[deliverable/binutils-gdb.git] / gdb / tui / tuiGeneralWin.c

/*
   ** TuiGeneralWin.c
   ** This module supports general window behavior
 */

#include "defs.h"
#include "tui.h"
#include "tuiData.h"
#include "tuiGeneralWin.h"


/*
   ** local support functions
 */
static void _winResize (void);


/***********************
** PUBLIC FUNCTIONS
***********************/
/*
   ** tuiRefreshWin()
   **        Refresh the window
 */
void
#ifdef __STDC__
tuiRefreshWin (
		TuiGenWinInfoPtr winInfo)
#else
tuiRefreshWin (winInfo)
     TuiGenWinInfoPtr winInfo;
#endif
{
  if (winInfo->type == DATA_WIN && winInfo->contentSize > 0)
    {
      int i;

      for (i = 0; (i < winInfo->contentSize); i++)
	{
	  TuiGenWinInfoPtr dataItemWinPtr;

	  dataItemWinPtr = &((TuiWinContent)
			     winInfo->content)[i]->whichElement.dataWindow;
	  if (m_genWinPtrNotNull (dataItemWinPtr) &&
	      dataItemWinPtr->handle != (WINDOW *) NULL)
	    wrefresh (dataItemWinPtr->handle);
	}
    }
  else if (winInfo->type == CMD_WIN)
    {
      /* Do nothing */
    }
  else
    {
      if (winInfo->handle != (WINDOW *) NULL)
	wrefresh (winInfo->handle);
    }

  return;
}				/* tuiRefreshWin */


/*
   ** tuiDelwin()
   **        Function to delete the curses window, checking for null
 */
void
#ifdef __STDC__
tuiDelwin (
	    WINDOW * window)
#else
tuiDelwin (window)
     WINDOW *window;
#endif
{
  if (window != (WINDOW *) NULL)
    delwin (window);

  return;
}				/* tuiDelwin */


/*
   ** boxWin().
 */
void
#ifdef __STDC__
boxWin (
	 TuiGenWinInfoPtr winInfo,
	 int highlightFlag)
#else
boxWin (winInfo, highlightFlag)
     TuiGenWinInfoPtr winInfo;
     int highlightFlag;
#endif
{
  if (m_genWinPtrNotNull (winInfo) && winInfo->handle != (WINDOW *) NULL)
    {
      if (highlightFlag == HILITE)
	box (winInfo->handle, '|', '-');
      else
	{
/*            wattron(winInfo->handle, A_DIM); */
	  box (winInfo->handle, ':', '.');
/*            wattroff(winInfo->handle, A_DIM); */
	}
    }

  return;
}				/* boxWin */


/*
   ** unhighlightWin().
 */
void
#ifdef __STDC__
unhighlightWin (
		 TuiWinInfoPtr winInfo)
#else
unhighlightWin (winInfo)
     TuiWinInfoPtr winInfo;
#endif
{
  if (m_winPtrNotNull (winInfo) && winInfo->generic.handle != (WINDOW *) NULL)
    {
      boxWin ((TuiGenWinInfoPtr) winInfo, NO_HILITE);
      wrefresh (winInfo->generic.handle);
      m_setWinHighlightOff (winInfo);
    }
}				/* unhighlightWin */


/*
   ** highlightWin().
 */
void
#ifdef __STDC__
highlightWin (
	       TuiWinInfoPtr winInfo)
#else
highlightWin (winInfo)
     TuiWinInfoPtr winInfo;
#endif
{
  if (m_winPtrNotNull (winInfo) &&
      winInfo->canHighlight && winInfo->generic.handle != (WINDOW *) NULL)
    {
      boxWin ((TuiGenWinInfoPtr) winInfo, HILITE);
      wrefresh (winInfo->generic.handle);
      m_setWinHighlightOn (winInfo);
    }
}				/* highlightWin */


/*
   ** checkAndDisplayHighlightIfNecessay
 */
void
#ifdef __STDC__
checkAndDisplayHighlightIfNeeded (
				   TuiWinInfoPtr winInfo)
