value ml_text_upper(value ch) {
return Val_int(towupper(Int_val(ch)));
}
int assignLetter(WCHAR letter, PCWSTR path)
{
BOOL ret;
DWORD len;
PWSTR str;
HV_TYPES vm;
WCHAR capsLetter;
DWORD inputBufferSize;
PASSIGN_INPUT inputBuffer;
vm = detectVM();
if (vm == vmMax)
{
wprintf(L"Unsupported VM type\n");
return 1;
}
if (iswalpha(letter) == 0)
{
wprintf(L"Invalid letter provided\n");
return 1;
}
capsLetter = towupper(letter);
if (capsLetter == L'C')
{
wprintf(L"Looks suspicious, won't proceed\n");
return 1;
}
len = wcslen(path);
if (len == 0)
{
wprintf(L"Invalid share name\n");
return 1;
}
if (wcschr(path, L'\\') != NULL)
{
wprintf(L"Only give the name of a share\n");
return 1;
}
inputBufferSize = len * sizeof(WCHAR) + sizeof(ASSIGN_INPUT) + (wcslen(dev[vm]) + wcslen(unc[vm]) + 2) * sizeof(WCHAR);
inputBuffer = malloc(inputBufferSize);
if (inputBuffer == NULL)
{
wprintf(L"Memory failure\n");
return 1;
}
inputBuffer->letter = capsLetter;
inputBuffer->offset = sizeof(ASSIGN_INPUT);
inputBuffer->len = len * sizeof(WCHAR) + (wcslen(dev[vm]) + wcslen(unc[vm]) + 1) * sizeof(WCHAR);
str = (PWSTR)((ULONG_PTR)inputBuffer + inputBuffer->offset);
swprintf(str, L"%s%c%s%s", dev[vm], capsLetter, unc[vm], path);
if (!startService())
{
free(inputBuffer);
return 1;
}
Sleep(500);
ret = performDevIoCtl(FSCTL_HACKSSIGN_ASSIGN, inputBuffer, inputBufferSize);
free(inputBuffer);
return (ret == FALSE);
}
static int
do_test (void)
{
const char *loc = "de_DE.ISO-8859-1";
if (setlocale (LC_ALL, loc) == NULL)
{
printf ("cannot set %s locale\n", loc);
return 1;
}
printf ("selected locale %s\n", loc);
wint_t win = 0xe4;
wint_t wex = 0xc4;
wint_t wch = towupper (win);
if (wch != wex)
{
printf ("towupper(%x) = %x, expected %x\n", win, wch, wex);
return 1;
}
wch = toupper (win);
if (wch != wex)
{
printf ("toupper(%x) = %x, expected %x\n", win, wch, wex);
return 1;
}
win = 0x69;
wex = 0x49;
wch = towupper (win);
if (wch != wex)
{
printf ("towupper(%x) = %x, expected %x\n", win, wch, wex);
return 1;
}
wch = toupper (win);
if (wch != wex)
{
printf ("toupper(%x) = %x, expected %x\n", win, wch, wex);
return 1;
}
loc = "tr_TR.ISO-8859-9";
if (setlocale (LC_ALL, loc) == NULL)
{
printf ("cannot set %s locale\n", loc);
return 1;
}
printf ("selected locale %s\n", loc);
win = 0x69;
wex = 0x130;
wch = towupper (win);
if (wch != wex)
{
printf ("towupper(%x) = %x, expected %x\n", win, wch, wex);
return 1;
}
wch = toupper (win);
wex = 0xdd;
if (wch != wex)
{
printf ("toupper(%x) = %x, expected %x\n", win, wch, wex);
return 1;
}
return 0;
}
size_t mbstoupper( char *s1, char *s2, size_t n )
/* Copies the multibyte string from s2 to s1, converting all the
characters to uppercase on the way.
Because there are no standard functions for case-mapping in multibyte
encodings, converts to and from the wide-character encoding (using the
current locale setting for the LC_CTYPE category). The source string
must begin in the initial shift state.
Returns: the number of bytes written;
or (size_t)-1 on an encoding error.
*/
{
char *inptr = s2, *outptr = s1;
wchar_t thiswc[1];
size_t inresult, outresult;
mbstate_t states[2], *instate = &states[0], *outstate = &states[1];
memset( states, '\0', sizeof states );
do
{
inresult = mbrtowc( thiswc, inptr, MB_CUR_MAX, instate );
switch ( inresult )
{
case (size_t)-2: // The (MB_CUR_MAX) bytes at inptr do not make
// a complete mb character. Maybe there is a
// redundant sequence of shift codes. Treat the
// same as an encoding error.
*outptr = '\0';
return (size_t)-1;
case (size_t)-1: // Found an invalid mb sequence at inptr:
return inresult; // pass the error to the caller.
case 0: // Got a null character. Make a last null wc.
// The default action, with wcrtomb, does this
// nicely, so *no break statement* necessary here.
default: // Read <result> mb characters to get one wide
// character.
/* Check for length limit before writing anything but a null.
Note: Using inresult as an approximation for the output
length.
The actual output length could conceivably be different
due to a different succession of state-shift sequences.
*/
if (( outptr - s1 ) + inresult + MB_CUR_MAX > n )
{ // i.e., if bytes written + bytes to write + termination > n,
// then terminate now by simulating a null-character input.
thiswc[0] = L'\0';
inresult = 0;
}
inptr += inresult;
if (( outresult = wcrtomb( outptr,
(wchar_t)towupper(thiswc[0]),
outstate )) == -1 )
{ // Encoding error on output:
*outptr = '\0'; // Terminate and return error.
return outresult;
}
else
outptr += outresult;
}
} while ( inresult ); // Drop out after handling '\0'.
return outptr - s1;
}
void FF_toupper(FF_T_WCHAR *string, FF_T_UINT32 strLen) {
FF_T_UINT32 i;
for(i = 0; i < strLen; i++) {
string[i] = towupper(string[i]);
}
}
bool StringUtil::filterString(const char* filter, const char* name, bool casesensitive) {
char buf[1024];
int num;
bool flag;
while (*filter) {
if (*filter == '*') {
filter++;
num = 0;
for (; *filter && *filter != '*' && *filter != '?'; filter++) {
buf[num++] = *filter;
}
buf[num] = 0;
if (!num)
continue;
if (!__StringContains(name, buf, casesensitive))
return false;
if (!*filter)
return true;
} else if (*filter == '?') {
filter++;
name++;
} else if (*filter == '[') {
if (filter[1] == '[') {
filter++;
continue;
}
filter++;
flag = false;
if (!*filter)
return false;
while (*filter) {
if (flag)
break;
if (*filter == ']' && filter[1] != ']')
return false;
if (filter[1] == '-' && filter[2] && (filter[2] != ']' || filter[3] == ']')) {
if (casesensitive) {
if (*name >= filter[0] && *name <= filter[2]) {
flag = true;
}
} else {
if (towupper(*name) >= towupper(filter[0]) && towupper(*name) <= towupper(filter[2])) {
flag = true;
}
}
filter += 3;
} else {
if (casesensitive) {
if (*filter == *name)
flag = true;
} else {
if (towupper(*filter) == towupper(*name))
flag = true;
}
filter++;
}
}
if (!flag)
return false;
while (*filter) {
if (*filter == ']' && filter[1] != ']')
break;
filter++;
}
filter++;
name++;
} else {
if (casesensitive) {
if (*filter != *name)
return false;
} else {
if (towupper(*filter) != towupper(*name))
return false;
}
filter++;
name++;
}
}
return true;
}
static unsigned long __cdecl wcstoxl (
const wchar_t *nptr,
const wchar_t **endptr,
int ibase,
int flags
)
{
const wchar_t *p;
wchar_t c;
unsigned long number;
unsigned digval;
unsigned long maxval;
p = nptr; /* p is our scanning pointer */
number = 0; /* start with zero */
c = *p++; /* read char */
while ( iswspace(c) )
c = *p++; /* skip whitespace */
if (c == '-') {
flags |= FL_NEG; /* remember minus sign */
c = *p++;
}
else if (c == '+')
c = *p++; /* skip sign */
if (ibase < 0 || ibase == 1 || ibase > 36) {
/* bad base! */
if (endptr)
/* store beginning of string in endptr */
*endptr = nptr;
return 0L; /* return 0 */
}
else if (ibase == 0) {
/* determine base free-lance, based on first two chars of
string */
if (c != L'0')
ibase = 10;
else if (*p == L'x' || *p == L'X')
ibase = 16;
else
ibase = 8;
}
if (ibase == 16) {
/* we might have 0x in front of number; remove if there */
if (c == L'0' && (*p == L'x' || *p == L'X')) {
++p;
c = *p++; /* advance past prefix */
}
}
/* if our number exceeds this, we will overflow on multiply */
maxval = ULONG_MAX / ibase;
for (;;) { /* exit in middle of loop */
/* make sure c is not too big */
if ( (unsigned)c > UCHAR_MAX )
break;
/* convert c to value */
if ( iswdigit(c) )
digval = c - L'0';
else if ( iswalpha(c))
digval = towupper(c) - L'A' + 10;
else
break;
if (digval >= (unsigned)ibase)
break; /* exit loop if bad digit found */
/* record the fact we have read one digit */
flags |= FL_READDIGIT;
/* we now need to compute number = number * base + digval,
but we need to know if overflow occured. This requires
a tricky pre-check. */
if (number < maxval || (number == maxval &&
(unsigned long)digval <= ULONG_MAX % ibase)) {
/* we won't overflow, go ahead and multiply */
number = number * ibase + digval;
}
else {
/* we would have overflowed -- set the overflow flag */
flags |= FL_OVERFLOW;
}
c = *p++; /* read next digit */
}
--p; /* point to place that stopped scan */
if (!(flags & FL_READDIGIT)) {
/* no number there; return 0 and point to beginning of
string */
if (endptr)
/* store beginning of string in endptr later on */
p = nptr;
number = 0L; /* return 0 */
}
else if ( (flags & FL_OVERFLOW) ||
( !(flags & FL_UNSIGNED) &&
( ( (flags & FL_NEG) && (number > -LONG_MIN) ) ||
( !(flags & FL_NEG) && (number > LONG_MAX) ) ) ) )
{
/* overflow or signed overflow occurred */
errno = ERANGE;
if ( flags & FL_UNSIGNED )
number = ULONG_MAX;
else
number = LONG_MAX;
flags &= ~FL_NEG;
}
else if ((flags & FL_UNSIGNED) && (flags & FL_NEG)) {
// Disallow a negative sign if we're reading an unsigned
number = 0L;
p = nptr;
}
if (endptr != NULL)
/* store pointer to char that stopped the scan */
*endptr = p;
if (flags & FL_NEG)
/* negate result if there was a neg sign */
number = (unsigned long)(-(long)number);
return number; /* done. */
}
wint_t towctrans(wint_t c, wctrans_t t) {
if (t == wctrans_tolower) return towlower(c);
if (t == wctrans_toupper) return towupper(c);
errno = EINVAL;
return 0;
}
VOID
CFileDefExt::InitOpensWithField(HWND hwndDlg)
{
WCHAR wszBuf[MAX_PATH] = L"";
WCHAR wszPath[MAX_PATH] = L"";
DWORD dwSize = sizeof(wszBuf);
BOOL bUnknownApp = TRUE;
LPCWSTR pwszExt = PathFindExtensionW(m_wszPath);
if (RegGetValueW(HKEY_CLASSES_ROOT, pwszExt, L"", RRF_RT_REG_SZ, NULL, wszBuf, &dwSize) == ERROR_SUCCESS)
{
bUnknownApp = FALSE;
StringCbCatW(wszBuf, sizeof(wszBuf), L"\\shell\\open\\command");
dwSize = sizeof(wszPath);
if (RegGetValueW(HKEY_CLASSES_ROOT, wszBuf, L"", RRF_RT_REG_SZ, NULL, wszPath, &dwSize) == ERROR_SUCCESS)
{
/* Get path from command line */
ExpandEnvironmentStringsW(wszPath, wszBuf, _countof(wszBuf));
PathRemoveArgs(wszBuf);
PathUnquoteSpacesW(wszBuf);
PathSearchAndQualify(wszBuf, wszPath, _countof(wszPath));
HICON hIcon;
if (ExtractIconExW(wszPath, 0, NULL, &hIcon, 1))
{
HWND hIconCtrl = GetDlgItem(hwndDlg, 14025);
HWND hDescrCtrl = GetDlgItem(hwndDlg, 14007);
ShowWindow(hIconCtrl, SW_SHOW);
RECT rcIcon, rcDescr;
GetWindowRect(hIconCtrl, &rcIcon);
if (rcIcon.left == rcIcon.right)
ERR("Icon control has invalid width: %d-%d\n", rcIcon.left, rcIcon.right);
MapWindowPoints(NULL, hwndDlg, (LPPOINT)&rcIcon, 2);
GetWindowRect(hDescrCtrl, &rcDescr);
MapWindowPoints(NULL, hwndDlg, (LPPOINT)&rcDescr, 2);
INT cxOffset = rcIcon.right + 2 - rcDescr.left;
SetWindowPos(hDescrCtrl, NULL,
rcDescr.left + cxOffset, rcDescr.top,
rcDescr.right - rcDescr.left - cxOffset, rcDescr.bottom - rcDescr.top,
SWP_NOZORDER);
SendMessageW(hIconCtrl, STM_SETICON, (WPARAM)hIcon, 0);
} else
ERR("Failed to extract icon\n");
if (PathFileExistsW(wszPath))
{
/* Get file description */
CFileVersionInfo VerInfo;
VerInfo.Load(wszPath);
LPCWSTR pwszDescr = VerInfo.GetString(L"FileDescription");
if (pwszDescr)
SetDlgItemTextW(hwndDlg, 14007, pwszDescr);
else
{
/* File has no description - display filename */
LPWSTR pwszFilename = PathFindFileNameW(wszPath);
PathRemoveExtension(pwszFilename);
pwszFilename[0] = towupper(pwszFilename[0]);
SetDlgItemTextW(hwndDlg, 14007, pwszFilename);
}
}
else
bUnknownApp = TRUE;
} else
WARN("RegGetValueW %ls failed\n", wszBuf);
} else
WARN("RegGetValueW %ls failed\n", pwszExt);
if (bUnknownApp)
{
/* Unknown application */
LoadStringW(shell32_hInstance, IDS_UNKNOWN_APP, wszBuf, _countof(wszBuf));
SetDlgItemTextW(hwndDlg, 14007, wszBuf);
}
}
int towupper_l(int c, locale_t l)
{
return towupper(c);
}
JAVA_INT java_lang_String_toUpperCaseImpl___int(JAVA_OBJECT me, JAVA_INT n1)
{
//XMLVM_BEGIN_NATIVE[java_lang_String_toUpperCaseImpl___int]
return towupper(n1);
//XMLVM_END_NATIVE
}
// check whether Name matches Expression
// Expression can contain "?"(any one character) and "*" (any string)
// when IgnoreCase is TRUE, do case insenstive matching
//
// http://msdn.microsoft.com/en-us/library/ff546850(v=VS.85).aspx
// * (asterisk) Matches zero or more characters.
// ? (question mark) Matches a single character.
// DOS_DOT Matches either a period or zero characters beyond the name string.
// DOS_QM Matches any single character or, upon encountering a period or end
// of name string, advances the expression to the end of the set of
// contiguous DOS_QMs.
// DOS_STAR Matches zero or more characters until encountering and matching
// the final . in the name.
BOOL DOKANAPI
DokanIsNameInExpression(
LPCWSTR Expression, // matching pattern
LPCWSTR Name, // file name
BOOL IgnoreCase)
{
ULONG ei = 0;
ULONG ni = 0;
while (Expression[ei] != '\0') {
if (Expression[ei] == L'*') {
ei++;
if (Expression[ei] == '\0')
return TRUE;
while (Name[ni] != '\0') {
if (DokanIsNameInExpression(&Expression[ei], &Name[ni], IgnoreCase))
return TRUE;
ni++;
}
} else if (Expression[ei] == DOS_STAR) {
ULONG p = ni;
ULONG lastDot = 0;
ei++;
while (Name[p] != '\0') {
if (Name[p] == L'.')
lastDot = p;
p++;
}
for ( ; ; ) {
if (Name[ni] == '\0' || ni == lastDot)
break;
if (DokanIsNameInExpression(&Expression[ei], &Name[ni], IgnoreCase))
return TRUE;
ni++;
}
} else if (Expression[ei] == DOS_QM) {
ei++;
if (Name[ni] != L'.') {
ni++;
} else {
ULONG p = ni + 1;
while (Name[p] != '\0') {
if (Name[p] == L'.')
break;
p++;
}
if (Name[p] == L'.')
ni++;
}
} else if (Expression[ei] == DOS_DOT) {
ei++;
if (Name[ni] == L'.')
ni++;
} else {
if (Expression[ei] == L'?') {
ei++; ni++;
} else if(IgnoreCase && towupper(Expression[ei]) == towupper(Name[ni])) {
ei++; ni++;
} else if(!IgnoreCase && Expression[ei] == Name[ni]) {
ei++; ni++;
} else {
return FALSE;
}
}
}
if (ei == wcslen(Expression) && ni == wcslen(Name))
return TRUE;
return FALSE;
}
void StartLogger()
{
SHOWTHREAD(_T("StartLogger"));
HANDLE hFile;
int i;
TCHAR path[MAX_PATH+1];
TCHAR cAsset[3];
// strAsset is initialized with DUM.
if (_tcslen(PilotName_Config)>0) {
strAssetNumber[0]= IsAlphaNum(PilotName_Config[0]) ? PilotName_Config[0] : _T('A');
strAssetNumber[1]= IsAlphaNum(PilotName_Config[1]) ? PilotName_Config[1] : _T('A');
} else {
strAssetNumber[0]= _T('D');
strAssetNumber[1]= _T('U');
}
if (_tcslen(AircraftType_Config)>0) {
strAssetNumber[2]= IsAlphaNum(AircraftType_Config[0]) ? AircraftType_Config[0] : _T('A');
} else {
strAssetNumber[2]= _T('M');
}
strAssetNumber[0]= towupper(strAssetNumber[0]);
strAssetNumber[1]= towupper(strAssetNumber[1]);
strAssetNumber[2]= towupper(strAssetNumber[2]);
strAssetNumber[3]= _T('\0');
for (i=0; i < 3; i++) { // chars must be legal in file names
cAsset[i] = IsAlphaNum(strAssetNumber[i]) ? strAssetNumber[i] : _T('A');
}
LocalPath(path,TEXT(LKD_LOGS));
if (TaskModified) {
SaveDefaultTask();
}
wsprintf(szLoggerFileName, TEXT("%s\\LOGGER_TMP.IGC"), path);
wsprintf(szSLoggerFileName, TEXT("%s\\LOGGER_SIG.IGC"), path);
TCHAR newfile[MAX_PATH+20];
if (GetFileAttributes(szLoggerFileName) != 0xffffffff) {
StartupStore(_T("---- Logger recovery: Existing LOGGER_TMP.IGC found, renamed to LOST%s"),NEWLINE);
wsprintf(newfile, TEXT("%s\\LOST_%02d%02d%02d.IGC"), path, GPS_INFO.Hour, GPS_INFO.Minute, GPS_INFO.Second);
CopyFile(szLoggerFileName,newfile,TRUE);
DeleteFile(szLoggerFileName);
}
if (GetFileAttributes(szSLoggerFileName) != 0xffffffff) {
StartupStore(_T("---- Logger recovery (G): Existing LOGGER_SIG.IGC found, renamed to LOSTG%s"),NEWLINE);
wsprintf(newfile, TEXT("%s\\LOSTG_%02d%02d%02d.IGC"), path, GPS_INFO.Hour, GPS_INFO.Minute, GPS_INFO.Second);
CopyFile(szSLoggerFileName,newfile,TRUE);
DeleteFile(szSLoggerFileName);
}
for(i=1;i<99;i++)
{
// 2003-12-31-XXX-987-01.IGC
// long filename form of IGC file.
// XXX represents manufacturer code
if (!LoggerShortName) {
// Long file name
wsprintf(szFLoggerFileName,
TEXT("%s\\%04d-%02d-%02d-%s-%c%c%c-%02d.IGC"),
path,
GPS_INFO.Year,
GPS_INFO.Month,
GPS_INFO.Day,
_T(LOGGER_MANUFACTURER),
cAsset[0],
cAsset[1],
cAsset[2],
i);
wsprintf(szFLoggerFileNameRoot,
TEXT("%s\\%04d-%02d-%02d-%s-%c%c%c-%02d.IGC"),
TEXT(""), // this creates it in root if MoveFile() fails
GPS_INFO.Year,
GPS_INFO.Month,
GPS_INFO.Day,
_T(LOGGER_MANUFACTURER),
cAsset[0],
cAsset[1],
cAsset[2],
i);
} else {
// Short file name
TCHAR cyear, cmonth, cday, cflight;
cyear = NumToIGCChar((int)GPS_INFO.Year % 10);
cmonth = NumToIGCChar(GPS_INFO.Month);
cday = NumToIGCChar(GPS_INFO.Day);
cflight = NumToIGCChar(i);
wsprintf(szFLoggerFileName,
TEXT("%s\\%c%c%cX%c%c%c%c.IGC"),
path,
cyear,
cmonth,
cday,
cAsset[0],
cAsset[1],
cAsset[2],
cflight);
wsprintf(szFLoggerFileNameRoot,
TEXT("%s\\%c%c%cX%c%c%c%c.IGC"),
TEXT(""), // this creates it in root if MoveFile() fails
cyear,
cmonth,
cday,
cAsset[0],
cAsset[1],
cAsset[2],
cflight);
} // end if
hFile = CreateFile(szFLoggerFileName, GENERIC_WRITE,
FILE_SHARE_WRITE, NULL, CREATE_NEW,
FILE_ATTRIBUTE_NORMAL, 0);
if(hFile!=INVALID_HANDLE_VALUE )
{
// file already exists
CloseHandle(hFile);
DeleteFile(szFLoggerFileName);
break;
}
} // end while
StartupStore(_T(". Logger Started %s File <%s>%s"),
WhatTimeIsIt(), szFLoggerFileName,NEWLINE);
return;
}
static int
iconv_ucs_conv(void *d2p, const char **inbuf,
size_t *inbytesleft, char **outbuf, size_t *outbytesleft,
int convchar, int casetype)
{
struct iconv_ucs *dp = (struct iconv_ucs*)d2p;
int ret = 0, i;
size_t in, on, ir, or, inlen, outlen, ucslen;
const char *src, *p;
char *dst;
u_char ucs[4], *q;
uint32_t code;
if (inbuf == NULL || *inbuf == NULL || outbuf == NULL || *outbuf == NULL)
return 0;
ir = in = *inbytesleft;
or = on = *outbytesleft;
src = *inbuf;
dst = *outbuf;
while (ir > 0 && or > 0) {
/*
* The first half of conversion.
* (convert any code into ENCODING_UNICODE)
*/
code = 0;
p = src;
if (dp->convtype & KICONV_UCS_FROM_UTF8) {
/* convert UTF-8 to ENCODING_UNICODE */
inlen = 0;
code = utf8_to_ucs4(p, &inlen, ir);
if (code == 0) {
ret = -1;
break;
}
if (casetype == KICONV_FROM_LOWER && dp->ctype) {
code = towlower(code, dp->ctype);
} else if (casetype == KICONV_FROM_UPPER && dp->ctype) {
code = towupper(code, dp->ctype);
}
if ((code >= 0xd800 && code < 0xe000) || code >= 0x110000 ) {
/* reserved for utf-16 surrogate pair */
/* invalid unicode */
ret = -1;
break;
}
if (inlen == 4) {
if (dp->convtype & KICONV_UCS_UCS4) {
ucslen = 4;
code = encode_surrogate(code);
} else {
/* can't handle with ucs-2 */
ret = -1;
break;
}
} else {
ucslen = 2;
}
/* save UCS-4 into ucs[] */
for (q = ucs, i = ucslen - 1 ; i >= 0 ; i--)
*q++ = (code >> (i << 3)) & 0xff;
} else if (dp->convtype & KICONV_UCS_COMBINE && dp->f_ctp) {
static int casecmp(wchar_t a, wchar_t b)
{
return towupper(a) == towupper(b);
}
wint_t __towupper_l(wint_t c, locale_t l)
{
return towupper(c);
}
bool IsVolumeDesignatorAvailable(WCHAR chVolume)
{
return IsDriveAvailable(towupper(chVolume) - L'A');
}
wchar_t CLocale::cl_upcase(wchar_t c)
{
return towupper(c);
};
int
main (int argc, char *argv[])
{
int result = 0;
wint_t ch;
for (ch = 0; ch < 128; ++ch)
{
if (iswlower (ch))
{
/* Get corresponding upper case character. */
wint_t up = towupper (ch);
/* This should have no effect. */
wint_t low = towlower (ch);
if ((ch != low) || (up == ch) || (up == low))
{
printf ("iswlower/towupper/towlower for character \\%x failed\n", ch);
result++;
}
}
if (iswupper (ch))
{
/* Get corresponding lower case character. */
wint_t low = towlower (ch);
/* This should have no effect. */
wint_t up = towupper (ch);
if ((ch != up) || (low == ch) || (up == low))
{
printf ("iswupper/towlower/towupper for character \\%x failed\n", ch);
result++;
}
}
}
/* Finally some specific tests. */
ch = L'A';
if (!iswupper (ch) || iswlower (ch))
{
printf ("!iswupper/iswlower (L'A') failed\n");
result++;
}
ch = L'a';
if (iswupper (ch) || !iswlower (ch))
{
printf ("iswupper/!iswlower (L'a') failed\n");
result++;
}
if (towlower (L'A') != L'a')
{
printf ("towlower(L'A') failed\n");
result++;
}
if (towupper (L'a') != L'A')
{
printf ("towupper(L'a') failed\n");
result++;
}
if (result == 0)
puts ("All test successful!");
return result != 0;
}
struct CharTrans *BKE_vfont_to_curve(Main *bmain, Scene *scene, Object *ob, int mode)
{
VFont *vfont, *oldvfont;
VFontData *vfd = NULL;
Curve *cu;
CharInfo *info = NULL, *custrinfo;
TextBox *tb;
VChar *che;
struct CharTrans *chartransdata = NULL, *ct;
float *f, xof, yof, xtrax, linedist, *linedata, *linedata2, *linedata3, *linedata4;
float twidth, maxlen = 0;
int i, slen, j;
int curbox;
int selstart, selend;
int utf8len;
short cnr = 0, lnr = 0, wsnr = 0;
wchar_t *mem, *tmp, ascii;
/* remark: do calculations including the trailing '\0' of a string
* because the cursor can be at that location */
if (ob->type != OB_FONT) return NULL;
/* Set font data */
cu = (Curve *) ob->data;
vfont = cu->vfont;
if (cu->str == NULL) return NULL;
if (vfont == NULL) return NULL;
/* Create unicode string */
utf8len = BLI_strlen_utf8(cu->str);
mem = MEM_mallocN(((utf8len + 1) * sizeof(wchar_t)), "convertedmem");
BLI_strncpy_wchar_from_utf8(mem, cu->str, utf8len + 1);
/* Count the wchar_t string length */
slen = wcslen(mem);
if (cu->ulheight == 0.0f)
cu->ulheight = 0.05f;
if (cu->strinfo == NULL) /* old file */
cu->strinfo = MEM_callocN((slen + 4) * sizeof(CharInfo), "strinfo compat");
custrinfo = cu->strinfo;
if (cu->editfont)
custrinfo = cu->editfont->textbufinfo;
if (cu->tb == NULL)
cu->tb = MEM_callocN(MAXTEXTBOX * sizeof(TextBox), "TextBox compat");
vfd = vfont_get_data(bmain, vfont);
/* The VFont Data can not be found */
if (!vfd) {
if (mem)
MEM_freeN(mem);
return NULL;
}
/* calc offset and rotation of each char */
ct = chartransdata =
(struct CharTrans *)MEM_callocN((slen + 1) * sizeof(struct CharTrans), "buildtext");
/* We assume the worst case: 1 character per line (is freed at end anyway) */
linedata = MEM_mallocN(sizeof(float) * (slen * 2 + 1), "buildtext2");
linedata2 = MEM_mallocN(sizeof(float) * (slen * 2 + 1), "buildtext3");
linedata3 = MEM_callocN(sizeof(float) * (slen * 2 + 1), "buildtext4");
linedata4 = MEM_callocN(sizeof(float) * (slen * 2 + 1), "buildtext5");
linedist = cu->linedist;
xof = cu->xof + (cu->tb[0].x / cu->fsize);
yof = cu->yof + (cu->tb[0].y / cu->fsize);
xtrax = 0.5f * cu->spacing - 0.5f;
oldvfont = NULL;
for (i = 0; i < slen; i++) custrinfo[i].flag &= ~(CU_CHINFO_WRAP | CU_CHINFO_SMALLCAPS_CHECK);
if (cu->selboxes) MEM_freeN(cu->selboxes);
cu->selboxes = NULL;
if (BKE_vfont_select_get(ob, &selstart, &selend))
cu->selboxes = MEM_callocN((selend - selstart + 1) * sizeof(SelBox), "font selboxes");
tb = &(cu->tb[0]);
curbox = 0;
for (i = 0; i <= slen; i++) {
makebreak:
/* Characters in the list */
info = &(custrinfo[i]);
ascii = mem[i];
if (info->flag & CU_CHINFO_SMALLCAPS) {
ascii = towupper(ascii);
if (mem[i] != ascii) {
mem[i] = ascii;
info->flag |= CU_CHINFO_SMALLCAPS_CHECK;
}
}
vfont = which_vfont(cu, info);
if (vfont == NULL) break;
che = find_vfont_char(vfd, ascii);
/*
* The character wasn't in the current curve base so load it
* But if the font is built-in then do not try loading since
* whole font is in the memory already
*/
if (che == NULL && BKE_vfont_is_builtin(vfont) == FALSE) {
BLI_vfontchar_from_freetypefont(vfont, ascii);
}
/* Try getting the character again from the list */
che = find_vfont_char(vfd, ascii);
/* No VFont found */
if (vfont == NULL) {
if (mem)
MEM_freeN(mem);
MEM_freeN(chartransdata);
return NULL;
}
if (vfont != oldvfont) {
vfd = vfont_get_data(bmain, vfont);
oldvfont = vfont;
}
/* VFont Data for VFont couldn't be found */
if (!vfd) {
if (mem)
MEM_freeN(mem);
MEM_freeN(chartransdata);
return NULL;
}
twidth = char_width(cu, che, info);
/* Calculate positions */
if ((tb->w != 0.0f) &&
(ct->dobreak == 0) &&
(((xof - (tb->x / cu->fsize) + twidth) * cu->fsize) > tb->w + cu->xof * cu->fsize))
{
// fprintf(stderr, "linewidth exceeded: %c%c%c...\n", mem[i], mem[i+1], mem[i+2]);
for (j = i; j && (mem[j] != '\n') && (mem[j] != '\r') && (chartransdata[j].dobreak == 0); j--) {
if (mem[j] == ' ' || mem[j] == '-') {
ct -= (i - (j - 1));
cnr -= (i - (j - 1));
if (mem[j] == ' ') wsnr--;
if (mem[j] == '-') wsnr++;
i = j - 1;
xof = ct->xof;
ct[1].dobreak = 1;
custrinfo[i + 1].flag |= CU_CHINFO_WRAP;
goto makebreak;
}
if (chartransdata[j].dobreak) {
// fprintf(stderr, "word too long: %c%c%c...\n", mem[j], mem[j+1], mem[j+2]);
ct->dobreak = 1;
custrinfo[i + 1].flag |= CU_CHINFO_WRAP;
ct -= 1;
cnr -= 1;
i--;
xof = ct->xof;
goto makebreak;
}
}
}
if (ascii == '\n' || ascii == '\r' || ascii == 0 || ct->dobreak) {
ct->xof = xof;
ct->yof = yof;
ct->linenr = lnr;
ct->charnr = cnr;
yof -= linedist;
maxlen = max_ff(maxlen, (xof - tb->x / cu->fsize));
linedata[lnr] = xof - tb->x / cu->fsize;
linedata2[lnr] = cnr;
linedata3[lnr] = tb->w / cu->fsize;
linedata4[lnr] = wsnr;
if ((tb->h != 0.0f) &&
((-(yof - (tb->y / cu->fsize))) > ((tb->h / cu->fsize) - (linedist * cu->fsize)) - cu->yof) &&
(cu->totbox > (curbox + 1)) )
{
maxlen = 0;
tb++;
curbox++;
yof = cu->yof + tb->y / cu->fsize;
}
/* XXX, has been unused for years, need to check if this is useful, r4613 r5282 - campbell */
#if 0
if (ascii == '\n' || ascii == '\r')
xof = cu->xof;
else
xof = cu->xof + (tb->x / cu->fsize);
#else
xof = cu->xof + (tb->x / cu->fsize);
#endif
lnr++;
cnr = 0;
wsnr = 0;
}
else if (ascii == 9) { /* TAB */
float tabfac;
ct->xof = xof;
ct->yof = yof;
ct->linenr = lnr;
ct->charnr = cnr++;
tabfac = (xof - cu->xof + 0.01f);
tabfac = 2.0f * ceilf(tabfac / 2.0f);
xof = cu->xof + tabfac;
}
else {
SelBox *sb = NULL;
float wsfac;
ct->xof = xof;
ct->yof = yof;
ct->linenr = lnr;
ct->charnr = cnr++;
if (cu->selboxes && (i >= selstart) && (i <= selend)) {
sb = &(cu->selboxes[i - selstart]);
sb->y = yof * cu->fsize - linedist * cu->fsize * 0.1f;
sb->h = linedist * cu->fsize;
sb->w = xof * cu->fsize;
}
if (ascii == 32) {
wsfac = cu->wordspace;
wsnr++;
}
else {
wsfac = 1.0f;
}
/* Set the width of the character */
twidth = char_width(cu, che, info);
xof += (twidth * wsfac * (1.0f + (info->kern / 40.0f)) ) + xtrax;
if (sb) {
sb->w = (xof * cu->fsize) - sb->w;
}
}
ct++;
}
cu->lines = 1;
ct = chartransdata;
tmp = mem;
for (i = 0; i <= slen; i++, tmp++, ct++) {
ascii = *tmp;
if (ascii == '\n' || ascii == '\r' || ct->dobreak) cu->lines++;
}
/* linedata is now: width of line
* linedata2 is now: number of characters
* linedata3 is now: maxlen of that line
* linedata4 is now: number of whitespaces of line */
if (cu->spacemode != CU_LEFT) {
ct = chartransdata;
if (cu->spacemode == CU_RIGHT) {
for (i = 0; i < lnr; i++) linedata[i] = linedata3[i] - linedata[i];
for (i = 0; i <= slen; i++) {
ct->xof += linedata[ct->linenr];
ct++;
}
}
else if (cu->spacemode == CU_MIDDLE) {
for (i = 0; i < lnr; i++) linedata[i] = (linedata3[i] - linedata[i]) / 2;
for (i = 0; i <= slen; i++) {
ct->xof += linedata[ct->linenr];
ct++;
}
}
else if ((cu->spacemode == CU_FLUSH) && (cu->tb[0].w != 0.0f)) {
for (i = 0; i < lnr; i++)
if (linedata2[i] > 1)
linedata[i] = (linedata3[i] - linedata[i]) / (linedata2[i] - 1);
for (i = 0; i <= slen; i++) {
for (j = i; (!ELEM3(mem[j], '\0', '\n', '\r')) && (chartransdata[j].dobreak == 0) && (j < slen); j++) {
/* do nothing */
}
// if ((mem[j] != '\r') && (mem[j] != '\n') && (mem[j])) {
ct->xof += ct->charnr * linedata[ct->linenr];
// }
ct++;
}
}
else if ((cu->spacemode == CU_JUSTIFY) && (cu->tb[0].w != 0.0f)) {
float curofs = 0.0f;
for (i = 0; i <= slen; i++) {
for (j = i; (mem[j]) && (mem[j] != '\n') &&
(mem[j] != '\r') && (chartransdata[j].dobreak == 0) && (j < slen);
j++)
{
/* pass */
}
if ((mem[j] != '\r') && (mem[j] != '\n') &&
((chartransdata[j].dobreak != 0)))
{
if (mem[i] == ' ') curofs += (linedata3[ct->linenr] - linedata[ct->linenr]) / linedata4[ct->linenr];
ct->xof += curofs;
}
if (mem[i] == '\n' || mem[i] == '\r' || chartransdata[i].dobreak) curofs = 0;
ct++;
}
}
}
/* TEXT ON CURVE */
/* Note: Only OB_CURVE objects could have a path */
if (cu->textoncurve && cu->textoncurve->type == OB_CURVE) {
Curve *cucu = cu->textoncurve->data;
int oldflag = cucu->flag;
cucu->flag |= (CU_PATH + CU_FOLLOW);
if (cu->textoncurve->curve_cache == NULL || cu->textoncurve->curve_cache->path == NULL) {
BKE_displist_make_curveTypes(scene, cu->textoncurve, 0);
}
if (cu->textoncurve->curve_cache->path) {
float distfac, imat[4][4], imat3[3][3], cmat[3][3];
float minx, maxx, miny, maxy;
float timeofs, sizefac;
invert_m4_m4(imat, ob->obmat);
copy_m3_m4(imat3, imat);
copy_m3_m4(cmat, cu->textoncurve->obmat);
mul_m3_m3m3(cmat, cmat, imat3);
sizefac = normalize_v3(cmat[0]) / cu->fsize;
minx = miny = 1.0e20f;
maxx = maxy = -1.0e20f;
ct = chartransdata;
for (i = 0; i <= slen; i++, ct++) {
if (minx > ct->xof) minx = ct->xof;
if (maxx < ct->xof) maxx = ct->xof;
if (miny > ct->yof) miny = ct->yof;
if (maxy < ct->yof) maxy = ct->yof;
}
/* we put the x-coordinaat exact at the curve, the y is rotated */
/* length correction */
distfac = sizefac * cu->textoncurve->curve_cache->path->totdist / (maxx - minx);
timeofs = 0.0f;
if (distfac > 1.0f) {
/* path longer than text: spacemode involves */
distfac = 1.0f / distfac;
if (cu->spacemode == CU_RIGHT) {
timeofs = 1.0f - distfac;
}
else if (cu->spacemode == CU_MIDDLE) {
timeofs = (1.0f - distfac) / 2.0f;
}
else if (cu->spacemode == CU_FLUSH) {
distfac = 1.0f;
}
}
else {
distfac = 1.0;
}
distfac /= (maxx - minx);
timeofs += distfac * cu->xof; /* not cyclic */
ct = chartransdata;
for (i = 0; i <= slen; i++, ct++) {
float ctime, dtime, vec[4], tvec[4], rotvec[3];
float si, co;
/* rotate around center character */
ascii = mem[i];
che = find_vfont_char(vfd, ascii);
twidth = char_width(cu, che, info);
dtime = distfac * 0.5f * twidth;
ctime = timeofs + distfac * (ct->xof - minx);
CLAMP(ctime, 0.0f, 1.0f);
/* calc the right loc AND the right rot separately */
/* vec, tvec need 4 items */
where_on_path(cu->textoncurve, ctime, vec, tvec, NULL, NULL, NULL);
where_on_path(cu->textoncurve, ctime + dtime, tvec, rotvec, NULL, NULL, NULL);
mul_v3_fl(vec, sizefac);
ct->rot = (float)M_PI - atan2f(rotvec[1], rotvec[0]);
si = sinf(ct->rot);
co = cosf(ct->rot);
yof = ct->yof;
ct->xof = vec[0] + si * yof;
ct->yof = vec[1] + co * yof;
}
cucu->flag = oldflag;
}
}
if (cu->selboxes) {
ct = chartransdata;
for (i = 0; i <= selend; i++, ct++) {
if (i >= selstart) {
cu->selboxes[i - selstart].x = ct->xof * cu->fsize;
cu->selboxes[i - selstart].y = ct->yof * cu->fsize;
}
}
}
if (mode == FO_CURSUP || mode == FO_CURSDOWN || mode == FO_PAGEUP || mode == FO_PAGEDOWN) {
/* 2: curs up
* 3: curs down */
ct = chartransdata + cu->pos;
if ((mode == FO_CURSUP || mode == FO_PAGEUP) && ct->linenr == 0) {
/* pass */
}
else if ((mode == FO_CURSDOWN || mode == FO_PAGEDOWN) && ct->linenr == lnr) {
/* pass */
}
else {
switch (mode) {
case FO_CURSUP: lnr = ct->linenr - 1; break;
case FO_CURSDOWN: lnr = ct->linenr + 1; break;
case FO_PAGEUP: lnr = ct->linenr - 10; break;
case FO_PAGEDOWN: lnr = ct->linenr + 10; break;
}
cnr = ct->charnr;
/* seek for char with lnr en cnr */
cu->pos = 0;
ct = chartransdata;
for (i = 0; i < slen; i++) {
if (ct->linenr == lnr) {
if ((ct->charnr == cnr) || ((ct + 1)->charnr == 0)) {
break;
}
}
else if (ct->linenr > lnr) {
break;
}
cu->pos++;
ct++;
}
}
}
/* cursor first */
if (cu->editfont) {
float si, co;
ct = chartransdata + cu->pos;
si = sinf(ct->rot);
co = cosf(ct->rot);
f = cu->editfont->textcurs[0];
f[0] = cu->fsize * (-0.1f * co + ct->xof);
f[1] = cu->fsize * ( 0.1f * si + ct->yof);
f[2] = cu->fsize * ( 0.1f * co + ct->xof);
f[3] = cu->fsize * (-0.1f * si + ct->yof);
f[4] = cu->fsize * ( 0.1f * co + 0.8f * si + ct->xof);
f[5] = cu->fsize * (-0.1f * si + 0.8f * co + ct->yof);
f[6] = cu->fsize * (-0.1f * co + 0.8f * si + ct->xof);
f[7] = cu->fsize * ( 0.1f * si + 0.8f * co + ct->yof);
}
MEM_freeN(linedata);
MEM_freeN(linedata2);
MEM_freeN(linedata3);
MEM_freeN(linedata4);
if (mode == FO_SELCHANGE) {
MEM_freeN(chartransdata);
MEM_freeN(mem);
return NULL;
}
if (mode == FO_EDIT) {
/* make nurbdata */
BKE_nurbList_free(&cu->nurb);
ct = chartransdata;
if (cu->sepchar == 0) {
for (i = 0; i < slen; i++) {
unsigned long cha = (uintptr_t) mem[i];
info = &(custrinfo[i]);
if (info->mat_nr > (ob->totcol)) {
/* printf("Error: Illegal material index (%d) in text object, setting to 0\n", info->mat_nr); */
info->mat_nr = 0;
}
/* We do not want to see any character for \n or \r */
if (cha != '\n' && cha != '\r')
buildchar(bmain, cu, cha, info, ct->xof, ct->yof, ct->rot, i);
if ((info->flag & CU_CHINFO_UNDERLINE) && (cu->textoncurve == NULL) && (cha != '\n') && (cha != '\r')) {
float ulwidth, uloverlap = 0.0f;
if ((i < (slen - 1)) && (mem[i + 1] != '\n') && (mem[i + 1] != '\r') &&
((mem[i + 1] != ' ') || (custrinfo[i + 1].flag & CU_CHINFO_UNDERLINE)) &&
((custrinfo[i + 1].flag & CU_CHINFO_WRAP) == 0))
{
uloverlap = xtrax + 0.1f;
}
/* Find the character, the characters has to be in the memory already
* since character checking has been done earlier already. */
che = find_vfont_char(vfd, cha);
twidth = char_width(cu, che, info);
ulwidth = cu->fsize * ((twidth * (1.0f + (info->kern / 40.0f))) + uloverlap);
build_underline(cu, ct->xof * cu->fsize, ct->yof * cu->fsize + (cu->ulpos - 0.05f) * cu->fsize,
ct->xof * cu->fsize + ulwidth,
ct->yof * cu->fsize + (cu->ulpos - 0.05f) * cu->fsize - cu->ulheight * cu->fsize,
i, info->mat_nr);
}
ct++;
}
}
else {
int outta = 0;
for (i = 0; (i < slen) && (outta == 0); i++) {
ascii = mem[i];
info = &(custrinfo[i]);
if (cu->sepchar == (i + 1)) {
float vecyo[3];
vecyo[0] = ct->xof;
vecyo[1] = ct->yof;
vecyo[2] = 0.0f;
mem[0] = ascii;
mem[1] = 0;
custrinfo[0] = *info;
cu->pos = 1;
cu->len = 1;
mul_v3_m4v3(ob->loc, ob->obmat, vecyo);
outta = 1;
cu->sepchar = 0;
}
ct++;
}
}
}
if (mode == FO_DUPLI) {
MEM_freeN(mem);
return chartransdata;
}
if (mem)
MEM_freeN(mem);
MEM_freeN(chartransdata);
return NULL;
}
juce_wchar CharacterFunctions::toUpperCase (const juce_wchar character) noexcept
{
return (juce_wchar) towupper ((wint_t) character);
}
wint_t towupper_l(wint_t c, locale_t loc) {
return towupper(c);
}
inline Char toUpper(Char c) { return IF_UNICODE( towupper(c) , toupper(c) ); }
///
/// Converts the wide character @p c to uppercase, returning the result
/// @param c the character to convert to uppercase
///
inline wchar wchar_to_upper(wchar c){
return (wchar) towupper(c);
}
int _mutt_enter_string(char *buf, size_t buflen, int y, int x,
int flags, int multiple, char ***files, int *numfiles,
struct enter_state *state)
{
int width = COLS - x - 1;
int redraw;
int pass =(flags & M_PASS);
int first = 1;
int ch, w, r;
size_t i;
wchar_t *tempbuf = 0;
size_t templen = 0;
history_class_t hclass;
wchar_t wc;
mbstate_t mbstate;
int rv = 0;
memset(&mbstate, 0, sizeof(mbstate));
if (state->wbuf)
{
/* Coming back after return 1 */
redraw = M_REDRAW_LINE;
first = 0;
}
else
{
/* Initialise wbuf from buf */
state->wbuflen = 0;
state->lastchar = my_mbstowcs(&state->wbuf, &state->wbuflen, 0, buf);
redraw = M_REDRAW_INIT;
}
if (flags & M_FILE)
hclass = HC_FILE;
else if (flags & M_EFILE)
hclass = HC_MBOX;
else if (flags & M_CMD)
hclass = HC_CMD;
else if (flags & M_ALIAS)
hclass = HC_ALIAS;
else if (flags & M_COMMAND)
hclass = HC_COMMAND;
else if (flags & M_PATTERN)
hclass = HC_PATTERN;
else
hclass = HC_OTHER;
for(;;)
{
if (redraw && !pass)
{
if (redraw == M_REDRAW_INIT)
{
/* Go to end of line */
state->curpos = state->lastchar;
state->begin = width_ceiling(state->wbuf, state->lastchar, my_wcswidth(state->wbuf, state->lastchar) - width + 1);
}
if (state->curpos < state->begin ||
my_wcswidth(state->wbuf + state->begin, state->curpos - state->begin) >= width)
state->begin = width_ceiling(state->wbuf, state->lastchar, my_wcswidth(state->wbuf, state->curpos) - width / 2);
move(y, x);
w = 0;
for(i = state->begin; i < state->lastchar; i++)
{
w += my_wcwidth(state->wbuf[i]);
if (w > width)
break;
my_addwch(state->wbuf[i]);
}
clrtoeol();
move(y, x + my_wcswidth(state->wbuf + state->begin, state->curpos - state->begin));
}
mutt_refresh();
if ((ch = km_dokey(MENU_EDITOR)) == -1)
{
rv = -1;
goto bye;
}
if (ch != OP_NULL)
{
first = 0;
if (ch != OP_EDITOR_COMPLETE && ch != OP_EDITOR_COMPLETE_QUERY)
state->tabs = 0;
redraw = M_REDRAW_LINE;
switch(ch)
{
case OP_EDITOR_HISTORY_UP:
state->curpos = state->lastchar;
if (mutt_history_at_scratch(hclass))
{
my_wcstombs(buf, buflen, state->wbuf, state->curpos);
mutt_history_save_scratch(hclass, buf);
}
replace_part(state, 0, mutt_history_prev(hclass));
redraw = M_REDRAW_INIT;
break;
case OP_EDITOR_HISTORY_DOWN:
state->curpos = state->lastchar;
if (mutt_history_at_scratch(hclass))
{
my_wcstombs(buf, buflen, state->wbuf, state->curpos);
mutt_history_save_scratch(hclass, buf);
}
replace_part(state, 0, mutt_history_next(hclass));
redraw = M_REDRAW_INIT;
break;
case OP_EDITOR_BACKSPACE:
if (state->curpos == 0)
BEEP();
else
{
i = state->curpos;
while(i && COMB_CHAR(state->wbuf[i - 1]))
--i;
if (i)
--i;
memmove(state->wbuf + i, state->wbuf + state->curpos,(state->lastchar - state->curpos) * sizeof(wchar_t));
state->lastchar -= state->curpos - i;
state->curpos = i;
}
break;
case OP_EDITOR_BOL:
state->curpos = 0;
break;
case OP_EDITOR_EOL:
redraw= M_REDRAW_INIT;
break;
case OP_EDITOR_KILL_LINE:
state->curpos = state->lastchar = 0;
break;
case OP_EDITOR_KILL_EOL:
state->lastchar = state->curpos;
break;
case OP_EDITOR_BACKWARD_CHAR:
if (state->curpos == 0)
BEEP();
else
{
while(state->curpos && COMB_CHAR(state->wbuf[state->curpos - 1]))
state->curpos--;
if (state->curpos)
state->curpos--;
}
break;
case OP_EDITOR_FORWARD_CHAR:
if (state->curpos == state->lastchar)
BEEP();
else
{
++state->curpos;
while(state->curpos < state->lastchar && COMB_CHAR(state->wbuf[state->curpos]))
++state->curpos;
}
break;
case OP_EDITOR_BACKWARD_WORD:
if (state->curpos == 0)
BEEP();
else
{
while(state->curpos && iswspace(state->wbuf[state->curpos - 1]))
--state->curpos;
while(state->curpos && !iswspace(state->wbuf[state->curpos - 1]))
--state->curpos;
}
break;
case OP_EDITOR_FORWARD_WORD:
if (state->curpos == state->lastchar)
BEEP();
else
{
while(state->curpos < state->lastchar && iswspace(state->wbuf[state->curpos]))
++state->curpos;
while(state->curpos < state->lastchar && !iswspace(state->wbuf[state->curpos]))
++state->curpos;
}
break;
case OP_EDITOR_CAPITALIZE_WORD:
case OP_EDITOR_UPCASE_WORD:
case OP_EDITOR_DOWNCASE_WORD:
if (state->curpos == state->lastchar)
{
BEEP();
break;
}
while(state->curpos && !iswspace(state->wbuf[state->curpos]))
--state->curpos;
while(state->curpos < state->lastchar && iswspace(state->wbuf[state->curpos]))
++state->curpos;
while(state->curpos < state->lastchar && !iswspace(state->wbuf[state->curpos]))
{
if (ch == OP_EDITOR_DOWNCASE_WORD)
state->wbuf[state->curpos] = towlower(state->wbuf[state->curpos]);
else
{
state->wbuf[state->curpos] = towupper(state->wbuf[state->curpos]);
if (ch == OP_EDITOR_CAPITALIZE_WORD)
ch = OP_EDITOR_DOWNCASE_WORD;
}
state->curpos++;
}
break;
case OP_EDITOR_DELETE_CHAR:
if (state->curpos == state->lastchar)
BEEP();
else
{
i = state->curpos;
while(i < state->lastchar && COMB_CHAR(state->wbuf[i]))
++i;
if (i < state->lastchar)
++i;
while(i < state->lastchar && COMB_CHAR(state->wbuf[i]))
++i;
memmove(state->wbuf + state->curpos, state->wbuf + i,(state->lastchar - i) * sizeof(wchar_t));
state->lastchar -= i - state->curpos;
}
break;
case OP_EDITOR_KILL_WORD:
/* delete to beginning of word */
if (state->curpos != 0)
{
i = state->curpos;
while(i && iswspace(state->wbuf[i - 1]))
--i;
if (i)
{
if (iswalnum(state->wbuf[i - 1]))
{
for(--i; i && iswalnum(state->wbuf[i - 1]); i--)
;
}
else
--i;
}
memmove(state->wbuf + i, state->wbuf + state->curpos,
(state->lastchar - state->curpos) * sizeof(wchar_t));
state->lastchar += i - state->curpos;
state->curpos = i;
}
break;
case OP_EDITOR_KILL_EOW:
/* delete to end of word */
/* first skip over whitespace */
for(i = state->curpos;
i < state->lastchar && iswspace(state->wbuf[i]); i++)
;
/* if there are any characters left.. */
if (i < state->lastchar)
{
/* if the current character is alphanumeric.. */
if (iswalnum(state->wbuf[i]))
{
/* skip over the rest of the word consistent of only alphanumerics */
for(; i < state->lastchar && iswalnum(state->wbuf[i]); i++)
;
}
else
{
/* skip over one non-alphanumeric character */
++i;
}
}
memmove(state->wbuf + state->curpos, state->wbuf + i,
(state->lastchar - i) * sizeof(wchar_t));
state->lastchar += state->curpos - i;
break;
case OP_EDITOR_BUFFY_CYCLE:
if (flags & M_EFILE)
{
first = 1; /* clear input if user types a real key later */
my_wcstombs(buf, buflen, state->wbuf, state->curpos);
mutt_buffy(buf, buflen);
state->curpos = state->lastchar = my_mbstowcs(&state->wbuf, &state->wbuflen, 0, buf);
break;
}
else if (!(flags & M_FILE))
goto self_insert;
/* fall through to completion routine(M_FILE) */
case OP_EDITOR_COMPLETE:
case OP_EDITOR_COMPLETE_QUERY:
state->tabs++;
if (flags & M_CMD)
{
for(i = state->curpos; i && !is_shell_char(state->wbuf[i-1]); i--)
;
my_wcstombs(buf, buflen, state->wbuf + i, state->curpos - i);
if (tempbuf && templen == state->lastchar - i &&
!memcmp(tempbuf, state->wbuf + i,(state->lastchar - i) * sizeof(wchar_t)))
{
mutt_select_file(buf, buflen,(flags & M_EFILE) ? M_SEL_FOLDER : 0);
set_bit(options, OPTNEEDREDRAW);
if (*buf)
replace_part(state, i, buf);
rv = 1;
goto bye;
}
if (!mutt_complete(buf, buflen))
{
templen = state->lastchar - i;
safe_realloc(&tempbuf, templen * sizeof(wchar_t));
}
else
BEEP();
replace_part(state, i, buf);
}
else if (flags & M_ALIAS && ch == OP_EDITOR_COMPLETE)
{
/* invoke the alias-menu to get more addresses */
for(i = state->curpos; i && state->wbuf[i-1] != ',' &&
state->wbuf[i-1] != ':'; i--)
;
for(; i < state->lastchar && state->wbuf[i] == ' '; i++)
;
my_wcstombs(buf, buflen, state->wbuf + i, state->curpos - i);
r = mutt_alias_complete(buf, buflen);
replace_part(state, i, buf);
if (!r)
{
rv = 1;
goto bye;
}
break;
}
else if (flags & M_ALIAS && ch == OP_EDITOR_COMPLETE_QUERY)
{
/* invoke the query-menu to get more addresses */
if ((i = state->curpos))
{
for(; i && state->wbuf[i - 1] != ','; i--)
;
for(; i < state->curpos && state->wbuf[i] == ' '; i++)
;
}
my_wcstombs(buf, buflen, state->wbuf + i, state->curpos - i);
mutt_query_complete(buf, buflen);
replace_part(state, i, buf);
rv = 1;
goto bye;
}
else if (flags & M_COMMAND)
{
my_wcstombs(buf, buflen, state->wbuf, state->curpos);
i = strlen(buf);
if (i && buf[i - 1] == '=' &&
mutt_var_value_complete(buf, buflen, i))
state->tabs = 0;
else if (!mutt_command_complete(buf, buflen, i, state->tabs))
BEEP();
replace_part(state, 0, buf);
}
else if (flags &(M_FILE | M_EFILE))
{
my_wcstombs(buf, buflen, state->wbuf, state->curpos);
/* see if the path has changed from the last time */
if ((!tempbuf && !state->lastchar) ||(tempbuf && templen == state->lastchar &&
!memcmp(tempbuf, state->wbuf, state->lastchar * sizeof(wchar_t))))
{
_mutt_select_file(buf, buflen,
((flags & M_EFILE) ? M_SEL_FOLDER : 0) |(multiple ? M_SEL_MULTI : 0),
files, numfiles);
set_bit(options, OPTNEEDREDRAW);
if (*buf)
{
mutt_pretty_mailbox(buf, buflen);
if (!pass)
mutt_history_add(hclass, buf, 1);
rv = 0;
goto bye;
}
/* file selection cancelled */
rv = 1;
goto bye;
}
if (!mutt_complete(buf, buflen))
{
templen = state->lastchar;
safe_realloc(&tempbuf, templen * sizeof(wchar_t));
memcpy(tempbuf, state->wbuf, templen * sizeof(wchar_t));
}
else
BEEP(); /* let the user know that nothing matched */
replace_part(state, 0, buf);
}
else
goto self_insert;
break;
case OP_EDITOR_QUOTE_CHAR:
{
struct event event;
/*ADDCH(LastKey);*/
event = mutt_getch();
if (event.ch >= 0)
{
LastKey = event.ch;
goto self_insert;
}
}
case OP_EDITOR_TRANSPOSE_CHARS:
if (state->lastchar < 2)
BEEP();
else
{
wchar_t t;
if (state->curpos == 0)
state->curpos = 2;
else if (state->curpos < state->lastchar)
++state->curpos;
t = state->wbuf[state->curpos - 2];
state->wbuf[state->curpos - 2] = state->wbuf[state->curpos - 1];
state->wbuf[state->curpos - 1] = t;
}
break;
default:
BEEP();
}
}
else
{
self_insert:
state->tabs = 0;
/* use the raw keypress */
ch = LastKey;
#if KEY_ENTER
/* treat ENTER the same as RETURN */
if (ch == KEY_ENTER)
ch = '\r';
#endif
/* quietly ignore all other function keys */
if (ch & ~0xff)
continue;
/* gather the octets into a wide character */
{
char c;
size_t k;
c = ch;
k = mbrtowc(&wc, &c, 1, &mbstate);
if (k ==(size_t)(-2))
continue;
else if (k && k != 1)
{
memset(&mbstate, 0, sizeof(mbstate));
continue;
}
}
if (first &&(flags & M_CLEAR))
{
first = 0;
if (IsWPrint(wc)) /* why? */
state->curpos = state->lastchar = 0;
}
if (wc == '\r' || wc == '\n')
{
/* Convert from wide characters */
my_wcstombs(buf, buflen, state->wbuf, state->lastchar);
if (!pass)
mutt_history_add(hclass, buf, 1);
if (multiple)
{
char **tfiles;
*numfiles = 1;
tfiles = safe_calloc(*numfiles, sizeof(char *));
mutt_expand_path(buf, buflen);
tfiles[0] = safe_strdup(buf);
*files = tfiles;
}
rv = 0;
goto bye;
}
else if (wc &&(wc < ' ' || IsWPrint(wc))) /* why? */
{
if (state->lastchar >= state->wbuflen)
{
state->wbuflen = state->lastchar + 20;
safe_realloc(&state->wbuf, state->wbuflen * sizeof(wchar_t));
}
memmove(state->wbuf + state->curpos + 1, state->wbuf + state->curpos,(state->lastchar - state->curpos) * sizeof(wchar_t));
state->wbuf[state->curpos++] = wc;
state->lastchar++;
}
else
{
mutt_flushinp();
BEEP();
}
}
}
bye:
mutt_reset_history_state(hclass);
safe_free(&tempbuf);
return rv;
}
VALUE
rb_file_expand_path_internal(VALUE fname, VALUE dname, int abs_mode, int long_name, VALUE result)
{
size_t size = 0, whome_len = 0;
size_t buffer_len = 0;
long wpath_len = 0, wdir_len = 0;
char *fullpath = NULL;
wchar_t *wfullpath = NULL, *wpath = NULL, *wpath_pos = NULL;
wchar_t *wdir = NULL, *wdir_pos = NULL;
wchar_t *whome = NULL, *buffer = NULL, *buffer_pos = NULL;
UINT path_cp, cp;
VALUE path = fname, dir = dname;
wchar_t wfullpath_buffer[PATH_BUFFER_SIZE];
wchar_t path_drive = L'\0', dir_drive = L'\0';
int ignore_dir = 0;
rb_encoding *path_encoding;
int tainted = 0;
/* tainted if path is tainted */
tainted = OBJ_TAINTED(path);
/* get path encoding */
if (NIL_P(dir)) {
path_encoding = rb_enc_get(path);
}
else {
path_encoding = rb_enc_check(path, dir);
}
cp = path_cp = code_page(path_encoding);
/* workaround invalid codepage */
if (path_cp == INVALID_CODE_PAGE) {
cp = CP_UTF8;
if (!NIL_P(path)) {
path = fix_string_encoding(path, path_encoding);
}
}
/* convert char * to wchar_t */
if (!NIL_P(path)) {
wpath = mbstr_to_wstr(cp, RSTRING_PTR(path), (int)RSTRING_LEN(path), &wpath_len);
wpath_pos = wpath;
}
/* determine if we need the user's home directory */
/* expand '~' only if NOT rb_file_absolute_path() where `abs_mode` is 1 */
if (abs_mode == 0 && wpath_len > 0 && wpath_pos[0] == L'~' &&
(wpath_len == 1 || IS_DIR_SEPARATOR_P(wpath_pos[1]))) {
/* tainted if expanding '~' */
tainted = 1;
whome = home_dir();
if (whome == NULL) {
xfree(wpath);
rb_raise(rb_eArgError, "couldn't find HOME environment -- expanding `~'");
}
whome_len = wcslen(whome);
if (PathIsRelativeW(whome) && !(whome_len >= 2 && IS_DIR_UNC_P(whome))) {
xfree(wpath);
xfree(whome);
rb_raise(rb_eArgError, "non-absolute home");
}
if (path_cp == INVALID_CODE_PAGE || rb_enc_str_asciionly_p(path)) {
/* use filesystem encoding if expanding home dir */
path_encoding = rb_filesystem_encoding();
cp = path_cp = system_code_page();
}
/* ignores dir since we are expanding home */
ignore_dir = 1;
/* exclude ~ from the result */
wpath_pos++;
wpath_len--;
/* exclude separator if present */
if (wpath_len && IS_DIR_SEPARATOR_P(wpath_pos[0])) {
wpath_pos++;
wpath_len--;
}
}
else if (wpath_len >= 2 && wpath_pos[1] == L':') {
if (wpath_len >= 3 && IS_DIR_SEPARATOR_P(wpath_pos[2])) {
/* ignore dir since path contains a drive letter and a root slash */
ignore_dir = 1;
}
else {
/* determine if we ignore dir or not later */
path_drive = wpath_pos[0];
}
}
else if (abs_mode == 0 && wpath_len >= 2 && wpath_pos[0] == L'~') {
result = rb_str_new_cstr("can't find user ");
result = append_wstr(result, wpath_pos + 1, user_length_in_path(wpath_pos + 1, wpath_len - 1),
cp, path_cp, path_encoding);
if (wpath)
xfree(wpath);
rb_exc_raise(rb_exc_new_str(rb_eArgError, result));
}
/* convert dir */
if (!ignore_dir && !NIL_P(dir)) {
/* fix string encoding */
if (path_cp == INVALID_CODE_PAGE) {
dir = fix_string_encoding(dir, path_encoding);
}
/* convert char * to wchar_t */
if (!NIL_P(dir)) {
wdir = mbstr_to_wstr(cp, RSTRING_PTR(dir), (int)RSTRING_LEN(dir), &wdir_len);
wdir_pos = wdir;
}
if (abs_mode == 0 && wdir_len > 0 && wdir_pos[0] == L'~' &&
(wdir_len == 1 || IS_DIR_SEPARATOR_P(wdir_pos[1]))) {
/* tainted if expanding '~' */
tainted = 1;
whome = home_dir();
if (whome == NULL) {
free(wpath);
free(wdir);
rb_raise(rb_eArgError, "couldn't find HOME environment -- expanding `~'");
}
whome_len = wcslen(whome);
if (PathIsRelativeW(whome) && !(whome_len >= 2 && IS_DIR_UNC_P(whome))) {
free(wpath);
free(wdir);
xfree(whome);
rb_raise(rb_eArgError, "non-absolute home");
}
/* exclude ~ from the result */
wdir_pos++;
wdir_len--;
/* exclude separator if present */
if (wdir_len && IS_DIR_SEPARATOR_P(wdir_pos[0])) {
wdir_pos++;
wdir_len--;
}
}
else if (wdir_len >= 2 && wdir[1] == L':') {
dir_drive = wdir[0];
if (wpath_len && IS_DIR_SEPARATOR_P(wpath_pos[0])) {
wdir_len = 2;
}
}
else if (wdir_len >= 2 && IS_DIR_UNC_P(wdir)) {
/* UNC path */
if (wpath_len && IS_DIR_SEPARATOR_P(wpath_pos[0])) {
/* cut the UNC path tail to '//host/share' */
long separators = 0;
long pos = 2;
while (pos < wdir_len && separators < 2) {
if (IS_DIR_SEPARATOR_P(wdir[pos])) {
separators++;
}
pos++;
}
if (separators == 2)
wdir_len = pos - 1;
}
}
else if (abs_mode == 0 && wdir_len >= 2 && wdir_pos[0] == L'~') {
result = rb_str_new_cstr("can't find user ");
result = append_wstr(result, wdir_pos + 1, user_length_in_path(wdir_pos + 1, wdir_len - 1),
cp, path_cp, path_encoding);
if (wpath)
free(wpath);
if (wdir)
free(wdir);
rb_exc_raise(rb_exc_new_str(rb_eArgError, result));
}
}
/* determine if we ignore dir or not */
if (!ignore_dir && path_drive && dir_drive) {
if (towupper(path_drive) == towupper(dir_drive)) {
/* exclude path drive letter to use dir */
wpath_pos += 2;
wpath_len -= 2;
}
else {
/* ignore dir since path drive is different from dir drive */
ignore_dir = 1;
wdir_len = 0;
}
}
if (!ignore_dir && wpath_len >= 2 && IS_DIR_UNC_P(wpath)) {
/* ignore dir since path has UNC root */
ignore_dir = 1;
wdir_len = 0;
}
else if (!ignore_dir && wpath_len >= 1 && IS_DIR_SEPARATOR_P(wpath[0]) &&
!dir_drive && !(wdir_len >= 2 && IS_DIR_UNC_P(wdir))) {
/* ignore dir since path has root slash and dir doesn't have drive or UNC root */
ignore_dir = 1;
wdir_len = 0;
}
buffer_len = wpath_len + 1 + wdir_len + 1 + whome_len + 1;
buffer = buffer_pos = (wchar_t *)xmalloc((buffer_len + 1) * sizeof(wchar_t));
/* add home */
if (whome_len) {
wcsncpy(buffer_pos, whome, whome_len);
buffer_pos += whome_len;
}
/* Add separator if required */
if (whome_len && wcsrchr(L"\\/:", buffer_pos[-1]) == NULL) {
buffer_pos[0] = L'\\';
buffer_pos++;
}
if (wdir_len) {
/* tainted if dir is used and dir is tainted */
if (!tainted && OBJ_TAINTED(dir))
tainted = 1;
wcsncpy(buffer_pos, wdir_pos, wdir_len);
buffer_pos += wdir_len;
}
/* add separator if required */
if (wdir_len && wcsrchr(L"\\/:", buffer_pos[-1]) == NULL) {
buffer_pos[0] = L'\\';
buffer_pos++;
}
/* now deal with path */
if (wpath_len) {
wcsncpy(buffer_pos, wpath_pos, wpath_len);
buffer_pos += wpath_len;
}
/* GetFullPathNameW requires at least "." to determine current directory */
if (wpath_len == 0) {
buffer_pos[0] = L'.';
buffer_pos++;
}
/* Ensure buffer is NULL terminated */
buffer_pos[0] = L'\0';
/* tainted if path is relative */
if (!tainted && PathIsRelativeW(buffer) && !(buffer_len >= 2 && IS_DIR_UNC_P(buffer)))
tainted = 1;
/* FIXME: Make this more robust */
/* Determine require buffer size */
size = GetFullPathNameW(buffer, PATH_BUFFER_SIZE, wfullpath_buffer, NULL);
if (size > PATH_BUFFER_SIZE) {
/* allocate more memory than alloted originally by PATH_BUFFER_SIZE */
wfullpath = (wchar_t *)xmalloc(size * sizeof(wchar_t));
size = GetFullPathNameW(buffer, size, wfullpath, NULL);
}
else {
wfullpath = wfullpath_buffer;
}
/* Remove any trailing slashes */
if (IS_DIR_SEPARATOR_P(wfullpath[size - 1]) &&
wfullpath[size - 2] != L':' &&
!(size == 2 && IS_DIR_UNC_P(wfullpath))) {
size -= 1;
wfullpath[size] = L'\0';
}
/* Remove any trailing dot */
if (wfullpath[size - 1] == L'.') {
size -= 1;
wfullpath[size] = L'\0';
}
/* removes trailing invalid ':$DATA' */
size = remove_invalid_alternative_data(wfullpath, size);
/* Replace the trailing path to long name */
if (long_name)
size = replace_to_long_name(&wfullpath, size, (wfullpath != wfullpath_buffer));
/* sanitize backslashes with forwardslashes */
replace_wchar(wfullpath, L'\\', L'/');
/* convert to VALUE and set the path encoding */
rb_str_set_len(result, 0);
result = append_wstr(result, wfullpath, size, cp, path_cp, path_encoding);
/* makes the result object tainted if expanding tainted strings or returning modified path */
if (tainted)
OBJ_TAINT(result);
/* TODO: better cleanup */
if (buffer)
xfree(buffer);
if (wpath)
free(wpath);
if (wdir)
free(wdir);
if (whome)
xfree(whome);
if (wfullpath && wfullpath != wfullpath_buffer)
xfree(wfullpath);
if (fullpath)
xfree(fullpath);
rb_enc_associate(result, path_encoding);
return result;
}
void CACEdit::ReadDirectory(CString m_Dir)
{
CFileFind FoundFiles;
TCHAR ch;
CWaitCursor hg;
// Wenn mittem im Pfad,
// vorheriges Verzeichnis einlesen.
if (m_Dir.Right(1) != _T('\\'))
{
_tsplitpath_s(m_Dir, m_szDrive, m_szDir, m_szFname, m_szExt);
m_Dir.Format(_T("%s%s"),m_szDrive, m_szDir);
}
//ist hübscher
ch = (TCHAR)towupper(m_Dir.GetAt(0));
m_Dir.SetAt(0,ch);
CString m_Name,m_File,m_Dir1 = m_Dir;
if (m_Dir.Right(1) != _T('\\'))
m_Dir += _T("\\");
if(m_LastDirectory.CompareNoCase(m_Dir) == 0 && m_Liste.m_SearchList.GetSize())
return;
m_LastDirectory = m_Dir;
m_Dir += _T("*.*");
BOOL bContinue = FoundFiles.FindFile(m_Dir);
if(bContinue)
RemoveSearchAll();
while (bContinue == TRUE)
{
bContinue = FoundFiles.FindNextFile();
m_File = FoundFiles.GetFileName();
if(FoundFiles.IsHidden() || FoundFiles.IsSystem())
continue;
if(FoundFiles.IsDirectory())
{
if(m_iMode & _MODE_ONLY_FILES)
continue;
if(FoundFiles.IsDots())
continue;
if (m_File.Right(1) != _T('\\'))
m_File += _T("\\");
}
if(!FoundFiles.IsDirectory())
if(m_iMode & _MODE_ONLY_DIRS)
continue;
if(m_iMode & _MODE_FS_START_DIR_)
{
m_Name = m_File;
}
else
{
m_Name = m_Dir1;
if (m_Name.Right(1) != _T('\\'))
m_Name += _T("\\");
m_Name += m_File;
}
AddSearchString(m_Name);
}
FoundFiles.Close();
return;
}
// start event dispatching
NTSTATUS
DokanEventStart(__in PDEVICE_OBJECT DeviceObject, __in PIRP Irp) {
ULONG outBufferLen;
ULONG inBufferLen;
PIO_STACK_LOCATION irpSp;
EVENT_START eventStart;
PEVENT_DRIVER_INFO driverInfo;
PDOKAN_GLOBAL dokanGlobal;
PDokanDCB dcb;
NTSTATUS status;
DEVICE_TYPE deviceType;
ULONG deviceCharacteristics = 0;
WCHAR baseGuidString[64];
GUID baseGuid = DOKAN_BASE_GUID;
UNICODE_STRING unicodeGuid;
ULONG deviceNamePos;
BOOLEAN useMountManager = FALSE;
BOOLEAN mountGlobally = TRUE;
BOOLEAN fileLockUserMode = FALSE;
DDbgPrint("==> DokanEventStart\n");
dokanGlobal = DeviceObject->DeviceExtension;
if (GetIdentifierType(dokanGlobal) != DGL) {
return STATUS_INVALID_PARAMETER;
}
irpSp = IoGetCurrentIrpStackLocation(Irp);
outBufferLen = irpSp->Parameters.DeviceIoControl.OutputBufferLength;
inBufferLen = irpSp->Parameters.DeviceIoControl.InputBufferLength;
if (outBufferLen != sizeof(EVENT_DRIVER_INFO) ||
inBufferLen != sizeof(EVENT_START)) {
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlCopyMemory(&eventStart, Irp->AssociatedIrp.SystemBuffer,
sizeof(EVENT_START));
driverInfo = Irp->AssociatedIrp.SystemBuffer;
if (eventStart.UserVersion != DOKAN_DRIVER_VERSION) {
driverInfo->DriverVersion = DOKAN_DRIVER_VERSION;
driverInfo->Status = DOKAN_START_FAILED;
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = sizeof(EVENT_DRIVER_INFO);
return STATUS_SUCCESS;
}
switch (eventStart.DeviceType) {
case DOKAN_DISK_FILE_SYSTEM:
deviceType = FILE_DEVICE_DISK_FILE_SYSTEM;
break;
case DOKAN_NETWORK_FILE_SYSTEM:
deviceType = FILE_DEVICE_NETWORK_FILE_SYSTEM;
deviceCharacteristics |= FILE_REMOTE_DEVICE;
break;
default:
DDbgPrint(" Unknown device type: %d\n", eventStart.DeviceType);
deviceType = FILE_DEVICE_DISK_FILE_SYSTEM;
}
if (eventStart.Flags & DOKAN_EVENT_REMOVABLE) {
DDbgPrint(" DeviceCharacteristics |= FILE_REMOVABLE_MEDIA\n");
deviceCharacteristics |= FILE_REMOVABLE_MEDIA;
}
if (eventStart.Flags & DOKAN_EVENT_WRITE_PROTECT) {
DDbgPrint(" DeviceCharacteristics |= FILE_READ_ONLY_DEVICE\n");
deviceCharacteristics |= FILE_READ_ONLY_DEVICE;
}
if (eventStart.Flags & DOKAN_EVENT_MOUNT_MANAGER) {
DDbgPrint(" Using Mount Manager\n");
useMountManager = TRUE;
}
if (eventStart.Flags & DOKAN_EVENT_CURRENT_SESSION) {
DDbgPrint(" Mounting on current session only\n");
mountGlobally = FALSE;
}
if (eventStart.Flags & DOKAN_EVENT_FILELOCK_USER_MODE) {
DDbgPrint(" FileLock in User Mode\n");
fileLockUserMode = TRUE;
}
KeEnterCriticalRegion();
ExAcquireResourceExclusiveLite(&dokanGlobal->Resource, TRUE);
DOKAN_CONTROL dokanControl;
RtlZeroMemory(&dokanControl, sizeof(dokanControl));
RtlStringCchCopyW(dokanControl.MountPoint, MAXIMUM_FILENAME_LENGTH,
L"\\DosDevices\\");
if (wcslen(eventStart.MountPoint) == 1) {
dokanControl.MountPoint[12] = towupper(eventStart.MountPoint[0]);
dokanControl.MountPoint[13] = L':';
dokanControl.MountPoint[14] = L'\0';
} else {
RtlStringCchCatW(dokanControl.MountPoint, MAXIMUM_FILENAME_LENGTH,
eventStart.MountPoint);
}
DDbgPrint(" Checking for MountPoint %ls \n", dokanControl.MountPoint);
PMOUNT_ENTRY foundEntry = FindMountEntry(dokanGlobal, &dokanControl, FALSE);
if (foundEntry != NULL) {
DDbgPrint(" MountPoint exists already %ls \n", dokanControl.MountPoint);
driverInfo->DriverVersion = DOKAN_DRIVER_VERSION;
driverInfo->Status = DOKAN_START_FAILED;
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = sizeof(EVENT_DRIVER_INFO);
ExReleaseResourceLite(&dokanGlobal->Resource);
KeLeaveCriticalRegion();
return STATUS_SUCCESS;
}
baseGuid.Data2 = (USHORT)(dokanGlobal->MountId & 0xFFFF) ^ baseGuid.Data2;
baseGuid.Data3 = (USHORT)(dokanGlobal->MountId >> 16) ^ baseGuid.Data3;
status = RtlStringFromGUID(&baseGuid, &unicodeGuid);
if (!NT_SUCCESS(status)) {
ExReleaseResourceLite(&dokanGlobal->Resource);
KeLeaveCriticalRegion();
return status;
}
RtlZeroMemory(baseGuidString, sizeof(baseGuidString));
RtlStringCchCopyW(baseGuidString, sizeof(baseGuidString) / sizeof(WCHAR),
unicodeGuid.Buffer);
RtlFreeUnicodeString(&unicodeGuid);
InterlockedIncrement((LONG *)&dokanGlobal->MountId);
status = DokanCreateDiskDevice(
DeviceObject->DriverObject, dokanGlobal->MountId, eventStart.MountPoint,
eventStart.UNCName, baseGuidString, dokanGlobal, deviceType,
deviceCharacteristics, mountGlobally, useMountManager, &dcb);
if (!NT_SUCCESS(status)) {
ExReleaseResourceLite(&dokanGlobal->Resource);
KeLeaveCriticalRegion();
return status;
}
dcb->FileLockInUserMode = fileLockUserMode;
DDbgPrint(" MountId:%d\n", dcb->MountId);
driverInfo->DeviceNumber = dokanGlobal->MountId;
driverInfo->MountId = dokanGlobal->MountId;
driverInfo->Status = DOKAN_MOUNTED;
driverInfo->DriverVersion = DOKAN_DRIVER_VERSION;
// SymbolicName is
// \\DosDevices\\Global\\Volume{D6CC17C5-1734-4085-BCE7-964F1E9F5DE9}
// Finds the last '\' and copy into DeviceName.
// DeviceName is \Volume{D6CC17C5-1734-4085-BCE7-964F1E9F5DE9}
deviceNamePos = dcb->SymbolicLinkName->Length / sizeof(WCHAR) - 1;
for (; dcb->SymbolicLinkName->Buffer[deviceNamePos] != L'\\'; --deviceNamePos)
;
RtlStringCchCopyW(driverInfo->DeviceName,
sizeof(driverInfo->DeviceName) / sizeof(WCHAR),
&(dcb->SymbolicLinkName->Buffer[deviceNamePos]));
// Set the irp timeout in milliseconds
// If the IrpTimeout is 0, we assume that the value was not changed
dcb->IrpTimeout = DOKAN_IRP_PENDING_TIMEOUT;
if (eventStart.IrpTimeout > 0) {
if (eventStart.IrpTimeout > DOKAN_IRP_PENDING_TIMEOUT_RESET_MAX) {
eventStart.IrpTimeout = DOKAN_IRP_PENDING_TIMEOUT_RESET_MAX;
}
if (eventStart.IrpTimeout < DOKAN_IRP_PENDING_TIMEOUT) {
eventStart.IrpTimeout = DOKAN_IRP_PENDING_TIMEOUT;
}
dcb->IrpTimeout = eventStart.IrpTimeout;
}
DDbgPrint(" DeviceName:%ws\n", driverInfo->DeviceName);
dcb->UseAltStream = 0;
if (eventStart.Flags & DOKAN_EVENT_ALTERNATIVE_STREAM_ON) {
DDbgPrint(" ALT_STREAM_ON\n");
dcb->UseAltStream = 1;
}
DokanStartEventNotificationThread(dcb);
ExReleaseResourceLite(&dokanGlobal->Resource);
KeLeaveCriticalRegion();
IoVerifyVolume(dcb->DeviceObject, FALSE);
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = sizeof(EVENT_DRIVER_INFO);
DDbgPrint("<== DokanEventStart\n");
return Irp->IoStatus.Status;
}
static
void
InitializeGeneralDriveDialog(HWND hwndDlg, WCHAR * szDrive)
{
WCHAR szVolumeName[MAX_PATH+1] = {0};
DWORD MaxComponentLength = 0;
DWORD FileSystemFlags = 0;
WCHAR FileSystemName[MAX_PATH+1] = {0};
WCHAR szFormat[50];
WCHAR szBuffer[128];
BOOL ret;
UINT DriveType;
ULARGE_INTEGER FreeBytesAvailable;
LARGE_INTEGER TotalNumberOfFreeBytes;
LARGE_INTEGER TotalNumberOfBytes;
ret = GetVolumeInformationW(szDrive, szVolumeName, MAX_PATH+1, NULL, &MaxComponentLength, &FileSystemFlags, FileSystemName, MAX_PATH+1);
if (ret)
{
/* set volume label */
SendDlgItemMessageW(hwndDlg, 14000, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szVolumeName);
/* set filesystem type */
SendDlgItemMessageW(hwndDlg, 14002, WM_SETTEXT, (WPARAM)NULL, (LPARAM)FileSystemName);
}
DriveType = GetDriveTypeW(szDrive);
if (DriveType == DRIVE_FIXED || DriveType == DRIVE_CDROM)
{
if(GetDiskFreeSpaceExW(szDrive, &FreeBytesAvailable, (PULARGE_INTEGER)&TotalNumberOfBytes, (PULARGE_INTEGER)&TotalNumberOfFreeBytes))
{
WCHAR szResult[128];
LONGLONG Result;
HANDLE hVolume;
DWORD BytesReturned = 0;
swprintf(szResult, L"\\\\.\\%c:", towupper(szDrive[0]));
hVolume = CreateFileW(szResult, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
if (hVolume != INVALID_HANDLE_VALUE)
{
ret = DeviceIoControl(hVolume, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, (LPVOID)&TotalNumberOfBytes, sizeof(ULARGE_INTEGER), &BytesReturned, NULL);
if (ret && StrFormatByteSizeW(TotalNumberOfBytes.QuadPart, szResult, sizeof(szResult) / sizeof(WCHAR)))
SendDlgItemMessageW(hwndDlg, 14007, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szResult);
CloseHandle(hVolume);
}
TRACE("szResult %s hVOlume %p ret %d LengthInformation %ul Bytesreturned %d\n", debugstr_w(szResult), hVolume, ret, TotalNumberOfBytes.QuadPart, BytesReturned);
if (StrFormatByteSizeW(TotalNumberOfBytes.QuadPart - FreeBytesAvailable.QuadPart, szResult, sizeof(szResult) / sizeof(WCHAR)))
SendDlgItemMessageW(hwndDlg, 14003, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szResult);
if (StrFormatByteSizeW(FreeBytesAvailable.QuadPart, szResult, sizeof(szResult) / sizeof(WCHAR)))
SendDlgItemMessageW(hwndDlg, 14005, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szResult);
Result = GetFreeBytesShare(TotalNumberOfFreeBytes.QuadPart, TotalNumberOfBytes.QuadPart);
/* set free bytes percentage */
swprintf(szResult, L"%02d%%", Result);
SendDlgItemMessageW(hwndDlg, 14006, WM_SETTEXT, (WPARAM)0, (LPARAM)szResult);
/* store used share amount */
Result = 100 - Result;
swprintf(szResult, L"%02d%%", Result);
SendDlgItemMessageW(hwndDlg, 14004, WM_SETTEXT, (WPARAM)0, (LPARAM)szResult);
if (DriveType == DRIVE_FIXED)
{
if (LoadStringW(shell32_hInstance, IDS_DRIVE_FIXED, szBuffer, sizeof(szBuffer) / sizeof(WCHAR)))
SendDlgItemMessageW(hwndDlg, 14001, WM_SETTEXT, (WPARAM)0, (LPARAM)szBuffer);
}
else /* DriveType == DRIVE_CDROM) */
{
if (LoadStringW(shell32_hInstance, IDS_DRIVE_CDROM, szBuffer, sizeof(szBuffer) / sizeof(WCHAR)))
SendDlgItemMessageW(hwndDlg, 14001, WM_SETTEXT, (WPARAM)0, (LPARAM)szBuffer);
}
}
}
/* set drive description */
SendDlgItemMessageW(hwndDlg, 14009, WM_GETTEXT, (WPARAM)50, (LPARAM)szFormat);
swprintf(szBuffer, szFormat, szDrive);
SendDlgItemMessageW(hwndDlg, 14009, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szBuffer);
}
/**
\note This implementation cannot be used because the extension is omitted
when the exploer hides the extension of registered file types.
\todo Support the case where the exploer hides the extension of registered file types.
*/
std::string toActualPathName(const std::string& path)
{
int codepage = _getmbcp();
size_t length = ::MultiByteToWideChar(codepage, 0, path.c_str(), path.size(), NULL, 0);
if(length >= 0){
wchar_t wpath[MAX_PATH];
::MultiByteToWideChar(codepage, 0, path.c_str(), path.size(), wpath, MAX_PATH);
// The following code was based on the code posted at
// http://stackoverflow.com/questions/74451/getting-actual-file-name-with-proper-casing-on-windowsis
// Thank you.
const wchar_t kSeparator = L'\\';
size_t i = 0;
std::wstring result;
// for network paths (\\server\share\RestOfPath), getting the display
// name mangles it into unusable form (e.g. "\\server\share" turns
// into "share on server (server)"). So detect this case and just skip
// up to two path components
if( length >= 2 && wpath[0] == kSeparator && wpath[1] == kSeparator ) {
int skippedCount = 0;
i = 2; // start after '\\'
while( i < length && skippedCount < 2 ) {
if( wpath[i] == kSeparator ){
++skippedCount;
}
++i;
}
result.append( wpath, i );
}
// for drive names, just add it uppercased
else if( length >= 2 && wpath[1] == L':' ) {
result += towupper(wpath[0]);
result += L':';
if( length >= 3 && wpath[2] == kSeparator ){
result += kSeparator;
i = 3; // start after drive, colon and separator
} else {
i = 2; // start after drive and colon
}
}
size_t lastComponentStart = i;
bool addSeparator = false;
while( i < length ) {
// skip until path separator
while( i < length && wpath[i] != kSeparator ) {
++i;
}
if( addSeparator ) {
result += kSeparator;
}
// if we found path separator, get real filename of this
// last path name component
bool foundSeparator = (i < length);
wpath[i] = 0;
SHFILEINFOW info;
// nuke the path separator so that we get real name of current path component
info.szDisplayName[0] = 0;
if( SHGetFileInfoW( wpath, 0, &info, sizeof(info), SHGFI_DISPLAYNAME ) ) {
result += info.szDisplayName;
} else {
// most likely file does not exist.
// So just append original path name component.
result.append( wpath + lastComponentStart, i - lastComponentStart );
}
// restore path separator that we might have nuked before
if( foundSeparator ){
wpath[i] = kSeparator;
}
++i;
lastComponentStart = i;
addSeparator = true;
}
length = ::WideCharToMultiByte(codepage, 0, &result[0], result.size(), NULL, 0, NULL, NULL);
if(length >= 0){
std::vector<char> converted(length + 1);
::WideCharToMultiByte(codepage, 0, &result[0], result.size(), &converted[0], length + 1, NULL, NULL);
return std::string(&converted[0], length);
}
}
return path; // failed
}
