/*	$OpenBSD: vs_msg.c,v 1.20 2017/04/18 01:45:35 deraadt Exp $	*/

/*-

 * Copyright (c) 1993, 1994

 *	The Regents of the University of California.  All rights reserved.

 * Copyright (c) 1992, 1993, 1994, 1995, 1996

 *	Keith Bostic.  All rights reserved.

 *

 * See the LICENSE file for redistribution information.

 */

#include "config.h"

#include <sys/types.h>

#include <sys/queue.h>

#include <sys/time.h>

#include <bitstring.h>

#include <ctype.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <unistd.h>

#include "../common/common.h"

#include "vi.h"

typedef enum {

	SCROLL_W,			/* User wait. */

	SCROLL_W_EX,			/* User wait, or enter : to continue. */

	SCROLL_W_QUIT			/* User wait, or enter q to quit. */

					/*

					 * SCROLL_W_QUIT has another semantic

					 * -- only wait if the screen is full

					 */

} sw_t;

static void	vs_divider(SCR *);

static void	vs_msgsave(SCR *, mtype_t, char *, size_t);

static void	vs_output(SCR *, mtype_t, const char *, int);

static void	vs_scroll(SCR *, int *, sw_t);

static void	vs_wait(SCR *, int *, sw_t);

/*

 * vs_busy --

 *	Display, update or clear a busy message.

 *

 * This routine is the default editor interface for vi busy messages.  It

 * implements a standard strategy of stealing lines from the bottom of the

 * vi text screen.  Screens using an alternate method of displaying busy

 * messages, e.g. X11 clock icons, should set their scr_busy function to the

 * correct function before calling the main editor routine.

 *

 * PUBLIC: void vs_busy(SCR *, const char *, busy_t);

 */

void

vs_busy(SCR *sp, const char *msg, busy_t btype)

{

	GS *gp;

	VI_PRIVATE *vip;

	static const char flagc[] = "|/-\\";

	/* Ex doesn't display busy messages. */

	/*

	 * Most of this routine is to deal with the screen sharing real estate

	 * between the normal edit messages and the busy messages.  Logically,

	 * all that's needed is something that puts up a message, periodically

	 * updates it, and then goes away.

	 */

	case BUSY_ON:

			break;

		/* Initialize state for updates. */

		/* Save the current cursor. */

		/* Display the busy message. */

	case BUSY_OFF:

			break;

		/*

		 * If the line isn't in use for another purpose, clear it.

		 * Always return to the original position.

		 */

		}

	case BUSY_UPDATE:

			break;

		/* Update no more than every 1/8 of a second. */

		}

		/* Display the update. */

	}

}

/*

 * vs_home --

 *	Home the cursor to the bottom row, left-most column.

 *

 * PUBLIC: void vs_home(SCR *);

 */

void

vs_home(SCR *sp)

{

}

/*

 * vs_update --

 *	Update a command.

 *

 * PUBLIC: void vs_update(SCR *, const char *, const char *);

 */

void

vs_update(SCR *sp, const char *m1, const char *m2)

{

	GS *gp;

	/*

	 * This routine displays a message on the bottom line of the screen,

	 * without updating any of the command structures that would keep it

	 * there for any period of time, i.e. it is overwritten immediately.

	 *

	 * It's used by the ex read and ! commands when the user's command is

	 * expanded, and by the ex substitution confirmation prompt.

	 */

	}

	/*

	 * Save the cursor position, the substitute-with-confirmation code

	 * will have already set it correctly.

	 */

	/* Clear the bottom line. */

	/*

	 * XXX

	 * Don't let long file names screw up the screen.

	 */

		len = 0;

	}

}

/*

 * vs_msg --

 *	Display ex output or error messages for the screen.

 *

 * This routine is the default editor interface for all ex output, and all ex

 * and vi error/informational messages.  It implements the standard strategy

 * of stealing lines from the bottom of the vi text screen.  Screens using an

 * alternate method of displaying messages, e.g. dialog boxes, should set their

 * scr_msg function to the correct function before calling the editor.

 *

 * PUBLIC: void vs_msg(SCR *, mtype_t, char *, size_t);

 */

void

vs_msg(SCR *sp, mtype_t mtype, char *line, size_t len)