#else
checkAndDisplayHighlightIfNeeded (winInfo)
     TuiWinInfoPtr winInfo;
#endif
{
  if (m_winPtrNotNull (winInfo) && winInfo->generic.type != CMD_WIN)
    {
      if (winInfo->isHighlighted)
	highlightWin (winInfo);
      else
	unhighlightWin (winInfo);

    }
  return;
}				/* checkAndDisplayHighlightIfNeeded */


/*
   ** makeWindow().
 */
void
#ifdef __STDC__
makeWindow (
	     TuiGenWinInfoPtr winInfo,
	     int boxIt)
#else
makeWindow (winInfo, boxIt)
     TuiGenWinInfoPtr winInfo;
     int boxIt;
#endif
{
  WINDOW *handle;

  handle = newwin (winInfo->height,
		   winInfo->width,
		   winInfo->origin.y,
		   winInfo->origin.x);
  winInfo->handle = handle;
  if (handle != (WINDOW *) NULL)
    {
      if (boxIt == BOX_WINDOW)
	boxWin (winInfo, NO_HILITE);
      winInfo->isVisible = TRUE;
      scrollok (handle, TRUE);
      tuiRefreshWin (winInfo);

#ifndef FOR_TEST
      if (			/*!m_WinIsAuxillary(winInfo->type) && */
	   (winInfo->type != CMD_WIN) &&
	   (winInfo->content == (OpaquePtr) NULL))
	{
	  mvwaddstr (handle, 1, 1, winName (winInfo));
	  tuiRefreshWin (winInfo);
	}
#endif /*FOR_TEST */
    }

  return;
}				/* makeWindow */


/*
   ** tuiClearWin().
   **        Clear the window of all contents without calling wclear.
 */
void
#ifdef __STDC__
tuiClearWin (
	      TuiGenWinInfoPtr winInfo)
#else
tuiClearWin (winInfo)
     TuiGenWinInfoPtr winInfo;
#endif
{
  if (m_genWinPtrNotNull (winInfo) && winInfo->handle != (WINDOW *) NULL)
    {
      int curRow, curCol;

      for (curRow = 0; (curRow < winInfo->height); curRow++)
	for (curCol = 0; (curCol < winInfo->width); curCol++)
	  mvwaddch (winInfo->handle, curRow, curCol, ' ');

      tuiRefreshWin (winInfo);
    }

  return;
}				/* tuiClearWin */


/*
   ** makeVisible().
   **        We can't really make windows visible, or invisible.  So we
   **        have to delete the entire window when making it visible,
   **        and create it again when making it visible.
 */
void
#ifdef __STDC__
makeVisible (
	      TuiGenWinInfoPtr winInfo,
	      int visible)
#else
makeVisible (winInfo, visible)
     TuiGenWinInfoPtr winInfo;
     int visible;
#endif
{
  /* Don't tear down/recreate command window */
  if (winInfo->type == CMD_WIN)
    return;

  if (visible)
    {
      if (!winInfo->isVisible)
	{
	  makeWindow (
		       winInfo,
	   (winInfo->type != CMD_WIN && !m_winIsAuxillary (winInfo->type)));
	  winInfo->isVisible = TRUE;
	}
      tuiRefreshWin (winInfo);
    }
  else if (!visible &&
	   winInfo->isVisible && winInfo->handle != (WINDOW *) NULL)
    {
      winInfo->isVisible = FALSE;
      tuiClearWin (winInfo);
      tuiDelwin (winInfo->handle);
      winInfo->handle = (WINDOW *) NULL;
    }

  return;
}				/* makeVisible */


/*
   ** makeAllVisible().
   **        Makes all windows invisible (except the command and locator windows)
 */
void
#ifdef __STDC__
makeAllVisible (
		 int visible)
#else
makeAllVisible (visible)
     int visible;
