/*
* @implemented
*/
size_t _mbsspn (const unsigned char *str1, const unsigned char *str2)
{
int c;
const unsigned char *save = str1;
while ((c = _mbsnextc (str1))) {
if (_mbschr (str2, c) == 0)
break;
str1 = _mbsinc ((unsigned char *) str1);
}
return str1 - save;
}
/*
* @implemented
*/
unsigned char *_mbsupr (unsigned char *string)
{
int c;
unsigned char *save = string;
while ((c = _mbsnextc (string))) {
if (_MBIS16 (c) == 0)
c = toupper (c);
_mbset (string, c);
string = _mbsinc (string);
}
return save;
}
// Fix strings in tzname[] to avoid long names with non-ascii characters.
// If TZ is not set, tzset() in the MSVC runtime sets tzname[] to the
// national language timezone names returned by GetTimezoneInformation().
static char * fixtzname(char * dest, int destsize, const char * src)
{
int i = 0, j = 0;
while (src[i] && j < destsize-1) {
int i2 = (const char *)_mbsinc((const unsigned char *)src+i) - src;
if (i2 > i+1)
i = i2; // Ignore multibyte chars
else {
if ('A' <= src[i] && src[i] <= 'Z')
dest[j++] = src[i]; // "Pacific Standard Time" => "PST"
i++;
}
}
if (j < 2)
j = 0;
dest[j] = 0;
return dest;
}
static int is_directory( const CHAR_TYPE *name )
/**********************************************/
{
UINT_WC_TYPE curr_ch;
UINT_WC_TYPE prev_ch;
curr_ch = NULLCHAR;
for(;;) {
prev_ch = curr_ch;
#ifdef __WIDECHAR__
curr_ch = *name;
#else
curr_ch = _mbsnextc( (unsigned char *)name );
#endif
if( curr_ch == NULLCHAR ) {
if( prev_ch == '\\' || prev_ch == '/' || prev_ch == ':' ){
/* directory, need add "*.*" */
return( 2 );
}
if( prev_ch == '.' ){
/* directory, need add "\\*.*" */
return( 1 );
}
/* without wildcards maybe file or directory, need next check */
/* need add "\\*.*" if directory */
return( 0 );
}
if( curr_ch == '*' )
break;
if( curr_ch == '?' )
break;
#ifdef __WIDECHAR__
++name;
#else
name = (char *)_mbsinc( (unsigned char *)name );
#endif
}
/* with wildcard must be file */
return( -1 );
}
static int is_directory( const CHAR_TYPE *name )
/**********************************************/
{
UINT_WC_TYPE curr_ch;
UINT_WC_TYPE prev_ch;
curr_ch = NULLCHAR;
for(;;) {
prev_ch = curr_ch;
#if defined( __WIDECHAR__ ) || defined( __UNIX__ )
curr_ch = *name;
#else
curr_ch = _mbsnextc( (unsigned char *)name );
#endif
if( curr_ch == NULLCHAR ) {
if( IS_DIR_SEP( prev_ch ) || prev_ch == DRV_SEP ){
/* directory, need add "*.*" */
return( 2 );
}
if( prev_ch == STRING( '.' ) ){
/* directory, need add "\\*.*" */
return( 1 );
}
/* without wildcards maybe file or directory, need next check */
/* need add "\\*.*" if directory */
return( 0 );
}
if( curr_ch == STRING( '*' ) )
break;
if( curr_ch == STRING( '?' ) )
break;
#if defined( __WIDECHAR__ ) || defined( __UNIX__ )
++name;
#else
name = (char *)_mbsinc( (unsigned char *)name );
#endif
}
/* with wildcard must be file */
return( -1 );
}
_WCRTLINK unsigned char _FFAR *_NEARFAR(_mbschr,_fmbschr)( const unsigned char _FFAR *string, unsigned int ch )
{
char mbc[MB_LEN_MAX+1];
// if( !__IsDBCS && !ch&0xFF00 ) return( strchr( string, ch ) );
/*** Search for the specified character ***/
_mbvtop( ch, mbc );
mbc[_mbclen(mbc)] = '\0';
#ifdef __FARFUNC__
while( !_fmbterm(string) && _fmbccmp(string,mbc)!=0 )
string = _fmbsinc( string ); /* skip over character */
#else
while( !_mbterm(string) && _mbccmp(string,mbc)!=0 )
string = _mbsinc( string ); /* skip over character */
#endif
/*** Return character address, or NULL if not found ***/
if( !_NEARFAR(_mbterm,_fmbterm)(string) || ch==0 )
return( (unsigned char _FFAR*) string );
else
return( NULL );
}
static int
add_menu_item (HMENU menu, widget_value *wv, HMENU item)
{
UINT fuFlags;
char *out_string, *p, *q;
int return_value;
size_t nlen, orig_len;
USE_SAFE_ALLOCA;
if (menu_separator_name_p (wv->name))
{
fuFlags = MF_SEPARATOR;
out_string = NULL;
}
else
{
if (wv->enabled)
fuFlags = MF_STRING;
else
fuFlags = MF_STRING | MF_GRAYED;
if (wv->key != NULL)
{
out_string = SAFE_ALLOCA (strlen (wv->name) + strlen (wv->key) + 2);
p = stpcpy (out_string, wv->name);
p = stpcpy (p, "\t");
strcpy (p, wv->key);
}
else
out_string = (char *)wv->name;
/* Quote any special characters within the menu item's text and
key binding. */
nlen = orig_len = strlen (out_string);
if (unicode_append_menu)
{
/* With UTF-8, & cannot be part of a multibyte character. */
for (p = out_string; *p; p++)
{
if (*p == '&')
nlen++;
}
}
#ifndef NTGUI_UNICODE
else
{
/* If encoded with the system codepage, use multibyte string
functions in case of multibyte characters that contain '&'. */
for (p = out_string; *p; p = _mbsinc (p))
{
if (_mbsnextc (p) == '&')
nlen++;
}
}
#endif /* !NTGUI_UNICODE */
if (nlen > orig_len)
{
p = out_string;
out_string = SAFE_ALLOCA (nlen + 1);
q = out_string;
while (*p)
{
if (unicode_append_menu)
{
if (*p == '&')
*q++ = *p;
*q++ = *p++;
}
#ifndef NTGUI_UNICODE
else
{
if (_mbsnextc (p) == '&')
{
_mbsncpy (q, p, 1);
q = _mbsinc (q);
}
_mbsncpy (q, p, 1);
p = _mbsinc (p);
q = _mbsinc (q);
}
#endif /* !NTGUI_UNICODE */
}
*q = '\0';
}
if (item != NULL)
fuFlags = MF_POPUP;
else if (wv->title || wv->call_data == 0)
{
/* Only use MF_OWNERDRAW if GetMenuItemInfo is usable, since
we can't deallocate the memory otherwise. */
if (get_menu_item_info)
{
out_string = (char *) local_alloc (strlen (wv->name) + 1);
strcpy (out_string, wv->name);
#ifdef MENU_DEBUG
DebPrint ("Menu: allocating %ld for owner-draw", out_string);
#endif
fuFlags = MF_OWNERDRAW | MF_DISABLED;
}
else
fuFlags = MF_DISABLED;
}
/* Draw radio buttons and tickboxes. */
else if (wv->selected && (wv->button_type == BUTTON_TYPE_TOGGLE ||
wv->button_type == BUTTON_TYPE_RADIO))
fuFlags |= MF_CHECKED;
else
fuFlags |= MF_UNCHECKED;
}
if (unicode_append_menu && out_string)
{
/* Convert out_string from UTF-8 to UTF-16-LE. */
int utf8_len = strlen (out_string);
WCHAR * utf16_string;
if (fuFlags & MF_OWNERDRAW)
utf16_string = local_alloc ((utf8_len + 1) * sizeof (WCHAR));
else
utf16_string = SAFE_ALLOCA ((utf8_len + 1) * sizeof (WCHAR));
utf8to16 ((unsigned char *)out_string, utf8_len, utf16_string);
return_value = unicode_append_menu (menu, fuFlags,
item != NULL ? (UINT_PTR) item
: (UINT_PTR) wv->call_data,
utf16_string);
#ifndef NTGUI_UNICODE /* Fallback does not apply when always UNICODE */
if (!return_value)
{
/* On W9x/ME, Unicode menus are not supported, though AppendMenuW
apparently does exist at least in some cases and appears to be
stubbed out to do nothing. out_string is UTF-8, but since
our standard menus are in English and this is only going to
happen the first time a menu is used, the encoding is
of minor importance compared with menus not working at all. */
return_value =
AppendMenu (menu, fuFlags,
item != NULL ? (UINT_PTR) item: (UINT_PTR) wv->call_data,
out_string);
/* Don't use Unicode menus in future, unless this is Windows
NT or later, where a failure of AppendMenuW does NOT mean
Unicode menus are unsupported. */
if (osinfo_cache.dwPlatformId != VER_PLATFORM_WIN32_NT)
unicode_append_menu = NULL;
}
#endif /* NTGUI_UNICODE */
if (unicode_append_menu && (fuFlags & MF_OWNERDRAW))
local_free (out_string);
}
else
{
return_value =
AppendMenu (menu,
fuFlags,
item != NULL ? (UINT_PTR) item : (UINT_PTR) wv->call_data,
out_string );
}
/* This must be done after the menu item is created. */
if (!wv->title && wv->call_data != 0)
{
if (set_menu_item_info)
{
MENUITEMINFO info;
memset (&info, 0, sizeof (info));
info.cbSize = sizeof (info);
info.fMask = MIIM_DATA;
/* Set help string for menu item. Leave it as a pointer to
a Lisp_String until it is ready to be displayed, since GC
can happen while menus are active. */
if (!NILP (wv->help))
{
/* We use XUNTAG below because in a 32-bit build
--with-wide-int we cannot pass a Lisp_Object
via a DWORD member of MENUITEMINFO. */
/* As of Jul-2012, w32api headers say that dwItemData
has DWORD type, but that's a bug: it should actually
be ULONG_PTR, which is correct for 32-bit and 64-bit
Windows alike. MSVC headers get it right; hopefully,
MinGW headers will, too. */
eassert (STRINGP (wv->help));
info.dwItemData = (ULONG_PTR) XUNTAG (wv->help, Lisp_String);
}
if (wv->button_type == BUTTON_TYPE_RADIO)
{
/* CheckMenuRadioItem allows us to differentiate TOGGLE and
RADIO items, but is not available on NT 3.51 and earlier. */
info.fMask |= MIIM_TYPE | MIIM_STATE;
info.fType = MFT_RADIOCHECK | MFT_STRING;
info.dwTypeData = out_string;
info.fState = wv->selected ? MFS_CHECKED : MFS_UNCHECKED;
}
set_menu_item_info (menu,
item != NULL ? (UINT_PTR) item : (UINT_PTR) wv->call_data,
FALSE, &info);
}
}
SAFE_FREE ();
return return_value;
}
unsigned long aFont::height( const char* st, int areaWidth ) const
{
unsigned long width, height;
gos_TextSetAttributes (gosFont, 0, size, false, true, false, false);
gos_TextSetRegion( 0, 0, areaWidth, Environment.screenHeight );
gos_TextStringLength(&width,&height,st);
unsigned long lineCount = 1;
if ( width > areaWidth - 1 )
{
unsigned long curLineWidth = 0;
gosASSERT( strlen( st) < 2048 );
char pLine[2048]; // should be more than adequate
char* pLastWord = (char*)st;
char* pTmp = (char*)st;
char* pTmpLine = (char*)pLine;
int numberOfWordsPerLine = 0;
bool bHasSpaces = true;
if ( !strstr( st, " " ) )
{
if ( !strstr( st, "\n" ) )
bHasSpaces = false;
}
while( *pTmp != NULL )
{
if ( *pTmp == '\n' )
{
lineCount++;
numberOfWordsPerLine = 0;
curLineWidth = 0;
pTmpLine = pLine;
pLastWord = pTmp+1;
}
else if ( !bHasSpaces )
{
if ( pTmp > st )
{
char tmp = *(pTmp-1);
if ( !isleadbyte( tmp ) )
{
*(pTmpLine) = NULL;
gos_TextStringLength( &curLineWidth, &height, pLine );
if ( curLineWidth > areaWidth )
{
lineCount++;
pTmp--;
pTmpLine = pLine;
curLineWidth = 0;
numberOfWordsPerLine = 0;
}
}
}
}
else if ( isspace( *pTmp ) )
{
*(pTmpLine) = NULL;
gos_TextStringLength( &curLineWidth, &height, pLine );
if ( curLineWidth > areaWidth )
{
gos_TextStringLength( &curLineWidth, &height, pLastWord );
if ( numberOfWordsPerLine == 0 || curLineWidth > areaWidth )
{
static bool firstTime = true;
if (firstTime)
{
Assert( true, 0, "this list box item contains a word of greater "
" area than the list box, giving up" );
firstTime = false;
}
/*There are times when you just can't guarantee that this won't occur,
so we have to just continue and deal with it.*/
//return height;
pLastWord = pTmp;
}
lineCount++;
pTmpLine = pLine;
pTmp = pLastWord - 1;
curLineWidth = 0;
numberOfWordsPerLine = 0;
}
pLastWord = pTmp;
numberOfWordsPerLine++;
}
*pTmpLine = *pTmp;
if ( isleadbyte( *pTmpLine ) )
{
*(pTmpLine+1) = *(pTmp+1);
}
pTmpLine = (char*)_mbsinc( (unsigned char*)pTmpLine );
pTmp = (char*)_mbsinc( (unsigned char*)pTmp );
}
// one last check
*pTmpLine = NULL;
gos_TextStringLength( &curLineWidth, &height, pLine );
if ( curLineWidth > areaWidth )
{
lineCount++;
}
if ( *pTmp == NULL )
lineCount++;
}
gos_TextStringLength( &width, &height, "A" );
return (height) * lineCount ;
}
void WdeChangeDialogInfo( WdeInfoStruct *is )
{
WdeInfoStruct c_is;
char *str;
char *cp;
bool quoted_str;
bool str_is_ordinal;
uint_16 ord;
bool found;
WdeHashValue value;
c_is = *is;
str = NULL;
cp = WdeGetStrFromEdit( WdeInfoWindow, IDB_INFO_CAPTION, NULL );
if( cp != NULL ) {
str = WRConvertStringTo( cp, "\t\n", "tn" );
WRMemFree( cp );
}
c_is.d.caption = str;
str = WdeGetStrFromCombo( WdeInfoWindow, IDB_INFO_IDSTR );
if( str == NULL ) {
WRMemFree( c_is.d.caption );
c_is.d.caption = NULL;
return;
}
WRStripSymbol( str );
quoted_str = FALSE;
if( _mbclen( (unsigned char *)str ) == 1 && str[0] == '"' ) {
unsigned char *s;
str[0] = ' ';
cp = NULL;
for( s = (unsigned char *)str; *s != '\0'; s = _mbsinc( s ) ) {
if( _mbclen( s ) == 1 && *s == '"' ) {
cp = (char *)s;
}
}
if( cp != NULL ) {
*cp = '\0';
}
WRStripSymbol( str );
quoted_str = TRUE;
}
if( str[0] == '\0' ) {
WRMemFree( str );
WRMemFree( c_is.d.caption );
c_is.d.caption = NULL;
return;
}
ord = (uint_16)strtoul( str, &cp, 0 );
str_is_ordinal = (*cp == '\0');
c_is.symbol = NULL;
if( quoted_str ) {
c_is.d.name = WResIDFromStr( str );
WRMemFree( str );
} else if( str_is_ordinal ) {
c_is.d.name = WResIDFromNum( ord );
WRMemFree( str );
} else {
if( !WdeIsValidSymbol( str ) ) {
WRMemFree( str );
WRMemFree( c_is.d.caption );
c_is.d.caption = NULL;
return;
}
strupr( str );
c_is.symbol = str;
c_is.d.name = NULL;
}
Forward( is->obj, MODIFY_INFO, &c_is, NULL );
if( c_is.symbol ) {
WdeAddUniqueStringToCombo( WdeInfoWindow, IDB_INFO_IDSTR, c_is.symbol );
value = WdeLookupName( c_is.res_info->hash_table, c_is.symbol, &found );
if( found ) {
WdeSetEditWithSINT32( (int_32)value, 10, WdeInfoWindow, IDB_INFO_IDNUM );
}
} else if( str_is_ordinal ) {
WdeSetEditWithSINT32( (int_32)ord, 10, WdeInfoWindow, IDB_INFO_IDNUM );
} else {
WdeSetEditWithStr( "", WdeInfoWindow, IDB_INFO_IDNUM );
}
*is = c_is;
}
_WCRTLINK int stat( CHAR_TYPE const *path, struct stat *buf )
{
const CHAR_TYPE * ptr;
CHAR_TYPE fullpath[_MAX_PATH];
CHAR_TYPE * fullp;
int isrootdir = 0;
int handle;
int RdosAttrib;
int ok;
CHAR_TYPE name[_MAX_PATH];
int attrib;
unsigned long wr_msb;
unsigned long wr_lsb;
long size;
int ms;
int us;
struct tm tm;
int i;
/* reject null string and names that has wildcard */
if( *path == '\0' || _mbspbrk( path, "*?" ) != NULL )
return( -1 );
/*** Determine if 'path' refers to a root directory ***/
if( _fullpath( fullpath, path, _MAX_PATH ) != NULL ) {
if( isalpha( fullpath[0] ) && fullpath[1] == ':' &&
fullpath[2] == '\\' && fullpath[3] == '\0' )
{
isrootdir = 1;
}
}
else
return( -1 );
ptr = path;
if( *_mbsinc(path ) ) ptr += 2;
if( ( (ptr[0] == '\\' || ptr[0] == '/') && ptr[1] == '\0' ) || isrootdir )
{
/* handle root directory */
CHAR_TYPE cwd[_MAX_PATH];
/* save current directory */
getcwd( cwd, _MAX_PATH );
/* try to change to specified root */
if( chdir( path ) != 0 ) return( -1 );
/* restore current directory */
chdir( cwd );
attrib = _A_SUBDIR;
wr_msb = 0;
wr_lsb = 0;
size = 0;
name[0] = NULLCHAR;
} else { /* not a root directory */
fullp = fullpath + strlen( fullpath ) - 1;
while( *fullp != '\\' && *fullp != '/' && fullp != fullpath )
fullp--;
*fullp = 0;
fullp++;
if( strlen( fullpath ) == 0 )
strcpy( fullpath, "*" );
handle = RdosOpenDir( fullpath );
ok = 0;
i = 0;
strlwr( fullp );
while( RdosReadDir( handle, i, _MAX_PATH, name, &size, &RdosAttrib, &wr_msb, &wr_lsb ) ) {
strlwr( name );
if( !strcmp( name, fullp ) ) {
ok = 1;
break;
}
i++;
}
RdosCloseDir( handle );
if( !ok )
return( -1 );
attrib = 0;
if( RdosAttrib & FILE_ATTRIBUTE_ARCHIVE ) {
attrib |= _A_ARCH;
}
if( RdosAttrib & FILE_ATTRIBUTE_DIRECTORY ) {
attrib |= _A_SUBDIR;
}
if( RdosAttrib & FILE_ATTRIBUTE_HIDDEN ) {
attrib |= _A_HIDDEN;
}
if( RdosAttrib & FILE_ATTRIBUTE_NORMAL ) {
attrib |= _A_NORMAL;
}
if( RdosAttrib & FILE_ATTRIBUTE_READONLY ) {
attrib |= _A_RDONLY;
}
if( RdosAttrib & FILE_ATTRIBUTE_SYSTEM ) {
attrib |= _A_SYSTEM;
}
}
/* process drive number */
if( *_mbsinc(path) ) {
buf->st_dev = tolower( fullpath[0] ) - 'a';
} else {
buf->st_dev = RdosGetCurDrive();
}
buf->st_rdev = buf->st_dev;
buf->st_size = size;
buf->st_mode = at2mode( attrib, name );
RdosDecodeMsbTics( wr_msb,
&tm.tm_year,
&tm.tm_mon,
&tm.tm_mday,
&tm.tm_hour );
RdosDecodeLsbTics( wr_lsb,
&tm.tm_min,
&tm.tm_sec,
&ms,
&us );
tm.tm_year -= 1900;
tm.tm_mon--;
tm.tm_isdst = -1;
tm.tm_wday = -1;
tm.tm_yday = -1;
buf->st_mtime = mktime( &tm );
buf->st_atime = buf->st_ctime = buf->st_btime = buf->st_mtime;
buf->st_nlink = 1;
buf->st_ino = buf->st_uid = buf->st_gid = 0;
buf->st_attr = attrib;
buf->st_archivedID = 0;
buf->st_updatedID = 0;
buf->st_inheritedRightsMask = 0;
buf->st_originatingNameSpace = 0;
return( 0 );
}
static PRBool
IsRootDirectory(char *fn, size_t buflen)
{
char *p;
PRBool slashAdded = PR_FALSE;
PRBool rv = PR_FALSE;
if (_PR_IS_SLASH(fn[0]) && fn[1] == '\0') {
return PR_TRUE;
}
if (isalpha(fn[0]) && fn[1] == ':' && _PR_IS_SLASH(fn[2])
&& fn[3] == '\0') {
rv = GetDriveType(fn) > 1 ? PR_TRUE : PR_FALSE;
return rv;
}
/* The UNC root directory */
if (_PR_IS_SLASH(fn[0]) && _PR_IS_SLASH(fn[1])) {
/* The 'server' part should have at least one character. */
p = &fn[2];
if (*p == '\0' || _PR_IS_SLASH(*p)) {
return PR_FALSE;
}
/* look for the next slash */
do {
p = _mbsinc(p);
} while (*p != '\0' && !_PR_IS_SLASH(*p));
if (*p == '\0') {
return PR_FALSE;
}
/* The 'share' part should have at least one character. */
p++;
if (*p == '\0' || _PR_IS_SLASH(*p)) {
return PR_FALSE;
}
/* look for the final slash */
do {
p = _mbsinc(p);
} while (*p != '\0' && !_PR_IS_SLASH(*p));
if (_PR_IS_SLASH(*p) && p[1] != '\0') {
return PR_FALSE;
}
if (*p == '\0') {
/*
* GetDriveType() doesn't work correctly if the
* path is of the form \\server\share, so we add
* a final slash temporarily.
*/
if ((p + 1) < (fn + buflen)) {
*p++ = '\\';
*p = '\0';
slashAdded = PR_TRUE;
} else {
return PR_FALSE; /* name too long */
}
}
rv = GetDriveType(fn) > 1 ? PR_TRUE : PR_FALSE;
/* restore the 'fn' buffer */
if (slashAdded) {
*--p = '\0';
}
}
return rv;
}
_WCRTLINK void __F_NAME(_splitpath2,_wsplitpath2)( CHAR_TYPE const *inp, CHAR_TYPE *outp,
CHAR_TYPE **drive, CHAR_TYPE **path, CHAR_TYPE **fn, CHAR_TYPE **ext ) {
/*=====================================================================*/
CHAR_TYPE const *dotp;
CHAR_TYPE const *fnamep;
CHAR_TYPE const *startp;
UINT_WC_TYPE ch;
/* take apart specification like -> //0/hd/user/fred/filename.ext for QNX */
/* take apart specification like -> \\disk2\fred\filename.ext for UNC names */
/* take apart specification like -> c:\fred\filename.ext for DOS, OS/2 */
/* process node/drive/UNC specification */
startp = inp;
if( IS_PC( inp[ 0 ] ) && IS_PC( inp[ 1 ] ) )
{
inp += 2;
for( ;; ) {
if( *inp == NULLCHAR )
break;
if( IS_PC( *inp ) )
break;
if( *inp == '.' )
break;
#if defined( __WIDECHAR__ ) || defined( __UNIX__ )
++inp;
#else
inp = (char *)_mbsinc( (unsigned char *)inp );
#endif
}
outp = pcopy( drive, outp, startp, inp );
#if !defined(__UNIX__)
/* process drive specification */
} else if( inp[ 0 ] != NULLCHAR && inp[ 1 ] == ':' ) {
if( drive != NULL ) {
*drive = outp;
outp[ 0 ] = inp[ 0 ];
outp[ 1 ] = ':';
outp[ 2 ] = NULLCHAR;
outp += 3;
}
inp += 2;
#endif
} else if( drive != NULL ) {
*drive = outp;
*outp = NULLCHAR;
++outp;
}
/* process /user/fred/filename.ext for QNX */
/* process \fred\filename.ext for DOS, OS/2 */
/* process /fred/filename.ext for DOS, OS/2 */
dotp = NULL;
fnamep = inp;
startp = inp;
for( ;; ) {
#if defined( __WIDECHAR__ ) || defined( __UNIX__ )
ch = *inp;
#else
ch = _mbsnextc( (unsigned char *)inp );
#endif
if( ch == 0 )
break;
if( ch == '.' ) {
dotp = inp;
++inp;
continue;
}
#if defined( __WIDECHAR__ ) || defined( __UNIX__ )
inp++;
#else
inp = (char *)_mbsinc( (unsigned char *)inp );
#endif
if( IS_PC( ch ) ) {
fnamep = inp;
dotp = NULL;
}
}
outp = pcopy( path, outp, startp, fnamep );
if( dotp == NULL )
dotp = inp;
outp = pcopy( fn, outp, fnamep, dotp );
outp = pcopy( ext, outp, dotp, inp );
}
_WCRTLINK void __F_NAME(_makepath,_wmakepath)( CHAR_TYPE *path, const CHAR_TYPE *drive,
const CHAR_TYPE *dir, const CHAR_TYPE *fname, const CHAR_TYPE *ext )
{
UINT_WC_TYPE first_pc = NULLCHAR;
#ifndef __WIDECHAR__
char *pathstart = path;
unsigned ch;
#endif
if( drive != NULL ) {
if( *drive != NULLCHAR ) {
if( ( drive[0] == DIR_SEP ) && ( drive[1] == DIR_SEP ) ) {
__F_NAME(strcpy, wcscpy)( path, drive );
path += __F_NAME(strlen, wcslen)( drive );
} else {
*path++ = *drive; /* OK for MBCS */
*path++ = DRV_SEP;
}
}
}
*path = NULLCHAR;
if( dir != NULL ) {
if( *dir != NULLCHAR ) {
do {
#ifdef __WIDECHAR__
*path++ = pickup( *dir++, &first_pc );
#else
ch = pickup( _mbsnextc( (unsigned char *)dir ), &first_pc );
_mbvtop( ch, (unsigned char *)path );
path[_mbclen( (unsigned char *)path )] = NULLCHAR;
path = (char *)_mbsinc( (unsigned char *)path );
dir = (char *)_mbsinc( (unsigned char *)dir );
#endif
} while( *dir != NULLCHAR );
/* if no path separator was specified then pick a default */
if( first_pc == NULLCHAR )
first_pc = DIR_SEP;
/* if dir did not end in '/' then put in a provisional one */
#ifdef __WIDECHAR__
if( path[-1] == first_pc ) {
path--;
} else {
*path = first_pc;
}
#else
if( *(_mbsdec( (unsigned char *)pathstart, (unsigned char *)path )) == first_pc ) {
path--;
} else {
*path = first_pc;
}
#endif
}
}
/* if no path separator was specified thus far then pick a default */
if( first_pc == NULLCHAR )
first_pc = DIR_SEP;
if( fname != NULL ) {
#ifdef __WIDECHAR__
if( pickup( *fname, &first_pc ) != first_pc && *path == first_pc )
path++;
#else
ch = _mbsnextc( (unsigned char *)fname );
if( pickup( ch, &first_pc ) != first_pc && *path == first_pc )
path++;
#endif
while( *fname != NULLCHAR ) {
//do {
#ifdef __WIDECHAR__
*path++ = pickup( *fname++, &first_pc );
#else
ch = pickup( _mbsnextc( (unsigned char *)fname ), &first_pc );
_mbvtop( ch, (unsigned char *)path );
path[_mbclen( (unsigned char *)path )] = NULLCHAR;
path = (char *)_mbsinc( (unsigned char *)path );
fname = (char *)_mbsinc( (unsigned char *)fname );
#endif
} //while( *fname != NULLCHAR );
} else {
if( *path == first_pc ) {
path++;
}
}
if( ext != NULL ) {
if( *ext != NULLCHAR ) {
if( *ext != EXT_SEP )
*path++ = EXT_SEP;
while( *ext != NULLCHAR ) {
*path++ = *ext++; /* OK for MBCS */
}
}
}
*path = NULLCHAR;
}
_WCRTLINK void __F_NAME(_splitpath,_wsplitpath)( const CHAR_TYPE *path,
CHAR_TYPE *drive, CHAR_TYPE *dir, CHAR_TYPE *fname, CHAR_TYPE *ext )
{
const CHAR_TYPE *dotp;
const CHAR_TYPE *fnamep;
const CHAR_TYPE *startp;
#ifndef __WIDECHAR__
unsigned ch;
#else
CHAR_TYPE ch;
#endif
#ifdef __NETWARE__
const CHAR_TYPE *ptr;
#endif
/* take apart specification like -> //0/hd/user/fred/filename.ext for QNX */
/* take apart specification like -> c:\fred\filename.ext for DOS, OS/2 */
#if defined(__UNIX__)
/* process node/drive specification */
startp = path;
if( path[ 0 ] == PC && path[ 1 ] == PC ) {
path += 2;
for( ;; ) {
if( *path == NULLCHAR )
break;
if( *path == PC )
break;
if( *path == '.' )
break;
#ifdef __WIDECHAR__
++path;
#else
#ifdef __UNIX__
path++;
#else
path = _mbsinc( path );
#endif
#endif
}
}
copypart( drive, startp, path - startp, _MAX_NODE );
#elif defined(__NETWARE__)
#ifdef __WIDECHAR__
ptr = wcschr( path, ':' );
#else
#ifdef __UNIX__
ptr = strchr( path, ':' );
#else
ptr = _mbschr( path, ':' );
#endif
#endif
if( ptr != NULL ) {
if( drive != NULL ) {
copypart( drive, path, ptr - path + 1, _MAX_SERVER +
_MAX_VOLUME + 1 );
}
#ifdef __WIDECHAR__
path = ptr + 1;
#else
#ifdef __UNIX__
path = ptr + 1;
#else
path = _mbsinc( ptr );
#endif
#endif
} else if( drive != NULL ) {
*drive = '\0';
}
#else
/* processs drive specification */
if( path[ 0 ] != NULLCHAR && path[ 1 ] == ':' ) {
if( drive != NULL ) {
drive[ 0 ] = path[ 0 ];
drive[ 1 ] = ':';
drive[ 2 ] = NULLCHAR;
}
path += 2;
} else if( drive != NULL ) {
drive[ 0 ] = NULLCHAR;
}
#endif
/* process /user/fred/filename.ext for QNX */
/* process /fred/filename.ext for DOS, OS/2 */
dotp = NULL;
fnamep = path;
startp = path;
for( ;; ) { /* 07-jul-91 DJG -- save *path in ch for speed */
if( *path == NULLCHAR )
break;
#ifdef __WIDECHAR__
ch = *path;
#else
#ifdef __UNIX__
ch = *path;
#else
ch = _mbsnextc( path );
#endif
#endif
if( ch == '.' ) {
dotp = path;
++path;
continue;
}
#ifdef __WIDECHAR__
++path;
#else
#ifdef __UNIX__
path++;
#else
path = _mbsinc( path );
#endif
#endif
#if defined(__UNIX__)
if( ch == PC ) {
#else /* DOS, OS/2, Windows, Netware */
if( ch == PC || ch == ALT_PC ) {
#endif
fnamep = path;
dotp = NULL;
}
}
copypart( dir, startp, fnamep - startp, _MAX_DIR - 1 );
if( dotp == NULL )
dotp = path;
copypart( fname, fnamep, dotp - fnamep, _MAX_FNAME - 1 );
copypart( ext, dotp, path - dotp, _MAX_EXT - 1);
}
void CCredits::AddCredits()
{
// Sanity checks...
if (!m_pClientDE) return;
// Set the static info...
if (!CCredit::SetStaticInfo(m_pClientDE, GetMode(), IsClearingScreen()))
{
return;
}
// Get the credits text buffer...
char* sName = NULL;
#ifdef _ADDON
if (IsIntro()) sName = "INTRO_AO";
else sName = "CREDITS_AO";
#else
if (IsIntro()) sName = "INTRO";
else sName = "CREDITS";
#endif
void* hModule = NULL;
m_pClientDE->GetEngineHook("cres_hinstance", &hModule);
char* sBuf = CreditsWin_GetTextBuffer(sName, hModule);
if (!sBuf) return;
char sCredit[1024];
int i = 0;
while (*sBuf)
{
if (*sBuf == '#' && *((char*)_mbsinc((const unsigned char*)sBuf)) == '#')
{
sCredit[i] = '\0';
if (_mbsnbcmp((const unsigned char*)sCredit, (const unsigned char*)">END", 4) == 0) // end?
{
return;
}
AddCredit(sCredit);
i = 0;
sBuf = (char*)_mbsinc((const unsigned char*)sBuf);
sBuf = (char*)_mbsinc((const unsigned char*)sBuf);
while (*sBuf != '\0' && ((*sBuf == '\n') || (*sBuf == '\r'))) sBuf++;
}
else
{
int nCount = _mbsnbcnt((const unsigned char*)sBuf,1);
memcpy(&sCredit[i], sBuf, nCount);
i += nCount;
sBuf = (char*)_mbsinc((const unsigned char*)sBuf);
}
}
}
/*
* Translate foo/dir1\\dir2" \\"bar"grok --> "foo\\dir1\\dir2 \\"bargrok".
*/
char *PathConvert( const char *pathname, char quote )
/***************************************************/
{
const unsigned char *path = (const unsigned char *)pathname;
char *out;
unsigned char *p;
bool quoteends = FALSE; /* quote the whole filename */
bool backslash = FALSE; /* true if last char was a '\\' */
bool inquote = FALSE; /* true if inside a quoted string */
/*** Allocate a buffer for the new string (should be big enough) ***/
out = AllocMem( 2 * ( strlen( (char *)path ) + 1 + 2 ) );
p = (unsigned char *)out;
/*** Determine if path contains any bizarre characters ***/
if( _mbschr( path, ' ' ) != NULL ||
_mbschr( path, '\t' ) != NULL ||
_mbschr( path, '"' ) != NULL ||
_mbschr( path, '\'' ) != NULL ||
_mbschr( path, '`' ) != NULL ||
_mbschr( path, quote ) != NULL ) {
quoteends = TRUE;
*p++ = quote;
}
/*** Convert the path one character at a time ***/
while( *path != '\0' ) {
if( *path == '"' ) {
if( inquote ) {
if( backslash ) {
*p++ = '"'; /* handle \" within a string */
backslash = FALSE;
} else {
inquote = FALSE;
}
} else {
inquote = TRUE;
}
} else if( *path == '\\' ) {
*p++ = '\\';
if( backslash ) {
backslash = FALSE;
} else {
backslash = TRUE;
}
} else if( *path == '/' ) {
if( inquote ) {
*p++ = '/';
} else {
*p++ = '\\';
}
backslash = FALSE;
} else {
_mbccpy( p, path ); /* copy an ordinary character */
p = _mbsinc( p );
backslash = FALSE;
}
path = _mbsinc( path );
}
if( quoteends ) *p++ = quote;
*p++ = '\0';
return( out );
}
_WCRTLINK void __F_NAME(_splitpath,_wsplitpath)( const CHAR_TYPE *path,
CHAR_TYPE *drive, CHAR_TYPE *dir, CHAR_TYPE *fname, CHAR_TYPE *ext )
{
const CHAR_TYPE *dotp;
const CHAR_TYPE *fnamep;
const CHAR_TYPE *startp;
UINT_WC_TYPE ch;
#ifdef __NETWARE__
const CHAR_TYPE *ptr;
#endif
/* take apart specification like -> //0/hd/user/fred/filename.ext for QNX */
/* take apart specification like -> c:\fred\filename.ext for DOS, OS/2 */
#if defined(__UNIX__)
/* process node/drive specification */
startp = path;
if( path[0] == DIR_SEP && path[1] == DIR_SEP ) {
path += 2;
for( ;; ) {
if( *path == NULLCHAR )
break;
if( *path == DIR_SEP )
break;
if( *path == STRING( '.' ) )
break;
++path;
}
}
copypart( drive, startp, path - startp, _MAX_NODE );
#elif defined(__NETWARE__)
#ifdef __WIDECHAR__
ptr = wcschr( path, DRV_SEP );
#else
ptr = _mbschr( (unsigned char *)path, DRV_SEP );
#endif
if( ptr != NULL ) {
if( drive != NULL ) {
copypart( drive, path, ptr - path + 1, _MAX_SERVER + _MAX_VOLUME + 1 );
}
#if defined( __WIDECHAR__ )
path = ptr + 1;
#else
path = _mbsinc( ptr );
#endif
} else if( drive != NULL ) {
*drive = NULLCHAR;
}
#else
/* processs drive specification */
if( path[0] != NULLCHAR && path[1] == DRV_SEP ) {
if( drive != NULL ) {
drive[0] = path[0];
drive[1] = DRV_SEP;
drive[2] = NULLCHAR;
}
path += 2;
} else if( drive != NULL ) {
drive[0] = NULLCHAR;
}
#endif
/* process /user/fred/filename.ext for QNX */
/* process /fred/filename.ext for DOS, OS/2 */
dotp = NULL;
fnamep = path;
startp = path;
for( ;; ) { /* 07-jul-91 DJG -- save *path in ch for speed */
if( *path == NULLCHAR )
break;
#if defined( __WIDECHAR__ ) || defined( __UNIX__ ) || defined( __RDOS__ ) || defined( __RDOSDEV__ )
ch = *path;
#else
ch = _mbsnextc( (unsigned char *)path );
#endif
if( ch == EXT_SEP ) {
dotp = path;
++path;
continue;
}
#if defined( __WIDECHAR__ ) || defined( __UNIX__ ) || defined( __RDOS__ ) || defined( __RDOSDEV__ )
++path;
#else
path = (char *)_mbsinc( (unsigned char *)path );
#endif
if( IS_DIR_SEP( ch ) ) {
fnamep = path;
dotp = NULL;
}
}
copypart( dir, startp, fnamep - startp, _MAX_DIR - 1 );
if( dotp == NULL )
dotp = path;
copypart( fname, fnamep, dotp - fnamep, _MAX_FNAME - 1 );
copypart( ext, dotp, path - dotp, _MAX_EXT - 1);
}
HSURFACE CTextHelper::CreateWrappedSurface (ILTClient* pClientDE, int nWidth, HLTFONT hFont, char* pString, HLTCOLOR foreColor, HLTCOLOR backColor, int nAlignment, LTBOOL bCropped, int nExtraX, int nExtraY)
{
if (!pString || !pClientDE) return LTNULL;
// check if we are supposed to do hard wrapping
bool bHardTextWrap = false;
{
HSTRING hStr = pClientDE->FormatString(IDS_ENABLETEXTHARDWRAP);
if (hStr)
{
const char* pComp = pClientDE->GetStringData(hStr);
if (pComp != NULL)
{
if (stricmp(pComp,"TRUE") == 0) bHardTextWrap = true;
}
pClientDE->FreeString (hStr);
}
}
// get period or other characters that are not supposed to be at start of a line
char sPeriodChars[256] = ".";
{
HSTRING hStr = pClientDE->FormatString(IDS_EXCLULTLineSTARTCHARS);
if (hStr)
{
const char* pComp = pClientDE->GetStringData(hStr);
if (pComp != NULL)
{
_mbsncpy((unsigned char*)sPeriodChars, (const unsigned char*)pComp, 255);
sPeriodChars[255] = '\0';
}
pClientDE->FreeString (hStr);
}
}
char* pWorkingString = new char [strlen (pString) + 1];
if (!pWorkingString) return LTNULL;
CDynArray<uint32> surfaces (1, 2); // cannot create a dynarray of HSURFACES - compiler error C2926
uint32 nSurfaces = 0;
char* ptr = (char*) pString;
while (*ptr != '\0')
{
// copy what's left into the working string
strcpy (pWorkingString, ptr);
// create a string that will fit into the desired width
LTBOOL bDone = LTFALSE;
HSURFACE hSurface = LTNULL;
while (!bDone)
{
// create a string surface from the working string to test
HSTRING hString = pClientDE->CreateString (pWorkingString);
if (!hString) break;
hSurface = pClientDE->CreateSurfaceFromString (hFont, hString, foreColor, backColor, nExtraX, nExtraY);
if (!hSurface)
{
pClientDE->FreeString (hString);
break;
}
pClientDE->FreeString (hString);
// get the dimensions of the surface
uint32 nTestWidth = 0;
uint32 nTestHeight = 0;
pClientDE->GetSurfaceDims (hSurface, &nTestWidth, &nTestHeight);
if (nTestWidth > (uint32)nWidth)
{
// string too long, remove some and try again
char* pSpace;
// remove by character if we are hard wrapping
if (bHardTextWrap)
{
pSpace = pWorkingString;
// find last hard in string pPrev
char* pPrev = NULL;
while (pSpace != NULL)
{
pPrev = pSpace;
pSpace = (char*)_mbsinc ((const unsigned char*)pSpace);
if (*pSpace == '\0') pSpace = NULL;
}
if (pPrev == NULL) pSpace = pWorkingString;
else
{
//decrement 1 character
pSpace = (char*)_mbsdec ((const unsigned char*)pWorkingString, (const unsigned char*)pPrev);
// check if we are on a period then we need to decrement 3 more
if ((char*)_mbsspnp((const unsigned char*)pPrev, (const unsigned char*)sPeriodChars) != pPrev)
{
if (pSpace != NULL) pSpace = (char*)_mbsdec ((const unsigned char*)pWorkingString, (const unsigned char*)pSpace);
if (pSpace != NULL) pSpace = (char*)_mbsdec ((const unsigned char*)pWorkingString, (const unsigned char*)pSpace);
}
}
}
// remove by word if hard wrap is not on
else
{
pSpace = (char*)_mbsrchr ((const unsigned char*)pWorkingString, ' ');
if (!pSpace) pSpace = pWorkingString;
while (_mbsnbcmp ((const unsigned char*)pSpace, (const unsigned char*)" ", 1) == 0 && pSpace != pWorkingString)
{
pSpace = (char*)_mbsdec ((const unsigned char*)pWorkingString, (const unsigned char*)pSpace);
if (!pSpace) pSpace = pWorkingString;
}
}
if (pSpace == pWorkingString)
{
bDone = LTTRUE;
}
else
{
pSpace = (char*)_mbsinc ((const unsigned char*)pSpace);
*pSpace = '\0';
}
pClientDE->DeleteSurface (hSurface);
hSurface = LTNULL;
}
else
{
// it fits!
bDone = LTTRUE;
}
}
// if we got here without bDone being TRUE, there was an error
if (!bDone)
{
delete [] pWorkingString;
for (uint32 i = 0; i < nSurfaces; i++)
{
pClientDE->DeleteSurface ((HSURFACE)surfaces[i]);
}
return LTNULL;
}
// if bDone is true but there's no surface, we couldn't make it fit
// just create a surface from the string and it will get clipped later
if (bDone && !hSurface)
{
HSTRING hString = pClientDE->CreateString (pWorkingString);
hSurface = pClientDE->CreateSurfaceFromString (hFont, hString, foreColor, backColor, nExtraX, nExtraY);
if (!hString || !hSurface)
{
if (hString) pClientDE->FreeString (hString);
if (hSurface) pClientDE->DeleteSurface (hSurface);
delete [] pWorkingString;
for (uint32 i = 0; i < nSurfaces; i++)
{
pClientDE->DeleteSurface ((HSURFACE)surfaces[i]);
}
return LTNULL;
}
pClientDE->FreeString (hString);
}
// add this surface to the array
surfaces[nSurfaces] = (uint32) hSurface;
nSurfaces++;
// increment ptr to next character in the string
ptr += strlen (pWorkingString);
char* pPrev = NULL;
while (_mbsnbcmp ((const unsigned char*)ptr, (const unsigned char*)" ", 1) == 0 && *ptr)
{
pPrev = ptr;
ptr = (char*)_mbsinc ((const unsigned char*)ptr);
if (!ptr)
{
ptr = pPrev;
break;
}
}
}
delete [] pWorkingString;
// ok, now we should have an array of surfaces that we can combine into one large one...
if (!nSurfaces) return LTNULL;
// crop the surfaces if they need to be cropped (leave a one-pixel border)
if (bCropped)
{
for (uint32 i = 0; i < nSurfaces; i++)
{
HSURFACE hCropped = CropSurface (pClientDE, (HSURFACE)surfaces[i], LTNULL);
if (hCropped)
{
pClientDE->DeleteSurface ((HSURFACE)surfaces[i]);
surfaces[i] = (uint32) hCropped;
}
}
}
// get the final surface height
uint32 nTotalHeight = 0;
for (uint32 i = 0; i < nSurfaces; i++)
{
uint32 nSurfWidth = 0;
uint32 nSurfHeight = 0;
pClientDE->GetSurfaceDims ((HSURFACE)surfaces[i], &nSurfWidth, &nSurfHeight);
nTotalHeight += nSurfHeight;
}
// create the final surface
HSURFACE hFinalSurface = pClientDE->CreateSurface (nWidth, nTotalHeight);
if (!hFinalSurface)
{
for (uint32 i = 0; i < nSurfaces; i++)
{
pClientDE->DeleteSurface ((HSURFACE)surfaces[i]);
}
return LTNULL;
}
pClientDE->FillRect ((HSURFACE)hFinalSurface, LTNULL, LTNULL);
// draw the string surfaces onto final one
int y = 0;
for (int i = 0; i < nSurfaces; i++)
{
uint32 nSurfWidth = 0;
uint32 nSurfHeight = 0;
pClientDE->GetSurfaceDims ((HSURFACE)surfaces[i], &nSurfWidth, &nSurfHeight);
int x = 0;
switch (nAlignment)
{
case TH_ALIGN_CENTER: x = ((int)nWidth - (int)nSurfWidth) / 2; break;
case TH_ALIGN_RIGHT: x = (int)nWidth - (int)nSurfWidth; break;
}
pClientDE->DrawSurfaceToSurface (hFinalSurface, (HSURFACE)surfaces[i], LTNULL, x, y);
y += nSurfHeight;
// delete this surface since we don't need it anymore
pClientDE->DeleteSurface ((HSURFACE)surfaces[i]);
}
if (bCropped)
{
HSURFACE hCropped = CropSurface (pClientDE, hFinalSurface, backColor);
if (hCropped)
{
pClientDE->DeleteSurface (hFinalSurface);
return hCropped;
}
}
return hFinalSurface;
}
/*
* _DisplayLineInWindowWithColor - as it sounds!
*/
void _DisplayLineInWindowWithColor( LPWDATA w, int line, LPSTR text, int c1,
int c2, int extra, int startcol )
{
#ifdef _MBCS
LPBYTE tmp;
#else
LPSTR tmp;
#endif
char buff[256];
int start,end,a,spend,cnt1,cnt2;
WORD i;
HWND hwnd;
hwnd = w->hwnd;
/*** Find dimensions of line ***/
#ifdef _MBCS
tmp = FAR_mbsninc( (LPBYTE)text, startcol );
a = FAR_mbslen( tmp );
if( line < 1 || line >= w->height )
return;
start = 0;
spend = end = w->width - extra;
if( end > a )
end = a;
cnt1 = FAR_mbsnbcnt( tmp, end - start );
cnt2 = spend - end;
FAR_mbsnbcpy( (LPBYTE)buff, tmp, cnt1 - start );
FARmemset( buff + cnt1, ' ', cnt2 );
tmp = FAR_mbsninc( (LPBYTE)buff, cnt1 + cnt2 );
*tmp = '\0';
#else
tmp = text;
tmp += startcol;
a = FARstrlen( tmp );
if( line < 1 || line >= w->height )
return;
start = 0;
spend = end = w->width - extra;
if( end > a )
end = a;
cnt1 = end - start;
cnt2 = spend - end;
FARmemcpy( buff, tmp, cnt1 );
FARmemset( buff + cnt1, ' ', cnt2 );
buff[cnt1 + cnt2] = 0;
#endif
line--;
#if defined( __OS2__ )
{
RECTL rcl;
HPS ps;
POINTL ptl;
POINTL points[TXTBOX_COUNT];
ptl.x = 0;
ptl.y = (w->y2 - w->y1) - (line+1)*w->ychar + w->base_offset;
ps = WinGetPS( hwnd );
_SelectFont( ps );
GpiQueryTextBox( ps, startcol, w->tmpbuff->data, TXTBOX_COUNT, points );
rcl.xLeft = points[TXTBOX_BOTTOMRIGHT].x;
#ifdef _MBCS
GpiQueryTextBox( ps, __mbslen( (unsigned char *)buff ), buff, TXTBOX_COUNT, points );
#else
GpiQueryTextBox( ps, strlen( buff ), buff, TXTBOX_COUNT, points );
#endif
rcl.xRight = points[TXTBOX_BOTTOMRIGHT].x;
rcl.yTop = (w->y2 - w->y1) - line*w->ychar;
rcl.yBottom = rcl.yTop - w->ychar;
WinFillRect( ps, &rcl, c1 );
GpiSetColor( ps, c2 );
#ifdef _MBCS
GpiCharStringAt( ps, &ptl, _mbsnbcnt(buff,w->width), buff );
#else
GpiCharStringAt( ps, &ptl, w->width, buff );
#endif
WinReleasePS( ps );
}
#else
{
HDC dc;
// SIZE size;
// RECT rect;
dc = GetDC( hwnd );
_SetMyDC( dc, _ColorMap[c2], _ColorMap[c1] );
// #ifdef __NT__
// GetTextExtentPoint32( dc, buff, strlen(buff), &size );
// #else
// GetTextExtentPoint( dc, buff, strlen(buff), &size );
// #endif
//
#ifdef _MBCS
TextOut( dc, 0, line * w->ychar, (LPSTR)buff, FAR_mbsnbcnt( (LPBYTE)buff, w->width ) );
#else
TextOut( dc, 0, line * w->ychar, buff, w->width );
#endif
/*** Clear to end of line to remove any residue ***/
// GetClientRect( w->hwnd, &rect );
// rect.top = line * w->ychar;
// rect.bottom = (line+1) * w->ychar ;
// rect.left = size.cx;
// FillRect( dc, &rect, w->brush );
ReleaseDC( hwnd, dc );
}
#endif
/*** Update the w->image array ***/
#ifdef _MBCS
{
mb_char mbc;
unsigned char *curMbc;
int count;
i = line * w->width + startcol;
for( count = 0, curMbc = (unsigned char *)buff; count < w->width - startcol; count++ ) {
mbc = _mbsnextc( curMbc ); /* get the character */
curMbc = _mbsinc( curMbc ); /* point to next char */
w->image[i + count] = mbc; /* store it in w->image */
}
}
#else
i = line * w->width + startcol;
FARmemcpy( &w->image[i], buff, w->width - startcol );
#endif
} /* _DisplayLineInWindowWithColor */
static void test_mbcp(void)
{
int mb_orig_max = *p__mb_cur_max;
int curr_mbcp = _getmbcp();
unsigned char *mbstring = (unsigned char *)"\xb0\xb1\xb2 \xb3\xb4 \xb5"; /* incorrect string */
unsigned char *mbstring2 = (unsigned char *)"\xb0\xb1\xb2\xb3Q\xb4\xb5"; /* correct string */
unsigned char *mbsonlylead = (unsigned char *)"\xb0\0\xb1\xb2 \xb3";
unsigned char buf[16];
int step;
/* _mbtype tests */
/* An SBCS codepage test. The ctype of characters on e.g. CP1252 or CP1250 differs slightly
* between versions of Windows. Also Windows 9x seems to ignore the codepage and always uses
* CP1252 (or the ACP?) so we test only a few ASCII characters */
_setmbcp(1252);
expect_eq(p_mbctype[10], 0, char, "%x");
expect_eq(p_mbctype[50], 0, char, "%x");
expect_eq(p_mbctype[66], _SBUP, char, "%x");
expect_eq(p_mbctype[100], _SBLOW, char, "%x");
expect_eq(p_mbctype[128], 0, char, "%x");
_setmbcp(1250);
expect_eq(p_mbctype[10], 0, char, "%x");
expect_eq(p_mbctype[50], 0, char, "%x");
expect_eq(p_mbctype[66], _SBUP, char, "%x");
expect_eq(p_mbctype[100], _SBLOW, char, "%x");
expect_eq(p_mbctype[128], 0, char, "%x");
/* double byte code pages */
test_codepage(932);
test_codepage(936);
test_codepage(949);
test_codepage(950);
_setmbcp(936);
ok(*p__mb_cur_max == mb_orig_max, "__mb_cur_max shouldn't be updated (is %d != %d)\n", *p__mb_cur_max, mb_orig_max);
ok(_ismbblead('\354'), "\354 should be a lead byte\n");
ok(_ismbblead(' ') == FALSE, "' ' should not be a lead byte\n");
ok(_ismbblead(0x1234b0), "0x1234b0 should not be a lead byte\n");
ok(_ismbblead(0x123420) == FALSE, "0x123420 should not be a lead byte\n");
ok(_ismbbtrail('\xb0'), "\xa0 should be a trail byte\n");
ok(_ismbbtrail(' ') == FALSE, "' ' should not be a trail byte\n");
/* _ismbslead */
expect_eq(_ismbslead(mbstring, &mbstring[0]), -1, int, "%d");
expect_eq(_ismbslead(mbstring, &mbstring[1]), FALSE, int, "%d");
expect_eq(_ismbslead(mbstring, &mbstring[2]), -1, int, "%d");
expect_eq(_ismbslead(mbstring, &mbstring[3]), FALSE, int, "%d");
expect_eq(_ismbslead(mbstring, &mbstring[4]), -1, int, "%d");
expect_eq(_ismbslead(mbstring, &mbstring[5]), FALSE, int, "%d");
expect_eq(_ismbslead(mbstring, &mbstring[6]), FALSE, int, "%d");
expect_eq(_ismbslead(mbstring, &mbstring[7]), -1, int, "%d");
expect_eq(_ismbslead(mbstring, &mbstring[8]), FALSE, int, "%d");
expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[0]), -1, int, "%d");
expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[1]), FALSE, int, "%d");
expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[2]), FALSE, int, "%d");
expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[5]), FALSE, int, "%d");
/* _ismbstrail */
expect_eq(_ismbstrail(mbstring, &mbstring[0]), FALSE, int, "%d");
expect_eq(_ismbstrail(mbstring, &mbstring[1]), -1, int, "%d");
expect_eq(_ismbstrail(mbstring, &mbstring[2]), FALSE, int, "%d");
expect_eq(_ismbstrail(mbstring, &mbstring[3]), -1, int, "%d");
expect_eq(_ismbstrail(mbstring, &mbstring[4]), FALSE, int, "%d");
expect_eq(_ismbstrail(mbstring, &mbstring[5]), -1, int, "%d");
expect_eq(_ismbstrail(mbstring, &mbstring[6]), FALSE, int, "%d");
expect_eq(_ismbstrail(mbstring, &mbstring[7]), FALSE, int, "%d");
expect_eq(_ismbstrail(mbstring, &mbstring[8]), -1, int, "%d");
expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[0]), FALSE, int, "%d");
expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[1]), -1, int, "%d");
expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[2]), FALSE, int, "%d");
expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[3]), FALSE, int, "%d");
expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[4]), FALSE, int, "%d");
expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[5]), FALSE, int, "%d");
/* _mbsbtype */
expect_eq(_mbsbtype(mbstring, 0), _MBC_LEAD, int, "%d");
expect_eq(_mbsbtype(mbstring, 1), _MBC_TRAIL, int, "%d");
expect_eq(_mbsbtype(mbstring, 2), _MBC_LEAD, int, "%d");
expect_eq(_mbsbtype(mbstring, 3), _MBC_ILLEGAL, int, "%d");
expect_eq(_mbsbtype(mbstring, 4), _MBC_LEAD, int, "%d");
expect_eq(_mbsbtype(mbstring, 5), _MBC_TRAIL, int, "%d");
expect_eq(_mbsbtype(mbstring, 6), _MBC_SINGLE, int, "%d");
expect_eq(_mbsbtype(mbstring, 7), _MBC_LEAD, int, "%d");
expect_eq(_mbsbtype(mbstring, 8), _MBC_ILLEGAL, int, "%d");
expect_eq(_mbsbtype(mbsonlylead, 0), _MBC_LEAD, int, "%d");
expect_eq(_mbsbtype(mbsonlylead, 1), _MBC_ILLEGAL, int, "%d");
expect_eq(_mbsbtype(mbsonlylead, 2), _MBC_ILLEGAL, int, "%d");
expect_eq(_mbsbtype(mbsonlylead, 3), _MBC_ILLEGAL, int, "%d");
expect_eq(_mbsbtype(mbsonlylead, 4), _MBC_ILLEGAL, int, "%d");
expect_eq(_mbsbtype(mbsonlylead, 5), _MBC_ILLEGAL, int, "%d");
/* _mbsnextc */
expect_eq(_mbsnextc(mbstring), 0xb0b1, int, "%x");
expect_eq(_mbsnextc(&mbstring[2]), 0xb220, int, "%x"); /* lead + invalid tail */
expect_eq(_mbsnextc(&mbstring[3]), 0x20, int, "%x"); /* single char */
/* _mbclen/_mbslen */
expect_eq(_mbclen(mbstring), 2, int, "%d");
expect_eq(_mbclen(&mbstring[2]), 2, int, "%d");
expect_eq(_mbclen(&mbstring[3]), 1, int, "%d");
expect_eq(_mbslen(mbstring2), 4, int, "%d");
expect_eq(_mbslen(mbsonlylead), 0, int, "%d"); /* lead + NUL not counted as character */
expect_eq(_mbslen(mbstring), 4, int, "%d"); /* lead + invalid trail counted */
/* _mbccpy/_mbsncpy */
memset(buf, 0xff, sizeof(buf));
_mbccpy(buf, mbstring);
expect_bin(buf, "\xb0\xb1\xff", 3);
memset(buf, 0xff, sizeof(buf));
_mbsncpy(buf, mbstring, 1);
expect_bin(buf, "\xb0\xb1\xff", 3);
memset(buf, 0xff, sizeof(buf));
_mbsncpy(buf, mbstring, 2);
expect_bin(buf, "\xb0\xb1\xb2 \xff", 5);
memset(buf, 0xff, sizeof(buf));
_mbsncpy(buf, mbstring, 3);
expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4\xff", 7);
memset(buf, 0xff, sizeof(buf));
_mbsncpy(buf, mbstring, 4);
expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4 \xff", 8);
memset(buf, 0xff, sizeof(buf));
_mbsncpy(buf, mbstring, 5);
expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4 \0\0\xff", 10);
memset(buf, 0xff, sizeof(buf));
_mbsncpy(buf, mbsonlylead, 6);
expect_bin(buf, "\0\0\0\0\0\0\0\xff", 8);
memset(buf, 0xff, sizeof(buf));
_mbsnbcpy(buf, mbstring2, 2);
expect_bin(buf, "\xb0\xb1\xff", 3);
_mbsnbcpy(buf, mbstring2, 3);
expect_bin(buf, "\xb0\xb1\0\xff", 4);
_mbsnbcpy(buf, mbstring2, 4);
expect_bin(buf, "\xb0\xb1\xb2\xb3\xff", 5);
memset(buf, 0xff, sizeof(buf));
_mbsnbcpy(buf, mbsonlylead, 5);
expect_bin(buf, "\0\0\0\0\0\xff", 6);
/* _mbsinc/mbsdec */
step = _mbsinc(mbstring) - mbstring;
ok(step == 2, "_mbsinc adds %d (exp. 2)\n", step);
step = _mbsinc(&mbstring[2]) - &mbstring[2]; /* lead + invalid tail */
ok(step == 2, "_mbsinc adds %d (exp. 2)\n", step);
step = _mbsninc(mbsonlylead, 1) - mbsonlylead;
ok(step == 0, "_mbsninc adds %d (exp. 0)\n", step);
step = _mbsninc(mbsonlylead, 2) - mbsonlylead; /* lead + NUL byte + lead + char */
ok(step == 0, "_mbsninc adds %d (exp. 0)\n", step);
step = _mbsninc(mbstring2, 0) - mbstring2;
ok(step == 0, "_mbsninc adds %d (exp. 2)\n", step);
step = _mbsninc(mbstring2, 1) - mbstring2;
ok(step == 2, "_mbsninc adds %d (exp. 2)\n", step);
step = _mbsninc(mbstring2, 2) - mbstring2;
ok(step == 4, "_mbsninc adds %d (exp. 4)\n", step);
step = _mbsninc(mbstring2, 3) - mbstring2;
ok(step == 5, "_mbsninc adds %d (exp. 5)\n", step);
step = _mbsninc(mbstring2, 4) - mbstring2;
ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step);
step = _mbsninc(mbstring2, 5) - mbstring2;
ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step);
step = _mbsninc(mbstring2, 17) - mbstring2;
ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step);
/* functions that depend on locale codepage, not mbcp.
* we hope the current locale to be SBCS because setlocale(LC_ALL, ".1252") seems not to work yet
* (as of Wine 0.9.43)
*/
if (*p__mb_cur_max == 1)
{
expect_eq(mblen((char *)mbstring, 3), 1, int, "%x");
expect_eq(_mbstrlen((char *)mbstring2), 7, int, "%d");
}
