static long
params_to_pixels(TScreen *screen, String *params, Cardinal n)
{
int mult = 1;
const char *s;
int modifier;
switch (n > 2 ? 2 : n) {
case 2:
s = params[1];
if (CompareWidths(s, "PAGE", &modifier)) {
mult = (MaxRows(screen) + modifier) * FontHeight(screen);
} else if (CompareWidths(s, "HALFPAGE", &modifier)) {
mult = ((MaxRows(screen) + modifier) * FontHeight(screen)) / 2;
} else if (CompareWidths(s, "PIXEL", &modifier)) {
mult = 1;
} else {
/* else assume that it is Line */
mult = FontHeight(screen);
}
mult *= atoi(params[0]);
TRACE(("params_to_pixels(%s,%s) = %d\n", params[0], params[1], mult));
break;
case 1:
mult = atoi(params[0]) * FontHeight(screen); /* lines */
TRACE(("params_to_pixels(%s) = %d\n", params[0], mult));
break;
default:
mult = screen->scrolllines * FontHeight(screen);
TRACE(("params_to_pixels() = %d\n", mult));
break;
}
return mult;
}
//------------------------------------------------------------------------------
bool CvDatabaseUtility::Initialize2DArray(int**&ppArray, const char* szTable1Name, const char* szTable2Name, int iDefault /* = 0 */)
{
const int iCount1 = MaxRows(szTable1Name);
const int iCount2 = MaxRows(szTable2Name);
if(iCount1 <= 0 || iCount2 <= 0)
{
ppArray = NULL;
CvAssertMsg(false, "Cannot initialize array to 0 size.");
return false;
}
unsigned int iNumBytes = iCount1 * sizeof(int*) + iCount1 * iCount2 * sizeof(int);
unsigned char* pData = FNEW( unsigned char[iNumBytes], c_eCiv5GameplayDLL, 0 );
ppArray = (int**)pData;
ppArray[0] = (int*)( pData + iCount1 * sizeof(int*) );
for( int i = 0; i < iCount2; ++i )
{
ppArray[0][i] = iDefault;
}
for( int i = 1; i < iCount1; i++ )
{
ppArray[i] = ppArray[i-1] + iCount2;
for( int j = 0; j < iCount2; ++j )
{
ppArray[i][j] = iDefault;
}
}
return true;
}
/*
* This function dynamically adds support for wide-characters.
*/
void
ChangeToWide(TScreen * screen)
{
unsigned new_bufoffset = (OFF_COM2H + 1);
int savelines = screen->scrollWidget ? screen->savelines : 0;
if (screen->wide_chars)
return;
TRACE(("ChangeToWide\n"));
if (xtermLoadWideFonts(term, True)) {
if (savelines < 0)
savelines = 0;
ReallocateBufOffsets(&screen->allbuf, &screen->sbuf_address,
(unsigned) (MaxRows(screen) + savelines),
(unsigned) MaxCols(screen),
new_bufoffset);
if (screen->altbuf)
ReallocateBufOffsets(&screen->altbuf, &screen->abuf_address,
(unsigned) MaxRows(screen),
(unsigned) MaxCols(screen),
new_bufoffset);
screen->wide_chars = True;
term->num_ptrs = new_bufoffset;
screen->visbuf = &screen->allbuf[MAX_PTRS * savelines];
update_font_utf8_mode();
SetVTFont(term, screen->menu_font_number, TRUE, NULL);
}
TRACE(("...ChangeToWide\n"));
}
void
WindowScroll(XtermWidget xw, int top, Bool always GCC_UNUSED)
{
TScreen *screen = TScreenOf(xw);
#if OPT_SCROLL_LOCK
if (screen->allowScrollLock && (screen->scroll_lock && !always)) {
if (screen->scroll_dirty) {
screen->scroll_dirty = False;
ScrnRefresh(xw, 0, 0, MaxRows(screen), MaxCols(screen), False);
}
} else
#endif
{
int i;
if (top < -screen->savedlines) {
top = -screen->savedlines;
} else if (top > 0) {
top = 0;
}
if ((i = screen->topline - top) != 0) {
int lines;
int scrolltop, scrollheight, refreshtop;
if (screen->cursor_state)
HideCursor();
lines = i > 0 ? i : -i;
if (lines > MaxRows(screen))
lines = MaxRows(screen);
scrollheight = screen->max_row - lines + 1;
if (i > 0)
refreshtop = scrolltop = 0;
else {
scrolltop = lines;
refreshtop = scrollheight;
}
scrolling_copy_area(xw, scrolltop, scrollheight, -i);
screen->topline = top;
ScrollSelection(screen, i, True);
xtermClear2(xw,
OriginX(screen),
OriginY(screen) + refreshtop * FontHeight(screen),
(unsigned) Width(screen),
(unsigned) (lines * FontHeight(screen)));
ScrnRefresh(xw, refreshtop, 0, lines, MaxCols(screen), False);
#if OPT_BLINK_CURS || OPT_BLINK_TEXT
RestartBlinking(screen);
#endif
}
}
ScrollBarDrawThumb(screen->scrollWidget);
}
/*
* moves the cursor left n, no wrap around
*/
void
CursorBack(XtermWidget xw, int n)
{
#define WRAP_MASK (REVERSEWRAP | WRAPAROUND)
TScreen *screen = TScreenOf(xw);
int offset, in_row, length, rev;
int left = ScrnLeftMargin(xw);
int before = screen->cur_col;
if ((rev = (xw->flags & WRAP_MASK) == WRAP_MASK) != 0
&& screen->do_wrap) {
n--;
}
/* if the cursor is already before the left-margin, we have to let it go */
if (before < left)
left = 0;
if ((screen->cur_col -= n) < left) {
if (rev) {
in_row = ScrnRightMargin(xw) - left + 1;
offset = (in_row * screen->cur_row) + screen->cur_col - left;
if (offset < 0) {
length = in_row * MaxRows(screen);
offset += ((-offset) / length + 1) * length;
}
set_cur_row(screen, (offset / in_row));
set_cur_col(screen, (offset % in_row) + left);
do_xevents();
} else {
set_cur_col(screen, left);
}
}
ResetWrap(screen);
}
//------------------------------------------------------------------------------
bool CvDatabaseUtility::PopulateArrayByExistence(int*& pArray, const char* szTypeTableName, const char* szDataTableName, const char* szTypeColumn, const char* szFilterColumn, const char* szFilterValue)
{
InitializeArray(pArray, MaxRows(szTypeTableName), -1);
std::string strKey = "_PABE_";
strKey.append(szTypeTableName);
strKey.append(szDataTableName);
strKey.append(szFilterColumn);
Database::Results* pResults = GetResults(strKey);
if(pResults == NULL)
{
char szSQL[512];
sprintf_s(szSQL, "select %s.ID from %s inner join %s on %s = %s.Type where %s = ?", szTypeTableName, szDataTableName, szTypeTableName, szTypeColumn, szTypeTableName, szFilterColumn);
pResults = PrepareResults(strKey, szSQL);
if(pResults == NULL)
return false;
}
if(!pResults->Bind(1, szFilterValue, false))
{
CvAssertMsg(false, GetErrorMessage());
return false;
}
int idx = 0;
while(pResults->Step())
{
pArray[idx++] = pResults->GetInt(0);
}
pResults->Reset();
return true;
}
void
ScrollBarDrawThumb(Widget scrollWidget)
{
XtermWidget xw = getXtermWidget(scrollWidget);
if (xw != 0) {
TScreen *screen = TScreenOf(xw);
int thumbTop, thumbHeight, totalHeight;
thumbTop = ROW2INX(screen, screen->savedlines);
thumbHeight = MaxRows(screen);
totalHeight = thumbHeight + screen->savedlines;
XawScrollbarSetThumb(scrollWidget,
((float) thumbTop) / (float) totalHeight,
((float) thumbHeight) / (float) totalHeight);
}
}
/*
* moves the cursor left n, no wrap around
*/
void
CursorBack(TScreen * screen, int n)
{
int i, j, k, rev;
if ((rev = (term->flags & (REVERSEWRAP | WRAPAROUND)) ==
(REVERSEWRAP | WRAPAROUND)) != 0
&& screen->do_wrap)
n--;
if ((screen->cur_col -= n) < 0) {
if (rev) {
if ((i = ((j = MaxCols(screen))
* screen->cur_row) + screen->cur_col) < 0) {
k = j * MaxRows(screen);
i += ((-i) / k + 1) * k;
}
set_cur_row(screen, i / j);
set_cur_col(screen, i % j);
} else
set_cur_col(screen, 0);
}
screen->do_wrap = 0;
}
//------------------------------------------------------------------------------
bool CvDatabaseUtility::PopulateArrayByValue(int*& pArray, const char* szTypeTableName, const char* szDataTableName, const char* szTypeColumn, const char* szFilterColumn, const char* szFilterValue, const char* szValueColumn, int iDefaultValue /* = 0 */, int iMinArraySize /* = 0 */)
{
int iSize = MaxRows(szTypeTableName);
InitializeArray(pArray, (iSize<iMinArraySize)?iMinArraySize:iSize, iDefaultValue);
std::string strKey = "_PABV_";
strKey.append(szTypeTableName);
strKey.append(szDataTableName);
strKey.append(szFilterColumn);
strKey.append(szValueColumn);
Database::Results* pResults = GetResults(strKey);
if(pResults == NULL)
{
char szSQL[512];
sprintf_s(szSQL, "select %s.ID, %s from %s inner join %s on %s = %s.Type where %s = ?", szTypeTableName, szValueColumn, szDataTableName, szTypeTableName, szTypeColumn, szTypeTableName, szFilterColumn);
pResults = PrepareResults(strKey, szSQL);
if(pResults == NULL)
return false;
}
if(!pResults->Bind(1, szFilterValue, false))
{
CvAssertMsg(false, GetErrorMessage());
return false;
}
while(pResults->Step())
{
const int idx = pResults->GetInt(0);
const int value = pResults->GetInt(1);
pArray[idx] = value;
}
pResults->Reset();
return true;
}
/*ARGSUSED*/
static void
ScrollTextTo(
Widget scrollbarWidget,
XtPointer client_data GCC_UNUSED,
XtPointer call_data)
{
XtermWidget xw = getXtermWidget(scrollbarWidget);
if (xw != 0) {
float *topPercent = (float *) call_data;
TScreen *screen = TScreenOf(xw);
int thumbTop; /* relative to first saved line */
int newTopLine;
/*
* screen->savedlines : Number of offscreen text lines,
* MaxRows(screen) : Number of onscreen text lines,
*/
thumbTop = (int) (*topPercent
* (float) (screen->savedlines + MaxRows(screen)));
newTopLine = thumbTop - screen->savedlines;
WindowScroll(xw, newTopLine, True);
}
}
/* Resize the text window for a terminal screen, modifying the
* appropriate WM_SIZE_HINTS and taking advantage of bit gravity.
*/
void
DoResizeScreen(XtermWidget xw)
{
TScreen *screen = TScreenOf(xw);
int border = 2 * screen->border;
int min_wide = border + screen->fullVwin.sb_info.width;
int min_high = border;
XtGeometryResult geomreqresult;
Dimension reqWidth, reqHeight, repWidth, repHeight;
#ifndef NO_ACTIVE_ICON
VTwin *saveWin = WhichVWin(screen);
/* all units here want to be in the normal font units */
WhichVWin(screen) = &screen->fullVwin;
#endif /* NO_ACTIVE_ICON */
/*
* I'm going to try to explain, as I understand it, why we
* have to do XGetWMNormalHints and XSetWMNormalHints here,
* although I can't guarantee that I've got it right.
*
* In a correctly written toolkit program, the Shell widget
* parses the user supplied geometry argument. However,
* because of the way xterm does things, the VT100 widget does
* the parsing of the geometry option, not the Shell widget.
* The result of this is that the Shell widget doesn't set the
* correct window manager hints, and doesn't know that the
* user has specified a geometry.
*
* The XtVaSetValues call below tells the Shell widget to
* change its hints. However, since it's confused about the
* hints to begin with, it doesn't get them all right when it
* does the SetValues -- it undoes some of what the VT100
* widget did when it originally set the hints.
*
* To fix this, we do the following:
*
* 1. Get the sizehints directly from the window, going around
* the (confused) shell widget.
* 2. Call XtVaSetValues to let the shell widget know which
* hints have changed. Note that this may not even be
* necessary, since we're going to right ahead after that
* and set the hints ourselves, but it's good to put it
* here anyway, so that when we finally do fix the code so
* that the Shell does the right thing with hints, we
* already have the XtVaSetValues in place.
* 3. We set the sizehints directly, this fixing up whatever
* damage was done by the Shell widget during the
* XtVaSetValues.
*
* Gross, huh?
*
* The correct fix is to redo VTRealize, VTInitialize and
* VTSetValues so that font processing happens early enough to
* give back responsibility for the size hints to the Shell.
*
* Someday, we hope to have time to do this. Someday, we hope
* to have time to completely rewrite xterm.
*/
TRACE(("DoResizeScreen\n"));
#if 1 /* ndef nothack */
/*
* NOTE: the hints and the XtVaSetValues() must match.
*/
TRACE(("%s@%d -- ", __FILE__, __LINE__));
TRACE_WM_HINTS(xw);
getXtermSizeHints(xw);
xtermSizeHints(xw, ScrollbarWidth(screen));
/* These are obsolete, but old clients may use them */
xw->hints.width = MaxCols(screen) * FontWidth(screen) + xw->hints.min_width;
xw->hints.height = MaxRows(screen) * FontHeight(screen) + xw->hints.min_height;
#if OPT_MAXIMIZE
/* assure single-increment resize for fullscreen */
if (xw->work.ewmh[0].mode) {
xw->hints.width_inc = 1;
xw->hints.height_inc = 1;
}
#endif /* OPT_MAXIMIZE */
#endif
XSetWMNormalHints(screen->display, VShellWindow(xw), &xw->hints);
reqWidth = (Dimension) (MaxCols(screen) * FontWidth(screen) + min_wide);
reqHeight = (Dimension) (MaxRows(screen) * FontHeight(screen) + min_high);
#if OPT_MAXIMIZE
/* compensate for fullscreen mode */
if (xw->work.ewmh[0].mode) {
Screen *xscreen = DefaultScreenOfDisplay(xw->screen.display);
reqWidth = (Dimension) WidthOfScreen(xscreen);
reqHeight = (Dimension) HeightOfScreen(xscreen);
ScreenResize(xw, reqWidth, reqHeight, &xw->flags);
}
#endif /* OPT_MAXIMIZE */
TRACE(("...requesting screensize chars %dx%d, pixels %dx%d\n",
MaxRows(screen),
MaxCols(screen),
reqHeight, reqWidth));
geomreqresult = REQ_RESIZE((Widget) xw, reqWidth, reqHeight,
&repWidth, &repHeight);
if (geomreqresult == XtGeometryAlmost) {
TRACE(("...almost, retry screensize %dx%d\n", repHeight, repWidth));
geomreqresult = REQ_RESIZE((Widget) xw, repWidth,
repHeight, NULL, NULL);
}
if (geomreqresult != XtGeometryYes) {
/* The resize wasn't successful, so we might need to adjust
our idea of how large the screen is. */
TRACE(("...still no (%d) - resize the core-class\n", geomreqresult));
xw->core.widget_class->core_class.resize((Widget) xw);
}
#if 1 /* ndef nothack */
/*
* XtMakeResizeRequest() has the undesirable side-effect of clearing
* the window manager's hints, even on a failed request. This would
* presumably be fixed if the shell did its own work.
*/
if (xw->hints.flags
&& repHeight
&& repWidth) {
xw->hints.height = repHeight;
xw->hints.width = repWidth;
TRACE_HINTS(&xw->hints);
XSetWMNormalHints(screen->display, VShellWindow(xw), &xw->hints);
}
#endif
XSync(screen->display, False); /* synchronize */
if (xtermAppPending())
xevents();
#ifndef NO_ACTIVE_ICON
WhichVWin(screen) = saveWin;
#endif /* NO_ACTIVE_ICON */
}