#endif
{
  int i;

  for (i = 0; i < MAX_MAJOR_WINDOWS; i++)
    {
      if (m_winPtrNotNull (winList[i]) &&
	  ((winList[i])->generic.type) != CMD_WIN)
	{
	  if (m_winIsSourceType ((winList[i])->generic.type))
	    makeVisible ((winList[i])->detail.sourceInfo.executionInfo,
			 visible);
	  makeVisible ((TuiGenWinInfoPtr) winList[i], visible);
	}
    }

  return;
}				/* makeAllVisible */


/*
   ** scrollWinForward
 */
void
#ifdef __STDC__
scrollWinForward (
		   TuiGenWinInfoPtr winInfo,
		   int numLines)
#else
scrollWinForward (winInfo, numLines)
     TuiGenWinInfoPtr winInfo;
     int numLines;
#endif
{
  if (winInfo->content != (OpaquePtr) NULL &&
      winInfo->lastVisibleLine < winInfo->contentSize - 1)
    {
      int i, firstLine, newLastLine;

      firstLine = winInfo->lastVisibleLine - winInfo->viewportHeight + 1;
      if (winInfo->lastVisibleLine + numLines > winInfo->contentSize)
	newLastLine = winInfo->contentSize - 1;
      else
	newLastLine = winInfo->lastVisibleLine + numLines - 1;

      for (i = (newLastLine - winInfo->viewportHeight);
	   (i <= newLastLine); i++)
	{
	  TuiWinElementPtr line;
	  int lineHeight;

	  line = (TuiWinElementPtr) winInfo->content[i];
	  if (line->highlight)
	    wstandout (winInfo->handle);
	  mvwaddstr (winInfo->handle,
		     i - (newLastLine - winInfo->viewportHeight),
		     1,
		     displayableWinContentOf (winInfo, line));
	  if (line->highlight)
	    wstandend (winInfo->handle);
	  lineHeight = winElementHeight (winInfo, line);
	  newLastLine += (lineHeight - 1);
	}
      winInfo->lastVisibleLine = newLastLine;
    }

  return;
}				/* scrollWinForward */


/*
   ** scrollWinBackward
 */
void
#ifdef __STDC__
scrollWinBackward (
		    TuiGenWinInfoPtr winInfo,
		    int numLines)
#else
scrollWinBackward (winInfo, numLines)
     TuiGenWinInfoPtr winInfo;
     int numLines;
#endif
{
  if (winInfo->content != (OpaquePtr) NULL &&
      (winInfo->lastVisibleLine - winInfo->viewportHeight) > 0)
    {
      int i, newLastLine, firstLine;

      firstLine = winInfo->lastVisibleLine - winInfo->viewportHeight + 1;
      if ((firstLine - numLines) < 0)
	newLastLine = winInfo->viewportHeight - 1;
      else
	newLastLine = winInfo->lastVisibleLine - numLines + 1;

      for (i = newLastLine - winInfo->viewportHeight; (i <= newLastLine); i++)
	{
	  TuiWinElementPtr line;
	  int lineHeight;

	  line = (TuiWinElementPtr) winInfo->content[i];
	  if (line->highlight)
	    wstandout (winInfo->handle);
	  mvwaddstr (winInfo->handle,
		     i - (newLastLine - winInfo->viewportHeight),
		     1,
		     displayableWinContentOf (winInfo, line));
	  if (line->highlight)
	    wstandend (winInfo->handle);
	  lineHeight = winElementHeight (winInfo, line);
	  newLastLine += (lineHeight - 1);
	}
      winInfo->lastVisibleLine = newLastLine;
    }

  return;
}				/* scrollWinBackward */


/*
   ** refreshAll().
   **        Function to refresh all the windows currently displayed
 */
void
#ifdef __STDC__
refreshAll (
	     TuiWinInfoPtr * list)
#else
refreshAll (list)
     TuiWinInfoPtr *list;
#endif
{
  TuiWinType type;
  TuiGenWinInfoPtr locator = locatorWinInfoPtr ();

  for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
    {
      if (list[type]->generic.isVisible)
	{
	  if (type == SRC_WIN || type == DISASSEM_WIN)
	    {
	      touchwin (list[type]->detail.sourceInfo.executionInfo->handle);
	      tuiRefreshWin (list[type]->detail.sourceInfo.executionInfo);
	    }
	  touchwin (list[type]->generic.handle);
	  tuiRefreshWin (&list[type]->generic);
	}
    }
  if (locator->isVisible)
    {
      touchwin (locator->handle);
      tuiRefreshWin (locator);
    }

  return;
}				/* refreshAll */


