// Source:        display.cpp
// Author:        Michele Estebon
// Date:          11/21/96
// For:           CS1704: Introduction to Data Structures and Software Design
// Last revision: 12/2/96
// Version:       1.1

/************************************************************************
   Display functions 
   Implements:
        IOwin       IO display bar
        statwin     Program Status display bar
        displaywin  General main display window
        menubar     Main menubar

   Provided functions:
        InitWindows   initializes above windows for display and sets colors
        IOerr         sends an error message to IOwin and beeps console
        IOin          gets user input from IOwin entered from keyboard
        IOout         sends message/prompt to IOwin
        StatusUpdate  displays left message, middle message and right message
                      to statwin.
        DisplayScr    displays a screenful (MAXLINES) at a time
                      and waits for a carriage return from keyboard  
*************************************************************************/

#include <string.h>  
#include <ctype.h>
#include <fstream.h>
#include "curses.h"
#include "display.h"
#include "bool.h" 
#include "globals.h" 
#include "listglob.h"
#include "dblist.h"


/*-- CONSTANTS ---------------------------------------------------------*/

#define  FAILURE      FALSE  // globals
#define  SUCCESS      TRUE   // globals

const  char     LINECHAR = '-';
const  int      BAR      = 0;   // line position for a bar window 


/*--- LOCAL FUNCTION PROTOTYPES -----------------------------------------*/

Boolean   SetMenu (winptr &mainwin, winptr &menubar );

Boolean   SetDisplay (winptr &mainwin, winptr &displaywin );

Boolean   SetIO (winptr &mainwin, winptr &IOwin );

Boolean   SetStat (winptr &mainwin, winptr &statwin );

void      DisplCat  (winptr& displaywin, char* filename);

void      DisplDoc(winptr& displaywin, char* filename, Boolean desc);

  
/************************************************************************/
//--------------------------------------------------------------------------\\    
//   FN:    InitWindows
//   IN:    ---
//   OUT:   ptrs to curses windows: mainwin, menubar, displaywin, IOwin, statwin
//   CALLS: curses.h: wattrset, newwin, wclear, touchwin, mvwaddch, wrefresh
//          SetMenu, SetDisplay, SetIO, SetStat
//   PRE:   ptrs to windows are previously declared and initialized
//   POST:  windows are created and ready for input and display
//   ****** Inits curses and creates main display windows
//--------------------------------------------------------------------------\\    
Boolean InitWindows (winptr &mainwin,
                     winptr &menubar,
                     winptr &displaywin,
                     winptr &IOwin,
                     winptr &statwin)
{
	int i; 
	
    initscr();
    mainwin = newwin(0,0,0,0);
    if (mainwin == null) 
        return (FAILURE); 
    wattrset( mainwin, B_CYAN | F_BLACK );
    wclear(mainwin);

    if ( SetMenu(   mainwin, menubar)    &&
         SetDisplay(mainwin, displaywin) &&
         SetIO(     mainwin, IOwin)      &&
         SetStat(   mainwin, statwin) );
    else return (FAILURE);

    for (i=0; i<WIDTH; i++)    // draw window divider lines across screen
    {
        mvwaddch(mainwin, 1,          i, LINECHAR);
        mvwaddch(mainwin, (LENGTH-3), i, LINECHAR);
        mvwaddch(mainwin, (LENGTH-1), i, LINECHAR);
    }
    touchwin(mainwin);
    wrefresh(mainwin);
    return (SUCCESS);
}

//--------------------------------------------------------------------------\\    
//   FN:    SetMenu
//   IN:    mainwin ptr
//   OUT:   menubar window ptr
//   CALLS: curses.h: wattrset, subwin, wclear
//   PRE:   mainwin has been intialized
//   POST:  menubar pts to new subwindow positioned at top of screen
//--------------------------------------------------------------------------\\    
Boolean   SetMenu(winptr &mainwin, winptr &menubar )
{
    menubar = subwin( mainwin, 1, WIDTH-2, 0, 1 );
    if (menubar == null) return (FAILURE);
    wattrset( menubar, B_BLUE | F_RED | A_HIGH );
    wclear( menubar );
    return (SUCCESS); 
}

//--------------------------------------------------------------------------\\    
//   FN:    SetDisplay
//   IN:    mainwin ptr
//   OUT:   displaywin window ptr
//   CALLS: curses.h: wattrset, subwin, wclear
//   PRE:   mainwin has been intialized
//   POST:  displaywin pts to new subwindow positioned in center screen
//--------------------------------------------------------------------------\\    
Boolean   SetDisplay(winptr &mainwin, winptr &displaywin )
{
    displaywin = subwin( mainwin,(LENGTH-5), WIDTH-2, 2, 1 );
    if (displaywin == null) return (FAILURE);
    wattrset( displaywin, DISPCOLORS );
    wclear( displaywin );
    return (SUCCESS); 
}