{

	GS *gp;

	VI_PRIVATE *vip;

	const char *e, *s, *t;

	/*

	 * Ring the bell if it's scheduled.

	 *

	 * XXX

	 * Shouldn't we save this, too?

	 */

	}

	/*

	 * If vi is using the error line for text input, there's no screen

	 * real-estate for the error message.  Nothing to do without some

	 * information as to how important the error message is.

	 */

	/*

	 * Ex or ex controlled screen output.

	 *

	 * If output happens during startup, e.g., a .exrc file, we may be

	 * in ex mode but haven't initialized the screen.  Initialize here,

	 * and in this case, stay in ex mode.

	 *

	 * If the SC_SCR_EXWROTE bit is set, then we're switching back and

	 * forth between ex and vi, but the screen is trashed and we have

	 * to respect that.  Switch to ex mode long enough to put out the

	 * message.

	 *

	 * If the SC_EX_WAIT_NO bit is set, turn it off -- we're writing to

	 * the screen, so previous opinions are ignored.

	 */

			} else

		}

	}

	/* If the vi screen isn't ready, save the message. */

	}

	/* Save the cursor position. */

	/* If it's an ex output message, just write it out. */

	}

	/*

	 * If it's a vi message, strip the trailing <newline> so we can

	 * try and paste messages together.

	 */

	/*

	 * If a message won't fit on a single line, try to split on a <blank>.

	 * If a subsequent message fits on the same line, write a separator

	 * and output it.  Otherwise, put out a newline.

	 *

	 * Need up to two padding characters normally; a semi-colon and a

	 * separating space.  If only a single line on the screen, add some

	 * more for the trailing continuation message.

	 *

	 * XXX

	 * Assume that periods and semi-colons take up a single column on the

	 * screen.

	 *

	 * XXX

	 * There are almost certainly pathological cases that will break this

	 * code.

	 */

	else

		else  {

		}

	}

			break;

			else

		} else

		/*

		 * If the message ends in a period, discard it, we want to

		 * gang messages where possible.

		 */

			break;

	}

}

/*

 * vs_output --

 *	Output the text to the screen.

 */

static void

vs_output(SCR *sp, mtype_t mtype, const char *line, int llen)

{

	CHAR_T *kp;

	GS *gp;

	VI_PRIVATE *vip;

	int ch, len, tlen;

	const char *p, *t;

		/* Get the next physical line. */

		else

		/*

		 * The max is sp->cols characters, and we may have already

		 * written part of the line.

		 */

		/*

		 * If the first line output, do nothing.  If the second line

		 * output, draw the divider line.  If drew a full screen, we

		 * remove the divider line.  If it's a continuation line, move

		 * to the continuation point, else, move the screen up.

		 */

				}

				}

			}

				break;

		} else

		/* Error messages are in inverse video. */

		/* Display the line, doing character translation. */

#define	FLUSH {								\

	*cbp = '\0';							\

	(void)gp->scr_addstr(sp, cbuf, cbp - cbuf);			\

	cbp = cbuf;							\

}

			/*

			 * Replace tabs with spaces, there are places in

			 * ex that do column calculations without looking

			 * at <tabs> -- and all routines that care about

			 * <tabs> do their own expansions.  This catches

			 * <tabs> in things like tag search strings.

			 */

				ch = ' ';

		}

		/* Clear the rest of the line. */

		/* If we loop, it's a new line. */

		/* Reset for the next line. */

		}

	}

	/* Set up next continuation line. */

}

/*

 * vs_ex_resolve --

 *	Deal with ex message output.

 *

 * This routine is called when exiting a colon command to resolve any ex

 * output that may have occurred.

 *

 * PUBLIC: int vs_ex_resolve(SCR *, int *);

 */

int

vs_ex_resolve(SCR *sp, int *continuep)