/*********************************
** Local Static Functions
*********************************/
Commit	Line	Data
c906108c	1	/*
c5aa993b JM	2	** TuiGeneralWin.c
	3	** This module supports general window behavior
	4	*/
c906108c	5
c906108c SS	6	#include "defs.h"
	7	#include "tui.h"
	8	#include "tuiData.h"
	9	#include "tuiGeneralWin.h"
	10
	11
	12	/*
c5aa993b JM	13	** local support functions
c5aa993b JM	14	*/
a14ed312	15	static void _winResize (void);
c906108c SS	16
	17
	18	/***********************
	19	** PUBLIC FUNCTIONS
	20	***********************/
	21	/*
c5aa993b JM	22	** tuiRefreshWin()
	23	** Refresh the window
	24	*/
c906108c SS	25	void
	26	#ifdef __STDC__
	27	tuiRefreshWin (
	28	TuiGenWinInfoPtr winInfo)
	29	#else
	30	tuiRefreshWin (winInfo)
	31	TuiGenWinInfoPtr winInfo;
	32	#endif
	33	{
	34	if (winInfo->type == DATA_WIN && winInfo->contentSize > 0)
	35	{
	36	int i;
	37
	38	for (i = 0; (i < winInfo->contentSize); i++)
	39	{
	40	TuiGenWinInfoPtr dataItemWinPtr;
	41
	42	dataItemWinPtr = &((TuiWinContent)
	43	winInfo->content)[i]->whichElement.dataWindow;
	44	if (m_genWinPtrNotNull (dataItemWinPtr) &&
	45	dataItemWinPtr->handle != (WINDOW *) NULL)
	46	wrefresh (dataItemWinPtr->handle);
	47	}
	48	}
	49	else if (winInfo->type == CMD_WIN)
	50	{
	51	/* Do nothing */
	52	}
	53	else
	54	{
	55	if (winInfo->handle != (WINDOW *) NULL)
	56	wrefresh (winInfo->handle);
	57	}
	58
	59	return;
	60	} /* tuiRefreshWin */
	61
	62
	63	/*
c5aa993b JM	64	** tuiDelwin()
	65	** Function to delete the curses window, checking for null
	66	*/