//--------------------------------------------------------------------------\\    
//   FN:    SetIO
//   IN:    mainwin ptr
//   OUT:   IOwin window ptr
//   CALLS: curses.h: wattrset, subwin, wclear
//   PRE:   mainwin has been intialized
//   POST:  IOwin pts to new subwindow positioned below displaywin
//--------------------------------------------------------------------------\\    
Boolean   SetIO(winptr &mainwin, winptr &IOwin )
{
    IOwin = subwin( mainwin, 1, WIDTH-2, LENGTH-2, 1);
    if (IOwin == null) return (FAILURE);
    wattrset( IOwin, IOCOLORS );
    wclear( IOwin );
    return (SUCCESS); 
}

//--------------------------------------------------------------------------\\    
//   FN:    SetSat
//   IN:    mainwin ptr
//   OUT:   statwin window ptr
//   CALLS: curses.h: wattrset, subwin, wclear
//   PRE:   mainwin has been intialized
//   POST:  statwin pts to new subwindow positioned at bottom of screen
//--------------------------------------------------------------------------\\    
Boolean   SetStat(winptr &mainwin, winptr &statwin )
{
    statwin = subwin( mainwin, 1, WIDTH-2, LENGTH, 1 );
    if (statwin == null) return (FAILURE);
    wattrset( statwin, STATCOLORS );
    wclear( statwin );
    return (SUCCESS); 
}

//--------------------------------------------------------------------------\\    
//   FN:    IOin
//   IN:    IOwin
//   OUT:   string input
//   CALLS: wclear, mvwaddstr, wgetstr, wrefresh (curses.h); Wait
//   PRE:   IOwin is intialized
//   POST:  user has input string and user is notified to wait
//   *****  gets a character string from IOwin 
//--------------------------------------------------------------------------\\    
void IOin(winptr &IOwin, string80& input )
{                
    char* upinput;
    
    Buffin();
    wgetstr(IOwin, input );
    Wait(IOwin);                      // wait message displayed to IOwin
    upinput = strupr(input);
	strcpy(input, upinput);    
}

//--------------------------------------------------------------------------\\    
//   FN:    Wait
//   IN:    IOwin
//   OUT:   ---
//   CALLS: curses.h: wclear, mvwaddstr, wrefresh
//   PRE:   IOwin is initialized
//   POST:  A wait messgae is diplayed to the IO window
//   *****  Displays a wait message to IOwin after input is received 
//--------------------------------------------------------------------------\\    
void Wait(winptr &IOwin)
{              
    wclear(IOwin);
    mvwaddstr(IOwin, 0,1, WAIT_MSG);
    wrefresh(IOwin);
}

//--------------------------------------------------------------------------\\    
//   FN:    IOerr
//   IN:    IOwin, errmsg
//   OUT:   --- 
//   CALLS: curses.h: wclear, beep, mvwaddstr, wrefresh
//   PRE:   IOwin is initialized
//   POST:  err amsg is displayed to screen IOwin
//   ****** Beeps and displays an error message to IOwin on screen 
//--------------------------------------------------------------------------\\    
void IOerr(winptr &IOwin, char* errmsg )
{
    wclear(IOwin); 
    mvwaddstr(IOwin, 0,1, errmsg); 
    wrefresh(IOwin);
}

//--------------------------------------------------------------------------\\    
//   FN:    IOout
//   IN:    message
//   OUT:   ---
//   CALLS: curses.h: wclear, mvwaddstr, touchwin, wrefresh
//   PRE:   IOwin is intialized
//   POST:  message is displayed to screen IOwin 
//--------------------------------------------------------------------------\\    
void IOout( winptr &IOwin, char* message )
{
    wclear(IOwin);
    mvwaddstr(IOwin, 0,1, message);
}

//--------------------------------------------------------------------------\\    
//   FN:    StatusUpdate
//   IN:    leftstr, midstr, rightstr
//   OUT:   ---
//   CALLS: wclear, mvwaddstr (curses.h); strlen (string.h); Reversetxt, Normaltxt
//   PRE:   
//   POST:  
//   ****** Displays leftstr, midstr, rightstr to statwin 
//--------------------------------------------------------------------------\\    
void StatusUpdate( winptr &statwin, char* leftstr,
                                    char* midstr,
                                    nodeptr curptr )
{
    int mid, right;   
    string rightstr;

    if (curptr!=null)
       GetItem(curptr, rightstr);
    else strcpy(rightstr,"NO FILE");
   
    right = WIDTH-(strlen(rightstr)+5);   // position right string
    mid = (WIDTH/2)-(strlen(midstr)/2);   // position middle string
    wclear(statwin);
    mvwaddstr(statwin, 0, 1, leftstr);
    wattron(statwin, A_REVERSE);
    mvwaddstr(statwin, BAR, mid, midstr);
    ResetColors(statwin, STATCOLORS);
    mvwaddstr(statwin, 0, right, rightstr);
}                                  