{

	GS *gp;

	VI_PRIVATE *vip;

	sw_t wtype;

	/* If we ran any ex command, we can't trust the cursor position. */

	/* Terminate any partially written message. */

	}

	/*

	 * If we switched out of the vi screen into ex, switch back while we

	 * figure out what to do with the screen and potentially get another

	 * command to execute.

	 *

	 * If we didn't switch into ex, we're not required to wait, and less

	 * than 2 lines of output, we can continue without waiting for the

	 * wait.

	 *

	 * Note, all other code paths require waiting, so we leave the report

	 * of modified lines until later, so that we won't wait for no other

	 * reason than a threshold number of lines were modified.  This means

	 * we display cumulative line modification reports for groups of ex

	 * commands.  That seems right to me (well, at least not wrong).

	 */

	} else

		}

	/* Clear the required wait flag, it's no longer needed. */

	/*

	 * Wait, unless explicitly told not to wait or the user interrupted

	 * the command.  If the user is leaving the screen, for any reason,

	 * they can't continue with further ex commands.

	 */

		    SC_FSWITCH | SC_SSWITCH) ? SCROLL_W : SCROLL_W_EX;

		else

	}

	/* If ex wrote on the screen, refresh the screen image. */

	/*

	 * If we're not the bottom of the split screen stack, the screen

	 * image itself is wrong, so redraw everything.

	 */

	/* If ex changed the underlying file, the map itself is wrong. */

	/* Ex may have switched out of the alternate screen, return. */

	/*

	 * Whew.  We're finally back home, after what feels like years.

	 * Kiss the ground.

	 */

	/*

	 * We may need to repaint some of the screen, e.g.:

	 *

	 *	:set

	 *	:!ls

	 *

	 * gives us a combination of some lines that are "wrong", and a need

	 * for a full refresh.

	 */

		/* Set up the redraw of the overwritten lines. */

		/* Reset the count of overwriting lines. */

		/* Redraw. */

		/* Reset the count of overwriting lines. */

}

/*

 * vs_resolve --

 *	Deal with message output.

 *

 * PUBLIC: int vs_resolve(SCR *, SCR *, int);

 */

int

vs_resolve(SCR *sp, SCR *csp, int forcewait)

{

	GS *gp;

	MSGS *mp;

	VI_PRIVATE *vip;

	int redraw;

	/*

	 * Vs_resolve is called from the main vi loop and the refresh function

	 * to periodically ensure that the user has seen any messages that have

	 * been displayed and that any status lines are correct.  The sp screen

	 * is the screen we're checking, usually the current screen.  When it's

	 * not, csp is the current screen, used for final cursor positioning.

	 */

	/* Save the cursor position. */

	/* Ring the bell if it's scheduled. */

	}

	/* Display new file status line. */

	}

	/* Report on line modifications. */

	/*

	 * Flush any saved messages.  If the screen isn't ready, refresh

	 * it.  (A side-effect of screen refresh is that we can display

	 * messages.)  Once this is done, don't trust the cursor.  That

	 * extra refresh screwed the pooch.

	 */

		}

	}

	case 0:

		redraw = 0;

	case 1:

		/*

		 * If we're switching screens, we have to wait for messages,

		 * regardless.  If we don't wait, skip updating the modeline.

		 */

		else

		redraw = 0;

	default:

		/*

		 * If >1 message line in use, prompt the user to continue and

		 * repaint overwritten lines.

		 */

		redraw = 1;

	}

	/* Reset the count of overwriting lines. */

	/* Redraw. */

	/* Restore the cursor position. */

}

/*

 * vs_scroll --

 *	Scroll the screen for output.

 */

static void

vs_scroll(SCR *sp, int *continuep, sw_t wtype)

{

	GS *gp;

	VI_PRIVATE *vip;

		/*

		 * Scroll the screen.  Instead of scrolling the entire screen,

		 * delete the line above the first line output so preserve the

		 * maximum amount of the screen.

		 */

		/* If there are screens below us, push them back into place. */

		}

	}

}

/*

 * vs_wait --

 *	Prompt the user to continue.

 */

static void

vs_wait(SCR *sp, int *continuep, sw_t wtype)

{

	VI_PRIVATE *vip;

	const char *p;

	GS *gp;

	else

		case SCROLL_W_QUIT:

		case SCROLL_W_EX:

		case SCROLL_W:

		default:

			/* NOTREACHED */

		}

	/* Get a single character from the terminal. */

			break;

		}

	}

	case SCROLL_W_QUIT:

		break;

	case SCROLL_W_EX:

		break;

	case SCROLL_W:

		break;

	}

}

/*

 * vs_divider --

 *	Draw a dividing line between the screen and the output.

 */

static void

vs_divider(SCR *sp)

{

	GS *gp;

	size_t len;

#define	DIVIDESTR	"+=+=+=+=+=+=+=+"

	len =

}

/*

 * vs_msgsave --

 *	Save a message for later display.

 */

static void

vs_msgsave(SCR *sp, mtype_t mt, char *p, size_t len)

{

	GS *gp;

	MSGS *mp_c, *mp_n;

	/*

	 * We have to handle messages before we have any place to put them.

	 * If there's no screen support yet, allocate a msg structure, copy

	 * in the message, and queue it on the global structure.  If we can't

	 * allocate memory here, we're genuinely screwed, dump the message

	 * to stderr in the (probably) vain hope that someone will see it.

	 */

	}

alloc_err:

}