c906108c SS	67	void
	68	#ifdef __STDC__
	69	tuiDelwin (
	70	WINDOW * window)
	71	#else
	72	tuiDelwin (window)
	73	WINDOW *window;
	74	#endif
	75	{
	76	if (window != (WINDOW *) NULL)
	77	delwin (window);
	78
	79	return;
	80	} /* tuiDelwin */
	81
	82
	83	/*
c5aa993b JM	84	** boxWin().
c5aa993b JM	85	*/
c906108c SS	86	void
	87	#ifdef __STDC__
	88	boxWin (
	89	TuiGenWinInfoPtr winInfo,
	90	int highlightFlag)
	91	#else
	92	boxWin (winInfo, highlightFlag)
	93	TuiGenWinInfoPtr winInfo;
	94	int highlightFlag;
	95	#endif
	96	{
	97	if (m_genWinPtrNotNull (winInfo) && winInfo->handle != (WINDOW *) NULL)
	98	{
	99	if (highlightFlag == HILITE)
	100	box (winInfo->handle, '\|', '-');
	101	else
	102	{
c5aa993b	103	/* wattron(winInfo->handle, A_DIM); */
c906108c	104	box (winInfo->handle, ':', '.');
c5aa993b	105	/* wattroff(winInfo->handle, A_DIM); */
c906108c SS	106	}
	107	}
	108
	109	return;
	110	} /* boxWin */
	111
	112
	113	/*
c5aa993b JM	114	** unhighlightWin().
c5aa993b JM	115	*/
c906108c SS	116	void
	117	#ifdef __STDC__
	118	unhighlightWin (
	119	TuiWinInfoPtr winInfo)
	120	#else
	121	unhighlightWin (winInfo)
	122	TuiWinInfoPtr winInfo;
	123	#endif
	124	{
	125	if (m_winPtrNotNull (winInfo) && winInfo->generic.handle != (WINDOW *) NULL)
	126	{
	127	boxWin ((TuiGenWinInfoPtr) winInfo, NO_HILITE);
	128	wrefresh (winInfo->generic.handle);
	129	m_setWinHighlightOff (winInfo);
	130	}
	131	} /* unhighlightWin */
	132
	133
	134	/*
c5aa993b JM	135	** highlightWin().
c5aa993b JM	136	*/
c906108c SS	137	void
	138	#ifdef __STDC__
	139	highlightWin (
	140	TuiWinInfoPtr winInfo)
	141	#else
	142	highlightWin (winInfo)
	143	TuiWinInfoPtr winInfo;
	144	#endif
	145	{
	146	if (m_winPtrNotNull (winInfo) &&
	147	winInfo->canHighlight && winInfo->generic.handle != (WINDOW *) NULL)
	148	{
	149	boxWin ((TuiGenWinInfoPtr) winInfo, HILITE);
	150	wrefresh (winInfo->generic.handle);
	151	m_setWinHighlightOn (winInfo);
	152	}
	153	} /* highlightWin */
	154
	155
	156	/*
c5aa993b JM	157	** checkAndDisplayHighlightIfNecessay
c5aa993b JM	158	*/
c906108c SS	159	void
	160	#ifdef __STDC__
	161	checkAndDisplayHighlightIfNeeded (
	162	TuiWinInfoPtr winInfo)
	163	#else
	164	checkAndDisplayHighlightIfNeeded (winInfo)
	165	TuiWinInfoPtr winInfo;
	166	#endif
	167	{
	168	if (m_winPtrNotNull (winInfo) && winInfo->generic.type != CMD_WIN)
	169	{
	170	if (winInfo->isHighlighted)
	171	highlightWin (winInfo);
	172	else
	173	unhighlightWin (winInfo);
	174
	175	}
	176	return;
	177	} /* checkAndDisplayHighlightIfNeeded */
	178
	179
	180	/*
c5aa993b JM	181	** makeWindow().
c5aa993b JM	182	*/
c906108c SS	183	void
	184	#ifdef __STDC__
	185	makeWindow (
	186	TuiGenWinInfoPtr winInfo,
	187	int boxIt)
	188	#else
	189	makeWindow (winInfo, boxIt)
	190	TuiGenWinInfoPtr winInfo;
	191	int boxIt;
	192	#endif
	193	{
	194	WINDOW *handle;
	195
	196	handle = newwin (winInfo->height,
	197	winInfo->width,
	198	winInfo->origin.y,
	199	winInfo->origin.x);
	200	winInfo->handle = handle;
	201	if (handle != (WINDOW *) NULL)
	202	{
	203	if (boxIt == BOX_WINDOW)
	204	boxWin (winInfo, NO_HILITE);
	205	winInfo->isVisible = TRUE;
	206	scrollok (handle, TRUE);
	207	tuiRefreshWin (winInfo);
	208
	209	#ifndef FOR_TEST
	210	if ( /!m_WinIsAuxillary(winInfo->type) && /
	211	(winInfo->type != CMD_WIN) &&
	212	(winInfo->content == (OpaquePtr) NULL))
	213	{
	214	mvwaddstr (handle, 1, 1, winName (winInfo));
	215	tuiRefreshWin (winInfo);
	216	}
c5aa993b	217	#endif /FOR_TEST /
c906108c SS	218	}
	219
	220	return;
	221	} /* makeWindow */
	222
	223
	224	/*
c5aa993b JM	225	** tuiClearWin().
	226	** Clear the window of all contents without calling wclear.
	227	*/