//--------------------------------------------------------------------------\\    
//   FN:    Reversetxt
//   IN:    winptr window
//   OUT:   ---
//   CALLS: wattrset (curses.h)
//   PRE:   window is initialized
//   POST:  window is ready to input and display REVERSE text 
//   *****  Reverses text display, but window must be cleared in order to
//          reverse entire window.
//--------------------------------------------------------------------------\\    
void Reversetxt( winptr &win )
{
    wattron( win, A_REVERSE );
}

//--------------------------------------------------------------------------\\    
//   FN:    Normaltxt
//   IN:    winptr
//   OUT:   ---
//   CALLS: wattrset (curses.h)
//   PRE:   window is initialized
//   POST:  window is ready to input and display NORMAL text 
//--------------------------------------------------------------------------\\    
void Normaltxt( winptr &win )
{          
   wattroff( win, A_REVERSE); 
}

//--------------------------------------------------------------------------\\    
//   FN:    Displaywin 
//   IN:    filename, desc
//   OUT:   displaywin, IOwin - modified
//   CALLS: strcpy, strstr (string.h); wclear, wrefresh (curses.h); DisplCat,
//          DisplDoc (docops.h), Fexists (globals.h), IOerr (display.h)
//   PRE:   
//   POST:  file is displayed
//   ****** Displays a file to displaywin. Type of type determines how display
//          is drawn. For a documentation file, desc (when TRUE) designates
//          description display, desc==FALSE means display Codeinfo. Files with
//          CATEXT extensions have header descriptions displayed.
//--------------------------------------------------------------------------\\    
void Displayfile (winptr& displaywin, 
                  winptr &IOwin ,
				  char* filename, 
				  Boolean desc)
{    
	Boolean terminated = FALSE;
	int linenum = 0;

    wclear(displaywin);  
    scrollok(displaywin,TRUE);    
    wmove(displaywin, 0,0);
	if (!Fexists(filename))
	{
		IOerr(IOwin, NO_FILE);
		wrefresh(displaywin);
	}
    else 
    {
        if (strstr(filename,CATEXT))
            DisplCat(displaywin,filename);
        else
            DisplDoc(displaywin, filename, desc);  
        wrefresh(displaywin);
    } 
}

//--------------------------------------------------------------------------\\    
//   FN:    DisplCat
//   IN:    
//   OUT:   
//   CALLS: wclear, mvwaddstr, wrefresh (curses.h)
//   PRE:   file existance has already been checked
//   POST:  File is displayed to displaywin.
//   ****** 
//--------------------------------------------------------------------------\\    
void DisplCat( winptr& displaywin, char* filename)
{
	ifstream infile;
	Boolean terminated = FALSE;
	string80 line;  
	int linenum = 0;

	infile.open(filename); 
	if (infile.getline(line, LINELN))
			mvwaddstr(displaywin, linenum++, 1,line);
	
	while (infile.getline(line,LINELN) && (!terminated) && (linenum<DISPLN) )
	{
		terminated = (line[0] == TERMINATOR) || (linenum>C_ENDHDR+1);
		if (!terminated)
			mvwaddstr(displaywin, ++linenum, 1,line);
	} 
	infile.close();
}

//--------------------------------------------------------------------------\\    
//   FN:    DisplDoc
//   IN:    filename, desc
//   OUT:   displaywin
//   CALLS: wclear, mvwaddstr, wrefresh
//   PRE:   file existance has already been checked
//   POST:  file is displayed to displaywin
//   ****** Displays documentation file to displaywin. If desc == TRUE, description
//          info is displayed, else Codeinfo is displayed. 
//--------------------------------------------------------------------------\\    
void DisplDoc(winptr& displaywin, char* filename, Boolean desc)
{
	string80 line;
	int linenum; 
	ifstream infile;

	infile.open(filename);
	for (linenum=0; linenum<DOCHDCT; linenum++)
	{
		infile.getline(line,LINELN);
		if (!desc)
			mvwaddstr(displaywin, linenum, 1, line);
	}
	if (desc)
	{
		linenum=0;
		while ( (infile.getline(line,LINELN)) && (line[0]!= TERMINATOR) )
			mvwaddstr(displaywin, linenum++, 1, line);
	}
	infile.close();
}
               
//--------------------------------------------------------------------------\\    
//   FN:    ResetWin
//   IN:    window
//   OUT:   ---
//   CALLS: touchwin, wrefresh (curses.h)
//   PRE:   ---
//   POST:  window has been refreshed on screen
//--------------------------------------------------------------------------\\    
void ResetWin (winptr &window)
{
    touchwin(window);
    wrefresh(window);
}