NetBSD/dist/cdk/cdk.c

1314 lines
26 KiB
C
Raw Normal View History

#include <cdk.h>
/*
* $Author: garbled $
* $Date: 2001/01/04 20:15:30 $
* $Revision: 1.2 $
*/
char *GPasteBuffer = 0;
/*
* This beeps then flushes the stdout stream.
*/
void Beep(void)
{
beep();
fflush (stdout);
}
/*
* This sets a string to the given character.
*/
void cleanChar (char *s, int len, char character)
{
int x;
for (x=0; x < len; x++)
{
s[x] = character;
}
s[--x] = '\0';
}
void cleanChtype (chtype *s, int len, chtype character)
{
int x;
for (x=0; x < len; x++)
{
s[x] = character;
}
s[--x] = '\0';
}
/*
* This takes an x and y position and realigns the values iff they sent in
* values like CENTER, LEFT, RIGHT, ...
*/
void alignxy (WINDOW *window, int *xpos, int *ypos, int boxWidth, int boxHeight)
{
int first, gap, last;
first = getbegx(window);
last = getmaxx(window);
if ((gap = (last - boxWidth)) < 0) gap = 0;
last = first + gap;
switch (*xpos)
{
case LEFT:
(*xpos) = first;
break;
case RIGHT:
(*xpos) = first + gap;
break;
case CENTER:
(*xpos) = first + (gap / 2);
break;
}
if ((*xpos) > last)
(*xpos) = last;
else if ((*xpos) < first)
(*xpos) = first;
first = getbegy(window);
last = getmaxy(window);
if ((gap = (last - boxHeight)) < 0) gap = 0;
last = first + gap;
switch (*ypos)
{
case TOP:
(*ypos) = first;
break;
case BOTTOM:
(*ypos) = first + gap;
break;
case CENTER:
(*ypos) = first + (gap/2);
break;
}
if ((*ypos) > last)
(*ypos) = last;
else if ((*ypos) < first)
(*ypos) = first;
}
/*
* This takes a string, a field width and a justifycation type
* and returns the justifcation adjustment to make, to fill
* the justification requirement.
*/
int justifyString (int boxWidth, int mesgLength, int justify)
{
/*
* Make sure the message isn't longer than the width.
* If it is, return 1.
*/
if (mesgLength >= boxWidth)
{
return (0);
}
/* Try to justify the message. */
if (justify == LEFT)
{
return (0);
}
else if (justify == RIGHT)
{
return ((boxWidth - mesgLength));
}
else if (justify == CENTER)
{
return ((int)((boxWidth - mesgLength) / 2));
}
else
{
return (justify);
}
}
/*
* This returns a substring of the given string.
*/
char *substring (char *string, int start, int width)
{
char *newstring = 0;
int mesglen = 0;
int y = 0;
int x = 0;
int lastchar = 0;
/* Make sure the string isn't null. */
if (string == 0)
{
return 0;
}
mesglen = (int)strlen (string);
/* Make sure we start in the correct place. */
if (start > mesglen)
{
return (newstring);
}
/* Create the new string. */
newstring = (char *)malloc (sizeof (char) * (width + 3));
/*cleanChar (newstring, width + 3, '\0');*/
if ((start + width) > mesglen)
{
lastchar = mesglen;
}
else
{
lastchar = width + start;
}
for (x=start; x<=lastchar; x++)
{
newstring[y++] = string[x];
}
newstring[lastchar + 1] = '\0';
newstring[lastchar + 2] = '\0';
return (newstring);
}
/*
* This frees a string if it is not null. This is a safety
* measure. Some compilers let you free a null string. I
* don't like that idea.
*/
void freeChar (char *string)
{
if (string != 0)
free (string);
}
void freeChtype (chtype *string)
{
if (string != 0)
free (string);
}
/*
* Corresponding list freeing
*/
void freeCharList (char **list, unsigned size)
{
while (size-- != 0) {
freeChar(list[size]);
list[size] = 0;
}
}
/*
* This performs a safe copy of a string. This means it adds the null
* terminator on the end of the string, like strdup().
*/
char *copyChar (char *original)
{
/* Declare local variables. */
char *newstring;
/* Make sure the string is not null. */
if (original == 0)
{
return 0;
}
newstring = (char *)malloc (strlen(original) + 1);
/* Copy from one to the other. */
strcpy (newstring, original);
/* Return the new string. */
return (newstring);
}
chtype *copyChtype (chtype *original)
{
/* Declare local variables. */
chtype *newstring;
int len, x;
/* Make sure the string is not null. */
if (original == 0)
{
return 0;
}
/* Create the new string. */
len = chlen (original);
newstring = (chtype *)malloc (sizeof(chtype) * (len + 4));
if (newstring == 0)
{
return (original);
}
/* Copy from one to the other. */
for (x=0; x < len; x++)
{
newstring[x] = original[x];
}
newstring[len] = '\0';
newstring[len + 1] = '\0';
/* Return the new string. */
return (newstring);
}
/*
* This reads a file and sticks it into the char ** provided.
*/
int readFile (char *filename, char **array, int maxlines)
{
FILE *fd;
char temp[BUFSIZ];
int lines = 0;
size_t len;
/* Can we open the file? */
if ((fd = fopen (filename, "r")) == 0)
{
return (-1);
}
/* Start reading the file in. */
while ((fgets (temp, sizeof(temp), fd) != 0) && lines < maxlines)
{
len = strlen (temp);
if (temp[len-1] == '\n')
{
temp[len-1] = '\0';
}
array[lines] = copyChar (temp);
lines++;
}
fclose (fd);
/* Clean up and return. */
return (lines);
}
#define DigitOf(c) ((c)-'0')
static int parseAttribute(char *string, int from, chtype *mask)
{
int pair = 0;
*mask = 0;
switch (string[from + 1])
{
case 'B': *mask = A_BOLD; break;
case 'D': *mask = A_DIM; break;
case 'K': *mask = A_BLINK; break;
case 'R': *mask = A_REVERSE; break;
case 'S': *mask = A_STANDOUT; break;
case 'U': *mask = A_UNDERLINE; break;
}
if (*mask != 0)
{
from++;
}
else if (isdigit((int)string[from + 1]) && isdigit((int)string[from + 2]))
{
#ifdef HAVE_START_COLOR
pair = DigitOf(string[from + 1]) * 10 + DigitOf(string[from + 2]);
*mask = COLOR_PAIR(pair);
#else
*mask = A_BOLD;
#endif
from += 2;
}
else if (isdigit((int)string[from + 1]))
{
#ifdef HAVE_START_COLOR
pair = DigitOf(string[from + 1]);
*mask = COLOR_PAIR(pair);
#else
*mask = A_BOLD;
#endif
from++;
}
return from;
}
/*
* This function takes a character string, full of format markers
* and translates them into a chtype * array. This is better suited
* to curses, because curses uses chtype almost exclusively
*/
chtype *char2Chtype (char *string, int *to, int *align)
{
chtype *result = 0;
chtype attrib;
chtype lastChar;
chtype mask;
int adjust;
int from;
int insideMarker;
int len;
int pass;
int start;
int used;
int x;
(*to) = 0;
*align = LEFT;
if (string != 0)
{
len = (int)strlen(string);
used = 0;
/*
* We make two passes because we may have indents and tabs to expand, and
* do not know in advance how large the result will be.
*/
for (pass = 0; pass < 2; pass++)
{
if (pass != 0)
{
if ((result = (chtype *)malloc((used+2) * sizeof(chtype))) == 0)
{
used = 0;
break;
}
}
adjust = 0;
attrib = A_NORMAL;
lastChar = 0;
start = 0;
used = 0;
x = 3;
/* Look for an alignment marker. */
if (!strncmp(string, "<C>", 3))
{
(*align) = CENTER;
start = 3;
}
else if (!strncmp(string, "<R>", 3))
{
(*align) = RIGHT;
start = 3;
}
else if (!strncmp(string, "<L>", 3))
{
start = 3;
}
else if (!strncmp(string, "<B=", 3))
{
/* Set the item index value in the string. */
if (result != 0)
{
result[0] = ' ';
result[1] = ' ';
result[2] = ' ';
}
/* Pull out the bullet marker. */
while (string[x] != '>' && string[x] != 0)
{
if (result != 0)
result[x] = string[x] | A_BOLD;
x++;
}
adjust = 1;
/* Set the alignment variables. */
start = x;
used = x;
}
else if (!strncmp(string, "<I=", 3))
{
from = 2;
x = 0;
while (string[++from] != '>' && string[from] != 0)
{
if (isdigit((int)string[from]))
{
adjust = (adjust * 10) + DigitOf(string[from]);
}
}
start = x + 4;
}
while (adjust-- > 0)
{
if (result != 0)
result[used] = ' ';
used++;
}
/* Set the format marker boolean to false. */
insideMarker = FALSE;
/* Start parsing the character string. */
for (from = start; from < len; from++)
{
/* Are we inside a format marker? */
if (! insideMarker)
{
if (string[from] == '<'
&& (string[from + 1] == '/'
|| string[from + 1] == '!'
|| string[from + 1] == '#'))
{
insideMarker = TRUE;
}
else if (string[from] == '\\' && string[from + 1] == '<')
{
from++;
if (result != 0)
result[used] = (A_CHARTEXT & string[from]) | attrib;
used++;
from++;
}
else if (string[from] == '\t')
{
for (x=0; x < 8; x++)
{
if (result != 0)
result[used] = ' ';
used++;
}
}
else
{
if (result != 0)
result[used] = (A_CHARTEXT & string[from]) | attrib;
used++;
}
}
else
{
switch (string[from])
{
case '>':
insideMarker = 0;
break;
case '#':
{
lastChar = 0;
switch(string[from + 2])
{
case 'L':
switch (string[from + 1])
{
case 'L': lastChar = ACS_LLCORNER; break;
case 'U': lastChar = ACS_LRCORNER; break;
case 'H': lastChar = ACS_HLINE; break;
case 'V': lastChar = ACS_VLINE; break;
case 'P': lastChar = ACS_PLUS; break;
}
break;
case 'U':
switch (string[from + 1])
{
case 'L': lastChar = ACS_ULCORNER; break;
case 'U': lastChar = ACS_URCORNER; break;
}
break;
case 'T':
switch (string[from + 1])
{
case 'T': lastChar = ACS_TTEE; break;
case 'R': lastChar = ACS_RTEE; break;
case 'L': lastChar = ACS_LTEE; break;
case 'B': lastChar = ACS_BTEE; break;
}
break;
case 'A':
switch (string[from + 1])
{
case 'L': lastChar = ACS_LARROW; break;
case 'R': lastChar = ACS_RARROW; break;
case 'U': lastChar = ACS_UARROW; break;
case 'D': lastChar = ACS_DARROW; break;
}
break;
default:
if (string[from + 1] == 'D'
&& string[from + 2] == 'I')
lastChar = ACS_DIAMOND;
else
if (string[from + 1] == 'C'
&& string[from + 2] == 'B')
lastChar = ACS_CKBOARD;
else
if (string[from + 1] == 'D'
&& string[from + 2] == 'G')
lastChar = ACS_DEGREE;
else
if (string[from + 1] == 'P'
&& string[from + 2] == 'M')
lastChar = ACS_PLMINUS;
else
if (string[from + 1] == 'B'
&& string[from + 2] == 'U')
lastChar = ACS_BULLET;
else
if (string[from + 1] == 'S'
&& string[from + 2] == '1')
lastChar = ACS_S1;
else
if (string[from + 1] == 'S'
&& string[from + 2] == '9')
lastChar = ACS_S9;
}
if (lastChar != 0)
{
adjust = 1;
from += 2;
if (string[from + 1] == '(')
/* Check for a possible numeric modifier. */
{
from++;
adjust = 0;
while (string[++from] != ')' && string[from] != 0)
{
if (isdigit((int)string[from]))
{
adjust = (adjust * 10) + DigitOf(string[from]);
}
}
}
}
for (x=0; x < adjust; x++)
{
if (result != 0)
result[used] = lastChar | attrib;
used++;
}
break;
}
case '/':
from = parseAttribute(string, from, &mask);
attrib = attrib | mask;
break;
case '!':
from = parseAttribute(string, from, &mask);
attrib = attrib & ~mask;
break;
}
}
}
if (result != 0)
{
result[used] = 0;
result[used + 1] = 0;
}
/*
* If there are no characters, put the attribute into the
* the first character of the array.
*/
if (used == 0
&& result != 0)
{
result[0] = attrib;
}
}
*to = used;
}
return result;
}
/*
* This determines the length of a chtype string
*/
int chlen (chtype *string)
{
int result = 0;
if (string != 0)
{
while (string[result] != 0)
result++;
}
return (result);
}
/*
* This returns a pointer to char * of a chtype *
*/
char *chtype2Char (chtype *string)
{
/* Declare local variables. */
char *newstring;
int len = 0;
int x;
/* Is the string null? */
if (string == 0)
{
return (0);
}
/* Get the length of the string. */
len = chlen(string);
/* Make the new string. */
newstring = (char *)malloc (sizeof (char) * (len + 1));
/*cleanChar (newstring, len + 1, '\0');*/
/* Start translating. */
for (x=0; x < len; x++)
{
newstring[x] = (char)(string[x] & A_CHARTEXT);
}
/* Force a null character on the end of the string. */
newstring[len] = '\0';
/* Return it. */
return (newstring);
}
/*
* This takes a character pointer and returns the equivalent
* display type.
*/
EDisplayType char2DisplayType (char *string)
{
static const struct {
const char *name;
EDisplayType code;
} table[] = {
{ "CHAR", vCHAR },
{ "HCHAR", vHCHAR },
{ "INT", vINT },
{ "HINT", vHINT },
{ "UCHAR", vUCHAR },
{ "LCHAR", vLCHAR },
{ "UHCHAR", vUHCHAR },
{ "LHCHAR", vLHCHAR },
{ "MIXED", vMIXED },
{ "HMIXED", vHMIXED },
{ "UMIXED", vUMIXED },
{ "LMIXED", vLMIXED },
{ "UHMIXED", vUHMIXED },
{ "LHMIXED", vLHMIXED },
{ "VIEWONLY", vVIEWONLY },
{ 0, vINVALID },
};
/* Make sure we cover our bases... */
if (string != 0)
{
int n;
for (n = 0; table[n].name != 0; n++)
{
if (!strcmp(string, table[n].name))
return table[n].code;
}
}
return (EDisplayType)vINVALID;
}
/*
* This swaps two elements in an array.
*/
void swapIndex (char *list[], int i, int j)
{
char *temp;
temp = list[i];
list[i] = list[j];
list[j] = temp;
}
/*
* This function is a quick sort alg which sort an array of
* char *. I wanted to use to stdlib qsort, but couldn't get the
* thing to work, so I wrote my own. I'll use qsort if I can get
* it to work.
*/
void quickSort (char *list[], int left, int right)
{
#ifdef HAVE_RADIXSORT
radixsort ((const u_char **)list, right-left+1, NULL, '\0');
#else
int i, last;
/* If there are fewer than 2 elements, return. */
if (left >= right)
{
return;
}
swapIndex (list, left, (left + right)/2);
last = left;
for (i=left + 1; i <= right; i++)
{
if (strcmp (list[i], list[left]) < 0)
{
swapIndex (list, ++last, i);
}
}
swapIndex (list, left, last);
quickSort (list, left, last-1);
quickSort (list, last + 1, right);
#endif
}
/*
* This strips white space off of the given string.
*/
void stripWhiteSpace (EStripType stripType, char *string)
{
/* Declare local variables. */
int stringLength = 0;
int alphaChar = 0;
int x = 0;
/* Make sure the string is not null. */
if (string == 0)
{
return;
}
/* Get the length of the string. */
stringLength = (int)strlen(string);
if (stringLength == 0)
{
return;
}
/* Strip the white space from the front. */
if (stripType == vFRONT || stripType == vBOTH)
{
/* Find the first non-whitespace character. */
while (string[alphaChar] == ' ' || string[alphaChar] == '\t')
{
alphaChar++;
}
/* Trim off the white space. */
if (alphaChar != stringLength)
{
for (x=0; x < (stringLength-alphaChar); x++)
{
string[x] = string[x + alphaChar];
}
string[stringLength-alphaChar] = '\0';
}
else
{
/* Set the string to zero. */
memset (string, 0, stringLength);
}
}
/* Get the length of the string. */
stringLength = (int)strlen(string)-1;
/* Strip the space from behind if it was asked for. */
if (stripType == vBACK || stripType == vBOTH)
{
/* Find the first non-whitespace character. */
while (string[stringLength] == ' ' || string[stringLength] == '\t')
{
string[stringLength--] = '\0';
}
}
}
static unsigned countChar(char *string, int separator)
{
unsigned result = 0;
int ch;
while ((ch = *string++) != 0)
{
if (ch == separator)
result++;
}
return result;
}
/*
* Split a string into a list of strings.
*/
char **CDKsplitString(char *string, int separator)
{
char **result = 0;
char *first;
char *temp;
unsigned item;
unsigned need;
if (string != 0)
{
need = countChar(string, separator) + 2;
if ((result = (char **)malloc(need * sizeof(char *))) != 0)
{
item = 0;
first = string;
for(;;)
{
while (*string != 0 && *string != separator)
string++;
need = string - first;
if ((temp = (char *)malloc(need+1)) == 0)
break;
memcpy(temp, first, need);
temp[need] = 0;
result[item++] = temp;
if (*string++ == 0)
break;
first = string;
}
result[item] = 0;
}
}
return result;
}
/*
* Count the number of items in a list of strings.
*/
unsigned CDKcountStrings(char **list)
{
unsigned result = 0;
if (list != 0)
{
while (*list++ != 0)
result++;
}
return result;
}
/*
* Free a list of strings
*/
void CDKfreeStrings(char **list)
{
if (list != 0)
{
void *base = (void *)list;
while (*list != 0)
free(*list++);
free(base);
}
}
int mode2Filetype (mode_t mode)
{
static const struct {
mode_t mode;
char code;
} table[] = {
#ifdef S_IFBLK
{ S_IFBLK, 'b' }, /* Block device */
#endif
{ S_IFCHR, 'c' }, /* Character device */
{ S_IFDIR, 'd' }, /* Directory */
{ S_IFREG, '-' }, /* Regular file */
#ifdef S_IFLNK
{ S_IFLNK, 'l' }, /* Socket */
#endif
{ S_IFSOCK, '@' }, /* Socket */
{ S_IFIFO, '&' }, /* Pipe */
};
int filetype = '?';
unsigned n;
for (n = 0; n < sizeof(table)/sizeof(table[0]); n++) {
if ((mode & S_IFMT) == table[n].mode) {
filetype = table[n].code;
break;
}
}
return filetype;
}
/*
* This function takes a mode_t type and creates a string represntation
* of the permission mode.
*/
int mode2Char (char *string, mode_t mode)
{
static struct {
mode_t mask;
unsigned col;
char flag;
} table[] = {
{ S_IRUSR, 1, 'r' },
{ S_IWUSR, 2, 'w' },
{ S_IXUSR, 3, 'x' },
{ S_IRGRP, 4, 'r' },
{ S_IWGRP, 5, 'w' },
{ S_IXGRP, 6, 'x' },
{ S_IROTH, 7, 'r' },
{ S_IWOTH, 8, 'w' },
{ S_IXOTH, 9, 'x' },
{ S_ISUID, 3, 's' },
{ S_ISGID, 6, 's' },
#ifdef S_ISVTX
{ S_ISVTX, 9, 't' },
#endif
};
/* Declare local variables. */
int permissions = 0;
int filetype = mode2Filetype(mode);
unsigned n;
/* Clean the string. */
cleanChar (string, 11, '-');
string[11] = '\0';
if (filetype == '?')
return -1;
for (n = 0; n < sizeof(table)/sizeof(table[0]); n++) {
if ((mode & table[n].mask) != 0) {
string[table[n].col] = table[n].flag;
permissions |= table[n].mask;
}
}
/* Check for unusual permissions. */
if (((mode & S_IXUSR) == 0) &&
((mode & S_IXGRP) == 0) &&
((mode & S_IXOTH) == 0) &&
(mode & S_ISUID) != 0)
{
string[3] = 'S';
}
return permissions;
}
/*
* This returns the length of the integer.
*/
int intlen (int value)
{
if (value < 0)
return 1 + intlen(-value);
else if (value >= 10)
return 1 + intlen(value/10);
return 1;
}
/*
* This opens the current directory and reads the contents.
*/
int getDirectoryContents (char *directory, char **list, int maxListSize)
{
/* Declare local variables. */
struct dirent *dirStruct;
int counter = 0;
DIR *dp;
/* Open the directory. */
dp = opendir (directory);
/* Could we open the directory? */
if (dp == 0)
{
return -1;
}
/* Read the directory. */
while ((dirStruct = readdir (dp)) != 0)
{
if (counter <= maxListSize)
{
list[counter++] = copyChar (dirStruct->d_name);
}
}
/* Close the directory. */
closedir (dp);
/* Sort the info. */
quickSort (list, 0, counter-1);
/* Return the number of files in the directory. */
return counter;
}
/*
* This looks for a subset of a word in the given list.
*/
int searchList (char **list, int listSize, char *pattern)
{
/* Declare local variables. */
int len = 0;
int Index = -1;
int x, ret;
/* Make sure the pattern isn't null. */
if (pattern == 0)
{
return Index;
}
len = (int)strlen (pattern);
/* Cycle through the list looking for the word. */
for (x=0; x < listSize; x++)
{
/* Do a string compare. */
ret = strncmp (list[x], pattern, len);
/*
* If 'ret' is less than 0, then the current word is
* alphabetically less than the provided word. At this
* point we will set the index to the current position.
* If 'ret' is greater than 0, then the current word is
* alphabettically greater than the given word. We should
* return with index, which might contain the last best
* match. If they are equal, then we've found it.
*/
if (ret < 0)
{
Index = ret;
}
else if (ret > 0)
{
return Index;
}
else
{
return x;
}
}
return -1;
}
/*
* This function checks to see if a link has been requested.
*/
int checkForLink (char *line, char *filename)
{
int len = 0;
int fPos = 0;
int x = 3;
/* Make sure the line isn't null. */
if (line == 0)
{
return -1;
}
len = (int)strlen (line);
/* Strip out the filename. */
if (line[0] == '<' && line[1] == 'F' && line[2] == '=')
{
/* Strip out the filename. */
while (x < len)
{
if (line[x] == '>')
{
break;
}
filename[fPos++] = line[x++];
}
filename[fPos] = '\0';
return 1;
}
return 0;
}
/*
* This strips out the filename from the pathname. I would have
* used rindex but it seems that not all the C libraries support
* it. :(
*/
char *baseName (char *pathname)
{
char *base = 0;
int pathLen = 0;
int pos = 0;
int Index = -1;
int x = 0;
/* Check if the string is null. */
if (pathname == 0)
{
return 0;
}
base = copyChar (pathname);
pathLen = (int)strlen (pathname);
/* Find the last '/' in the pathname. */
x = pathLen - 1;
while ((pathname[x] != '\0') && (Index == -1) && (x > 0))
{
if (pathname[x] == '/')
{
Index = x;
break;
}
x--;
}
/*
* If the index is -1, we never found one. Return a pointer
* to the string given to us.
*/
if (Index == -1)
{
return base;
}
/* Clean out the base pointer. */
memset (base, '\0', pathLen);
/*
* We have found an index. Copy from the index to the
* end of the string into a new string.
*/
for (x=Index + 1; x < pathLen; x++)
{
base[pos++] = pathname[x];
}
return base;
}
/*
* This strips out the directory from the pathname. I would have
* used rindex but it seems that not all the C libraries support
* it. :(
*/
char *dirName (char *pathname)
{
char *dir = 0;
int pathLen = 0;
int x = 0;
/* Check if the string is null. */
if (pathname == 0)
{
return 0;
}
dir = copyChar (pathname);
pathLen = (int)strlen (pathname);
/* Starting from the end, look for the first '/' character. */
x = pathLen;
while ((dir[x] != '/') && (x > 0))
{
dir[x--] = '\0';
}
/* Now dir either has nothing or the basename. */
if (dir[0] == '\0')
{
/* If it has nothing, return nothing. */
return copyChar ("");
}
/* Otherwise, return the path. */
return dir;
}
/*
* If the dimension is a negative value, the dimension will
* be the full height/width of the parent window - the value
* of the dimension. Otherwise, the dimension will be the
* given value.
*/
int setWidgetDimension (int parentDim, int proposedDim, int adjustment)
{
int dimension = 0;
/* If the user passed in FULL, return the number of rows. */
if ((proposedDim == FULL) || (proposedDim == 0))
{
return parentDim;
}
/* If they gave a positive value, return it. */
if (proposedDim >= 0)
{
if (proposedDim >= parentDim)
{
return parentDim;
}
return (proposedDim + adjustment);
}
/*
* If they gave a negative value, then return the
* dimension of the parent minus the value given.
*/
dimension = parentDim + proposedDim;
/* Just to make sure. */
if (dimension < 0)
{
return parentDim;
}
return dimension;
}
/*
* This safely erases a given window.
*/
void eraseCursesWindow (WINDOW *window)
{
if (window != 0)
{
werase (window);
wnoutrefresh (window);
}
}
/*
* This safely deletes a given window.
*/
void deleteCursesWindow (WINDOW *window)
{
if (window != 0)
{
delwin (window);
}
}
/*
* This moves a given window
*/
void moveCursesWindow (WINDOW *window, int xpos, int ypos)
{
mvwin (window, ypos, xpos);
}
/*
* Return an integer like 'floor()', which returns a double.
*/
int floorCDK(double value)
{
int result = (int)value;
if (result > value) /* e.g., value < 0.0 and value is not an integer */
result--;
return result;
}
/*
* Return an integer like 'ceil()', which returns a double.
*/
int ceilCDK(double value)
{
return -floorCDK(-value);
}