c906108c SS	228	void
	229	#ifdef __STDC__
	230	tuiClearWin (
	231	TuiGenWinInfoPtr winInfo)
	232	#else
	233	tuiClearWin (winInfo)
	234	TuiGenWinInfoPtr winInfo;
	235	#endif
	236	{
	237	if (m_genWinPtrNotNull (winInfo) && winInfo->handle != (WINDOW *) NULL)
	238	{
	239	int curRow, curCol;
	240
	241	for (curRow = 0; (curRow < winInfo->height); curRow++)
	242	for (curCol = 0; (curCol < winInfo->width); curCol++)
	243	mvwaddch (winInfo->handle, curRow, curCol, ' ');
	244
	245	tuiRefreshWin (winInfo);
	246	}
	247
	248	return;
	249	} /* tuiClearWin */
	250
	251
	252	/*
c5aa993b JM	253	** makeVisible().
	254	** We can't really make windows visible, or invisible. So we
	255	** have to delete the entire window when making it visible,
	256	** and create it again when making it visible.
	257	*/
c906108c SS	258	void
	259	#ifdef __STDC__
	260	makeVisible (
	261	TuiGenWinInfoPtr winInfo,
	262	int visible)
	263	#else
	264	makeVisible (winInfo, visible)
	265	TuiGenWinInfoPtr winInfo;
	266	int visible;
	267	#endif
	268	{
	269	/* Don't tear down/recreate command window */
	270	if (winInfo->type == CMD_WIN)
	271	return;
	272
	273	if (visible)
	274	{
	275	if (!winInfo->isVisible)
	276	{
	277	makeWindow (
	278	winInfo,
	279	(winInfo->type != CMD_WIN && !m_winIsAuxillary (winInfo->type)));
	280	winInfo->isVisible = TRUE;
	281	}
	282	tuiRefreshWin (winInfo);
	283	}
	284	else if (!visible &&
	285	winInfo->isVisible && winInfo->handle != (WINDOW *) NULL)
	286	{
	287	winInfo->isVisible = FALSE;
	288	tuiClearWin (winInfo);
	289	tuiDelwin (winInfo->handle);
	290	winInfo->handle = (WINDOW *) NULL;
	291	}
	292
	293	return;
	294	} /* makeVisible */
	295
	296
	297	/*
c5aa993b JM	298	** makeAllVisible().
	299	** Makes all windows invisible (except the command and locator windows)
	300	*/
