/*
|
/*
|
** TuiGeneralWin.c
|
** TuiGeneralWin.c
|
** This module supports general window behavior
|
** This module supports general window behavior
|
*/
|
*/
|
|
|
#include <curses.h>
|
#include <curses.h>
|
#include "defs.h"
|
#include "defs.h"
|
#include "tui.h"
|
#include "tui.h"
|
#include "tuiData.h"
|
#include "tuiData.h"
|
#include "tuiGeneralWin.h"
|
#include "tuiGeneralWin.h"
|
|
|
|
|
/*
|
/*
|
** local support functions
|
** local support functions
|
*/
|
*/
|
static void _winResize PARAMS ((void));
|
static void _winResize PARAMS ((void));
|
|
|
|
|
/***********************
|
/***********************
|
** PUBLIC FUNCTIONS
|
** PUBLIC FUNCTIONS
|
***********************/
|
***********************/
|
/*
|
/*
|
** tuiRefreshWin()
|
** tuiRefreshWin()
|
** Refresh the window
|
** Refresh the window
|
*/
|
*/
|
void
|
void
|
#ifdef __STDC__
|
#ifdef __STDC__
|
tuiRefreshWin (
|
tuiRefreshWin (
|
TuiGenWinInfoPtr winInfo)
|
TuiGenWinInfoPtr winInfo)
|
#else
|
#else
|
tuiRefreshWin (winInfo)
|
tuiRefreshWin (winInfo)
|
TuiGenWinInfoPtr winInfo;
|
TuiGenWinInfoPtr winInfo;
|
#endif
|
#endif
|
{
|
{
|
if (winInfo->type == DATA_WIN && winInfo->contentSize > 0)
|
if (winInfo->type == DATA_WIN && winInfo->contentSize > 0)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; (i < winInfo->contentSize); i++)
|
for (i = 0; (i < winInfo->contentSize); i++)
|
{
|
{
|
TuiGenWinInfoPtr dataItemWinPtr;
|
TuiGenWinInfoPtr dataItemWinPtr;
|
|
|
dataItemWinPtr = &((TuiWinContent)
|
dataItemWinPtr = &((TuiWinContent)
|
winInfo->content)[i]->whichElement.dataWindow;
|
winInfo->content)[i]->whichElement.dataWindow;
|
if (m_genWinPtrNotNull (dataItemWinPtr) &&
|
if (m_genWinPtrNotNull (dataItemWinPtr) &&
|
dataItemWinPtr->handle != (WINDOW *) NULL)
|
dataItemWinPtr->handle != (WINDOW *) NULL)
|
wrefresh (dataItemWinPtr->handle);
|
wrefresh (dataItemWinPtr->handle);
|
}
|
}
|
}
|
}
|
else if (winInfo->type == CMD_WIN)
|
else if (winInfo->type == CMD_WIN)
|
{
|
{
|
/* Do nothing */
|
/* Do nothing */
|
}
|
}
|
else
|
else
|
{
|
{
|
if (winInfo->handle != (WINDOW *) NULL)
|
if (winInfo->handle != (WINDOW *) NULL)
|
wrefresh (winInfo->handle);
|
wrefresh (winInfo->handle);
|
}
|
}
|
|
|
return;
|
return;
|
} /* tuiRefreshWin */
|
} /* tuiRefreshWin */
|
|
|
|
|
/*
|
/*
|
** tuiDelwin()
|
** tuiDelwin()
|
** Function to delete the curses window, checking for null
|
** Function to delete the curses window, checking for null
|
*/
|
*/
|
void
|
void
|
#ifdef __STDC__
|
#ifdef __STDC__
|
tuiDelwin (
|
tuiDelwin (
|
WINDOW * window)
|
WINDOW * window)
|
#else
|
#else
|
tuiDelwin (window)
|
tuiDelwin (window)
|
WINDOW *window;
|
WINDOW *window;
|
#endif
|
#endif
|
{
|
{
|
if (window != (WINDOW *) NULL)
|
if (window != (WINDOW *) NULL)
|
delwin (window);
|
delwin (window);
|
|
|
return;
|
return;
|
} /* tuiDelwin */
|
} /* tuiDelwin */
|
|
|
|
|
/*
|
/*
|
** boxWin().
|
** boxWin().
|
*/
|
*/
|
void
|
void
|
#ifdef __STDC__
|
#ifdef __STDC__
|
boxWin (
|
boxWin (
|
TuiGenWinInfoPtr winInfo,
|
TuiGenWinInfoPtr winInfo,
|
int highlightFlag)
|
int highlightFlag)
|
#else
|
#else
|
boxWin (winInfo, highlightFlag)
|
boxWin (winInfo, highlightFlag)
|
TuiGenWinInfoPtr winInfo;
|
TuiGenWinInfoPtr winInfo;
|
int highlightFlag;
|
int highlightFlag;
|
#endif
|
#endif
|
{
|
{
|
if (m_genWinPtrNotNull (winInfo) && winInfo->handle != (WINDOW *) NULL)
|
if (m_genWinPtrNotNull (winInfo) && winInfo->handle != (WINDOW *) NULL)
|
{
|
{
|
if (highlightFlag == HILITE)
|
if (highlightFlag == HILITE)
|
box (winInfo->handle, '|', '-');
|
box (winInfo->handle, '|', '-');
|
else
|
else
|
{
|
{
|
/* wattron(winInfo->handle, A_DIM); */
|
/* wattron(winInfo->handle, A_DIM); */
|
box (winInfo->handle, ':', '.');
|
box (winInfo->handle, ':', '.');
|
/* wattroff(winInfo->handle, A_DIM); */
|
/* wattroff(winInfo->handle, A_DIM); */
|
}
|
}
|
}
|
}
|
|
|
return;
|
return;
|
} /* boxWin */
|
} /* boxWin */
|
|
|
|
|
/*
|
/*
|
** unhighlightWin().
|
** unhighlightWin().
|
*/
|
*/
|
void
|
void
|
#ifdef __STDC__
|
#ifdef __STDC__
|
unhighlightWin (
|
unhighlightWin (
|
TuiWinInfoPtr winInfo)
|
TuiWinInfoPtr winInfo)
|
#else
|
#else
|
unhighlightWin (winInfo)
|
unhighlightWin (winInfo)
|
TuiWinInfoPtr winInfo;
|
TuiWinInfoPtr winInfo;
|
#endif
|
#endif
|
{
|
{
|
if (m_winPtrNotNull (winInfo) && winInfo->generic.handle != (WINDOW *) NULL)
|
if (m_winPtrNotNull (winInfo) && winInfo->generic.handle != (WINDOW *) NULL)
|
{
|
{
|
boxWin ((TuiGenWinInfoPtr) winInfo, NO_HILITE);
|
boxWin ((TuiGenWinInfoPtr) winInfo, NO_HILITE);
|
wrefresh (winInfo->generic.handle);
|
wrefresh (winInfo->generic.handle);
|
m_setWinHighlightOff (winInfo);
|
m_setWinHighlightOff (winInfo);
|
}
|
}
|
} /* unhighlightWin */
|
} /* unhighlightWin */
|
|
|
|
|
/*
|
/*
|
** highlightWin().
|
** highlightWin().
|
*/
|
*/
|
void
|
void
|
#ifdef __STDC__
|
#ifdef __STDC__
|
highlightWin (
|
highlightWin (
|
TuiWinInfoPtr winInfo)
|
TuiWinInfoPtr winInfo)
|
#else
|
#else
|
highlightWin (winInfo)
|
highlightWin (winInfo)
|
TuiWinInfoPtr winInfo;
|
TuiWinInfoPtr winInfo;
|
#endif
|
#endif
|
{
|
{
|
if (m_winPtrNotNull (winInfo) &&
|
if (m_winPtrNotNull (winInfo) &&
|
winInfo->canHighlight && winInfo->generic.handle != (WINDOW *) NULL)
|
winInfo->canHighlight && winInfo->generic.handle != (WINDOW *) NULL)
|
{
|
{
|
boxWin ((TuiGenWinInfoPtr) winInfo, HILITE);
|
boxWin ((TuiGenWinInfoPtr) winInfo, HILITE);
|
wrefresh (winInfo->generic.handle);
|
wrefresh (winInfo->generic.handle);
|
m_setWinHighlightOn (winInfo);
|
m_setWinHighlightOn (winInfo);
|
}
|
}
|
} /* highlightWin */
|
} /* highlightWin */
|
|
|
|
|
/*
|
/*
|
** checkAndDisplayHighlightIfNecessay
|
** checkAndDisplayHighlightIfNecessay
|
*/
|
*/
|
void
|
void
|
#ifdef __STDC__
|
#ifdef __STDC__
|
checkAndDisplayHighlightIfNeeded (
|
checkAndDisplayHighlightIfNeeded (
|
TuiWinInfoPtr winInfo)
|
TuiWinInfoPtr winInfo)
|
#else
|
#else
|
checkAndDisplayHighlightIfNeeded (winInfo)
|
checkAndDisplayHighlightIfNeeded (winInfo)
|
TuiWinInfoPtr winInfo;
|
TuiWinInfoPtr winInfo;
|
#endif
|
#endif
|
{
|
{
|
if (m_winPtrNotNull (winInfo) && winInfo->generic.type != CMD_WIN)
|
if (m_winPtrNotNull (winInfo) && winInfo->generic.type != CMD_WIN)
|
{
|
{
|
if (winInfo->isHighlighted)
|
if (winInfo->isHighlighted)
|
highlightWin (winInfo);
|
highlightWin (winInfo);
|
else
|
else
|
unhighlightWin (winInfo);
|
unhighlightWin (winInfo);
|
|
|
}
|
}
|
return;
|
return;
|
} /* checkAndDisplayHighlightIfNeeded */
|
} /* checkAndDisplayHighlightIfNeeded */
|
|
|
|
|
/*
|
/*
|
** makeWindow().
|
** makeWindow().
|
*/
|
*/
|
void
|
void
|
#ifdef __STDC__
|
#ifdef __STDC__
|
makeWindow (
|
makeWindow (
|
TuiGenWinInfoPtr winInfo,
|
TuiGenWinInfoPtr winInfo,
|
int boxIt)
|
int boxIt)
|
#else
|
#else
|
makeWindow (winInfo, boxIt)
|
makeWindow (winInfo, boxIt)
|
TuiGenWinInfoPtr winInfo;
|
TuiGenWinInfoPtr winInfo;
|
int boxIt;
|
int boxIt;
|
#endif
|
#endif
|
{
|
{
|
WINDOW *handle;
|
WINDOW *handle;
|
|
|
handle = newwin (winInfo->height,
|
handle = newwin (winInfo->height,
|
winInfo->width,
|
winInfo->width,
|
winInfo->origin.y,
|
winInfo->origin.y,
|
winInfo->origin.x);
|
winInfo->origin.x);
|
winInfo->handle = handle;
|
winInfo->handle = handle;
|
if (handle != (WINDOW *) NULL)
|
if (handle != (WINDOW *) NULL)
|
{
|
{
|
if (boxIt == BOX_WINDOW)
|
if (boxIt == BOX_WINDOW)
|
boxWin (winInfo, NO_HILITE);
|
boxWin (winInfo, NO_HILITE);
|
winInfo->isVisible = TRUE;
|
winInfo->isVisible = TRUE;
|
scrollok (handle, TRUE);
|
scrollok (handle, TRUE);
|
tuiRefreshWin (winInfo);
|
tuiRefreshWin (winInfo);
|
|
|
#ifndef FOR_TEST
|
#ifndef FOR_TEST
|
if ( /*!m_WinIsAuxillary(winInfo->type) && */
|
if ( /*!m_WinIsAuxillary(winInfo->type) && */
|
(winInfo->type != CMD_WIN) &&
|
(winInfo->type != CMD_WIN) &&
|
(winInfo->content == (OpaquePtr) NULL))
|
(winInfo->content == (OpaquePtr) NULL))
|
{
|
{
|
mvwaddstr (handle, 1, 1, winName (winInfo));
|
mvwaddstr (handle, 1, 1, winName (winInfo));
|
tuiRefreshWin (winInfo);
|
tuiRefreshWin (winInfo);
|
}
|
}
|
#endif /*FOR_TEST */
|
#endif /*FOR_TEST */
|
}
|
}
|
|
|
return;
|
return;
|
} /* makeWindow */
|
} /* makeWindow */
|
|
|
|
|
/*
|
/*
|
** tuiClearWin().
|
** tuiClearWin().
|
** Clear the window of all contents without calling wclear.
|
** Clear the window of all contents without calling wclear.
|
*/
|
*/
|
void
|
void
|
#ifdef __STDC__
|
#ifdef __STDC__
|
tuiClearWin (
|
tuiClearWin (
|
TuiGenWinInfoPtr winInfo)
|
TuiGenWinInfoPtr winInfo)
|
#else
|
#else
|
tuiClearWin (winInfo)
|
tuiClearWin (winInfo)
|
TuiGenWinInfoPtr winInfo;
|
TuiGenWinInfoPtr winInfo;
|
#endif
|
#endif
|
{
|
{
|
if (m_genWinPtrNotNull (winInfo) && winInfo->handle != (WINDOW *) NULL)
|
if (m_genWinPtrNotNull (winInfo) && winInfo->handle != (WINDOW *) NULL)
|
{
|
{
|
int curRow, curCol;
|
int curRow, curCol;
|
|
|
for (curRow = 0; (curRow < winInfo->height); curRow++)
|
for (curRow = 0; (curRow < winInfo->height); curRow++)
|
for (curCol = 0; (curCol < winInfo->width); curCol++)
|
for (curCol = 0; (curCol < winInfo->width); curCol++)
|
mvwaddch (winInfo->handle, curRow, curCol, ' ');
|
mvwaddch (winInfo->handle, curRow, curCol, ' ');
|
|
|
tuiRefreshWin (winInfo);
|
tuiRefreshWin (winInfo);
|
}
|
}
|
|
|
return;
|
return;
|
} /* tuiClearWin */
|
} /* tuiClearWin */
|
|
|
|
|
/*
|
/*
|
** makeVisible().
|
** makeVisible().
|
** We can't really make windows visible, or invisible. So we
|
** We can't really make windows visible, or invisible. So we
|
** have to delete the entire window when making it visible,
|
** have to delete the entire window when making it visible,
|
** and create it again when making it visible.
|
** and create it again when making it visible.
|
*/
|
*/
|
void
|
void
|
#ifdef __STDC__
|
#ifdef __STDC__
|
makeVisible (
|
makeVisible (
|
TuiGenWinInfoPtr winInfo,
|
TuiGenWinInfoPtr winInfo,
|
int visible)
|
int visible)
|
#else
|
#else
|
makeVisible (winInfo, visible)
|
makeVisible (winInfo, visible)
|
TuiGenWinInfoPtr winInfo;
|
TuiGenWinInfoPtr winInfo;
|
int visible;
|
int visible;
|
#endif
|
#endif
|
{
|
{
|
/* Don't tear down/recreate command window */
|
/* Don't tear down/recreate command window */
|
if (winInfo->type == CMD_WIN)
|
if (winInfo->type == CMD_WIN)
|
return;
|
return;
|
|
|
if (visible)
|
if (visible)
|
{
|
{
|
if (!winInfo->isVisible)
|
if (!winInfo->isVisible)
|
{
|
{
|
makeWindow (
|
makeWindow (
|
winInfo,
|
winInfo,
|
(winInfo->type != CMD_WIN && !m_winIsAuxillary (winInfo->type)));
|
(winInfo->type != CMD_WIN && !m_winIsAuxillary (winInfo->type)));
|
winInfo->isVisible = TRUE;
|
winInfo->isVisible = TRUE;
|
}
|
}
|
tuiRefreshWin (winInfo);
|
tuiRefreshWin (winInfo);
|
}
|
}
|
else if (!visible &&
|
else if (!visible &&
|
winInfo->isVisible && winInfo->handle != (WINDOW *) NULL)
|
winInfo->isVisible && winInfo->handle != (WINDOW *) NULL)
|
{
|
{
|
winInfo->isVisible = FALSE;
|
winInfo->isVisible = FALSE;
|
tuiClearWin (winInfo);
|
tuiClearWin (winInfo);
|
tuiDelwin (winInfo->handle);
|
tuiDelwin (winInfo->handle);
|
winInfo->handle = (WINDOW *) NULL;
|
winInfo->handle = (WINDOW *) NULL;
|
}
|
}
|
|
|
return;
|
return;
|
} /* makeVisible */
|
} /* makeVisible */
|
|
|
|
|
/*
|
/*
|
** makeAllVisible().
|
** makeAllVisible().
|
** Makes all windows invisible (except the command and locator windows)
|
** Makes all windows invisible (except the command and locator windows)
|
*/
|
*/
|
void
|
void
|
#ifdef __STDC__
|
#ifdef __STDC__
|
makeAllVisible (
|
makeAllVisible (
|
int visible)
|
int visible)
|
#else
|
#else
|
makeAllVisible (visible)
|
makeAllVisible (visible)
|
int visible;
|
int visible;
|
#endif
|
#endif
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < MAX_MAJOR_WINDOWS; i++)
|
for (i = 0; i < MAX_MAJOR_WINDOWS; i++)
|
{
|
{
|
if (m_winPtrNotNull (winList[i]) &&
|
if (m_winPtrNotNull (winList[i]) &&
|
((winList[i])->generic.type) != CMD_WIN)
|
((winList[i])->generic.type) != CMD_WIN)
|
{
|
{
|
if (m_winIsSourceType ((winList[i])->generic.type))
|
if (m_winIsSourceType ((winList[i])->generic.type))
|
makeVisible ((winList[i])->detail.sourceInfo.executionInfo,
|
makeVisible ((winList[i])->detail.sourceInfo.executionInfo,
|
visible);
|
visible);
|
makeVisible ((TuiGenWinInfoPtr) winList[i], visible);
|
makeVisible ((TuiGenWinInfoPtr) winList[i], visible);
|
}
|
}
|
}
|
}
|
|
|
return;
|
return;
|
} /* makeAllVisible */
|
} /* makeAllVisible */
|
|
|
|
|
/*
|
/*
|
** scrollWinForward
|
** scrollWinForward
|
*/
|
*/
|
void
|
void
|
#ifdef __STDC__
|
#ifdef __STDC__
|
scrollWinForward (
|
scrollWinForward (
|
TuiGenWinInfoPtr winInfo,
|
TuiGenWinInfoPtr winInfo,
|
int numLines)
|
int numLines)
|
#else
|
#else
|
scrollWinForward (winInfo, numLines)
|
scrollWinForward (winInfo, numLines)
|
TuiGenWinInfoPtr winInfo;
|
TuiGenWinInfoPtr winInfo;
|
int numLines;
|
int numLines;
|
#endif
|
#endif
|
{
|
{
|
if (winInfo->content != (OpaquePtr) NULL &&
|
if (winInfo->content != (OpaquePtr) NULL &&
|
winInfo->lastVisibleLine < winInfo->contentSize - 1)
|
winInfo->lastVisibleLine < winInfo->contentSize - 1)
|
{
|
{
|
int i, firstLine, newLastLine;
|
int i, firstLine, newLastLine;
|
|
|
firstLine = winInfo->lastVisibleLine - winInfo->viewportHeight + 1;
|
firstLine = winInfo->lastVisibleLine - winInfo->viewportHeight + 1;
|
if (winInfo->lastVisibleLine + numLines > winInfo->contentSize)
|
if (winInfo->lastVisibleLine + numLines > winInfo->contentSize)
|
newLastLine = winInfo->contentSize - 1;
|
newLastLine = winInfo->contentSize - 1;
|
else
|
else
|
newLastLine = winInfo->lastVisibleLine + numLines - 1;
|
newLastLine = winInfo->lastVisibleLine + numLines - 1;
|
|
|
for (i = (newLastLine - winInfo->viewportHeight);
|
for (i = (newLastLine - winInfo->viewportHeight);
|
(i <= newLastLine); i++)
|
(i <= newLastLine); i++)
|
{
|
{
|
TuiWinElementPtr line;
|
TuiWinElementPtr line;
|
int lineHeight;
|
int lineHeight;
|
|
|
line = (TuiWinElementPtr) winInfo->content[i];
|
line = (TuiWinElementPtr) winInfo->content[i];
|
if (line->highlight)
|
if (line->highlight)
|
wstandout (winInfo->handle);
|
wstandout (winInfo->handle);
|
mvwaddstr (winInfo->handle,
|
mvwaddstr (winInfo->handle,
|
i - (newLastLine - winInfo->viewportHeight),
|
i - (newLastLine - winInfo->viewportHeight),
|
1,
|
1,
|
displayableWinContentOf (winInfo, line));
|
displayableWinContentOf (winInfo, line));
|
if (line->highlight)
|
if (line->highlight)
|
wstandend (winInfo->handle);
|
wstandend (winInfo->handle);
|
lineHeight = winElementHeight (winInfo, line);
|
lineHeight = winElementHeight (winInfo, line);
|
newLastLine += (lineHeight - 1);
|
newLastLine += (lineHeight - 1);
|
}
|
}
|
winInfo->lastVisibleLine = newLastLine;
|
winInfo->lastVisibleLine = newLastLine;
|
}
|
}
|
|
|
return;
|
return;
|
} /* scrollWinForward */
|
} /* scrollWinForward */
|
|
|
|
|
/*
|
/*
|
** scrollWinBackward
|
** scrollWinBackward
|
*/
|
*/
|
void
|
void
|
#ifdef __STDC__
|
#ifdef __STDC__
|
scrollWinBackward (
|
scrollWinBackward (
|
TuiGenWinInfoPtr winInfo,
|
TuiGenWinInfoPtr winInfo,
|
int numLines)
|
int numLines)
|
#else
|
#else
|
scrollWinBackward (winInfo, numLines)
|
scrollWinBackward (winInfo, numLines)
|
TuiGenWinInfoPtr winInfo;
|
TuiGenWinInfoPtr winInfo;
|
int numLines;
|
int numLines;
|
#endif
|
#endif
|
{
|
{
|
if (winInfo->content != (OpaquePtr) NULL &&
|
if (winInfo->content != (OpaquePtr) NULL &&
|
(winInfo->lastVisibleLine - winInfo->viewportHeight) > 0)
|
(winInfo->lastVisibleLine - winInfo->viewportHeight) > 0)
|
{
|
{
|
int i, newLastLine, firstLine;
|
int i, newLastLine, firstLine;
|
|
|
firstLine = winInfo->lastVisibleLine - winInfo->viewportHeight + 1;
|
firstLine = winInfo->lastVisibleLine - winInfo->viewportHeight + 1;
|
if ((firstLine - numLines) < 0)
|
if ((firstLine - numLines) < 0)
|
newLastLine = winInfo->viewportHeight - 1;
|
newLastLine = winInfo->viewportHeight - 1;
|
else
|
else
|
newLastLine = winInfo->lastVisibleLine - numLines + 1;
|
newLastLine = winInfo->lastVisibleLine - numLines + 1;
|
|
|
for (i = newLastLine - winInfo->viewportHeight; (i <= newLastLine); i++)
|
for (i = newLastLine - winInfo->viewportHeight; (i <= newLastLine); i++)
|
{
|
{
|
TuiWinElementPtr line;
|
TuiWinElementPtr line;
|
int lineHeight;
|
int lineHeight;
|
|
|
line = (TuiWinElementPtr) winInfo->content[i];
|
line = (TuiWinElementPtr) winInfo->content[i];
|
if (line->highlight)
|
if (line->highlight)
|
wstandout (winInfo->handle);
|
wstandout (winInfo->handle);
|
mvwaddstr (winInfo->handle,
|
mvwaddstr (winInfo->handle,
|
i - (newLastLine - winInfo->viewportHeight),
|
i - (newLastLine - winInfo->viewportHeight),
|
1,
|
1,
|
displayableWinContentOf (winInfo, line));
|
displayableWinContentOf (winInfo, line));
|
if (line->highlight)
|
if (line->highlight)
|
wstandend (winInfo->handle);
|
wstandend (winInfo->handle);
|
lineHeight = winElementHeight (winInfo, line);
|
lineHeight = winElementHeight (winInfo, line);
|
newLastLine += (lineHeight - 1);
|
newLastLine += (lineHeight - 1);
|
}
|
}
|
winInfo->lastVisibleLine = newLastLine;
|
winInfo->lastVisibleLine = newLastLine;
|
}
|
}
|
|
|
return;
|
return;
|
} /* scrollWinBackward */
|
} /* scrollWinBackward */
|
|
|
|
|
/*
|
/*
|
** refreshAll().
|
** refreshAll().
|
** Function to refresh all the windows currently displayed
|
** Function to refresh all the windows currently displayed
|
*/
|
*/
|
void
|
void
|
#ifdef __STDC__
|
#ifdef __STDC__
|
refreshAll (
|
refreshAll (
|
TuiWinInfoPtr * list)
|
TuiWinInfoPtr * list)
|
#else
|
#else
|
refreshAll (list)
|
refreshAll (list)
|
TuiWinInfoPtr *list;
|
TuiWinInfoPtr *list;
|
#endif
|
#endif
|
{
|
{
|
TuiWinType type;
|
TuiWinType type;
|
TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
|
TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
|
|
|
for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
|
for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
|
{
|
{
|
if (list[type]->generic.isVisible)
|
if (list[type]->generic.isVisible)
|
{
|
{
|
if (type == SRC_WIN || type == DISASSEM_WIN)
|
if (type == SRC_WIN || type == DISASSEM_WIN)
|
{
|
{
|
touchwin (list[type]->detail.sourceInfo.executionInfo->handle);
|
touchwin (list[type]->detail.sourceInfo.executionInfo->handle);
|
tuiRefreshWin (list[type]->detail.sourceInfo.executionInfo);
|
tuiRefreshWin (list[type]->detail.sourceInfo.executionInfo);
|
}
|
}
|
touchwin (list[type]->generic.handle);
|
touchwin (list[type]->generic.handle);
|
tuiRefreshWin (&list[type]->generic);
|
tuiRefreshWin (&list[type]->generic);
|
}
|
}
|
}
|
}
|
if (locator->isVisible)
|
if (locator->isVisible)
|
{
|
{
|
touchwin (locator->handle);
|
touchwin (locator->handle);
|
tuiRefreshWin (locator);
|
tuiRefreshWin (locator);
|
}
|
}
|
|
|
return;
|
return;
|
} /* refreshAll */
|
} /* refreshAll */
|
|
|
|
|
/*********************************
|
/*********************************
|
** Local Static Functions
|
** Local Static Functions
|
*********************************/
|
*********************************/
|
|
|