c906108c SS	301	void
	302	#ifdef __STDC__
	303	makeAllVisible (
	304	int visible)
	305	#else
	306	makeAllVisible (visible)
	307	int visible;
	308	#endif
	309	{
	310	int i;
	311
	312	for (i = 0; i < MAX_MAJOR_WINDOWS; i++)
	313	{
	314	if (m_winPtrNotNull (winList[i]) &&
	315	((winList[i])->generic.type) != CMD_WIN)
	316	{
	317	if (m_winIsSourceType ((winList[i])->generic.type))
	318	makeVisible ((winList[i])->detail.sourceInfo.executionInfo,
	319	visible);
	320	makeVisible ((TuiGenWinInfoPtr) winList[i], visible);
	321	}
	322	}
	323
	324	return;
	325	} /* makeAllVisible */
	326
	327
	328	/*
c5aa993b JM	329	** scrollWinForward
c5aa993b JM	330	*/
c906108c SS	331	void
	332	#ifdef __STDC__
	333	scrollWinForward (
	334	TuiGenWinInfoPtr winInfo,
	335	int numLines)
	336	#else
	337	scrollWinForward (winInfo, numLines)
	338	TuiGenWinInfoPtr winInfo;
	339	int numLines;
	340	#endif
	341	{
	342	if (winInfo->content != (OpaquePtr) NULL &&
	343	winInfo->lastVisibleLine < winInfo->contentSize - 1)
	344	{
	345	int i, firstLine, newLastLine;
	346
	347	firstLine = winInfo->lastVisibleLine - winInfo->viewportHeight + 1;
	348	if (winInfo->lastVisibleLine + numLines > winInfo->contentSize)
	349	newLastLine = winInfo->contentSize - 1;
	350	else
	351	newLastLine = winInfo->lastVisibleLine + numLines - 1;
	352
	353	for (i = (newLastLine - winInfo->viewportHeight);
	354	(i <= newLastLine); i++)
	355	{
	356	TuiWinElementPtr line;
	357	int lineHeight;
	358
	359	line = (TuiWinElementPtr) winInfo->content[i];
	360	if (line->highlight)
	361	wstandout (winInfo->handle);
	362	mvwaddstr (winInfo->handle,
	363	i - (newLastLine - winInfo->viewportHeight),
	364	1,
	365	displayableWinContentOf (winInfo, line));
	366	if (line->highlight)
	367	wstandend (winInfo->handle);
	368	lineHeight = winElementHeight (winInfo, line);
	369	newLastLine += (lineHeight - 1);
	370	}
	371	winInfo->lastVisibleLine = newLastLine;
	372	}
	373
	374	return;
	375	} /* scrollWinForward */
	376
	377
	378	/*
c5aa993b JM	379	** scrollWinBackward
c5aa993b JM	380	*/
c906108c SS	381	void
	382	#ifdef __STDC__
	383	scrollWinBackward (
	384	TuiGenWinInfoPtr winInfo,
	385	int numLines)
	386	#else
	387	scrollWinBackward (winInfo, numLines)
	388	TuiGenWinInfoPtr winInfo;
	389	int numLines;
	390	#endif
	391	{
	392	if (winInfo->content != (OpaquePtr) NULL &&
	393	(winInfo->lastVisibleLine - winInfo->viewportHeight) > 0)
	394	{
	395	int i, newLastLine, firstLine;
	396
	397	firstLine = winInfo->lastVisibleLine - winInfo->viewportHeight + 1;
	398	if ((firstLine - numLines) < 0)
	399	newLastLine = winInfo->viewportHeight - 1;
	400	else
	401	newLastLine = winInfo->lastVisibleLine - numLines + 1;
	402
	403	for (i = newLastLine - winInfo->viewportHeight; (i <= newLastLine); i++)
	404	{
	405	TuiWinElementPtr line;
	406	int lineHeight;
	407
	408	line = (TuiWinElementPtr) winInfo->content[i];
	409	if (line->highlight)
	410	wstandout (winInfo->handle);
	411	mvwaddstr (winInfo->handle,
	412	i - (newLastLine - winInfo->viewportHeight),
	413	1,
	414	displayableWinContentOf (winInfo, line));
	415	if (line->highlight)
	416	wstandend (winInfo->handle);
	417	lineHeight = winElementHeight (winInfo, line);
	418	newLastLine += (lineHeight - 1);
	419	}
	420	winInfo->lastVisibleLine = newLastLine;
	421	}
	422
	423	return;
	424	} /* scrollWinBackward */
	425
	426
	427	/*
c5aa993b JM	428	** refreshAll().
	429	** Function to refresh all the windows currently displayed
	430	*/
c906108c SS	431	void
	432	#ifdef __STDC__
	433	refreshAll (
	434	TuiWinInfoPtr * list)
	435	#else
	436	refreshAll (list)
	437	TuiWinInfoPtr *list;
	438	#endif
	439	{
	440	TuiWinType type;
	441	TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
	442
	443	for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
	444	{
	445	if (list[type]->generic.isVisible)
	446	{
	447	if (type == SRC_WIN \|\| type == DISASSEM_WIN)
	448	{
	449	touchwin (list[type]->detail.sourceInfo.executionInfo->handle);
	450	tuiRefreshWin (list[type]->detail.sourceInfo.executionInfo);
	451	}
	452	touchwin (list[type]->generic.handle);
	453	tuiRefreshWin (&list[type]->generic);
	454	}
	455	}
	456	if (locator->isVisible)
	457	{
	458	touchwin (locator->handle);
	459	tuiRefreshWin (locator);
	460	}
	461
	462	return;
	463	} /* refreshAll */
	464
	465
	466	/*********************************
	467	** Local Static Functions
	468	*********************************/