VOID
WriteDebugLog(LPSTR lpFile, UINT iLine, LPSTR lpFunc, LPWSTR lpMsg, ...)
{
LARGE_INTEGER FileSize, MoveTo, NewPos;
WCHAR szMsg[MAX_STR_LEN * 3];
WCHAR szText[MAX_STR_LEN * 4], szTime[MAX_STR_LEN];
DWORD dwBytesWritten;
va_list args;
if (!hDebugLog || hDebugLog == INVALID_HANDLE_VALUE)
return;
MoveTo.QuadPart = 0;
if (!SetFilePointerEx(hDebugLog, MoveTo, &NewPos, FILE_END))
return;
if (!GetFileSizeEx(hDebugLog, &FileSize))
return;
LockFile(hDebugLog, (DWORD_PTR)NewPos.QuadPart, 0, (DWORD_PTR)FileSize.QuadPart, 0);
GetTimeFormat(LOCALE_USER_DEFAULT,
0, NULL, NULL, szTime,
MAX_STR_LEN);
va_start(args, lpMsg);
StringCbVPrintf(szMsg, sizeof(szMsg), lpMsg, args);
va_end(args);
StringCbPrintf(szText, sizeof(szText),
L"[%s] %S:%ld %S(): \"%s\"\r\n",
szTime, lpFile, iLine, lpFunc, szMsg);
WriteFile(hDebugLog, szText,
wcslen(szText) * sizeof(WCHAR),
&dwBytesWritten, NULL);
UnlockFile(hDebugLog, (DWORD_PTR)NewPos.QuadPart, 0, (DWORD_PTR)FileSize.QuadPart, 0);
}
void Add2LogWithTime(TCHAR *txt)
{
BOOL bLogTime = TRUE;
TCHAR str[512];
TCHAR lpTimeStr[128];
TCHAR lpDateStr[128];
LONG res;
wsprintf(str,L"");
//Read the system time
res = GetTimeFormat(LOCALE_SYSTEM_DEFAULT,
TIME_FORCE24HOURFORMAT,
NULL,
L"hh:mm:ss",
lpTimeStr,
sizeof (lpTimeStr ) * sizeof(TCHAR));
if (res == 0)
{
wcscpy(lpTimeStr, L"err");
}
//Read the system date
res = GetDateFormat( LOCALE_SYSTEM_DEFAULT,
NULL,
NULL,
L"dd.MM.yyyy",
lpDateStr,
sizeof (lpDateStr) * sizeof(TCHAR));
if (res == 0)
{
wcscpy(lpDateStr, L"err");
}
if (bLogTime == TRUE)
wsprintf(str, L"%s %s\t%s", lpDateStr, lpTimeStr , txt);
else
wsprintf(str, L"%s", txt);
writefile(str);
}
void DateTime::toString(StringStorage *target) const
{
SYSTEMTIME systemTime;
toLocalSystemTime(&systemTime);
const size_t dateStringMaxLength = 255;
TCHAR dateString[dateStringMaxLength + 1];
if (GetDateFormat(LOCALE_USER_DEFAULT,
DATE_SHORTDATE,
&systemTime,
0,
dateString,
dateStringMaxLength) == 0) {
// TODO: Process this error.
}
target->setString(dateString);
target->appendChar(_T(' '));
const size_t timeStringMaxLength = 255;
TCHAR timeString[timeStringMaxLength + 1];
if (GetTimeFormat(
LOCALE_USER_DEFAULT,
0,
&systemTime,
0,
timeString,
timeStringMaxLength) == 0) {
// TODO: Process this error.
}
target->appendString(timeString);
}
void Log::ReallyPrint(LPCTSTR format, va_list ap)
{
SYSTEMTIME current;
GetLocalTime(¤t);
if (memcmp(&m_lastLogT, ¤t, sizeof(SYSTEMTIME)) != 0)
{
m_lastLogT = current;
char time_str[50] = {0};
char date_str[50] = {0};
int nRet = GetDateFormat(LOCALE_USER_DEFAULT, NULL, ¤t, "ddd yyyy-MM-dd", date_str, sizeof(date_str));
nRet = GetTimeFormat(LOCALE_USER_DEFAULT,NULL, ¤t,"hh:mm:ss",time_str,sizeof(time_str));
char time_buf[50];
sprintf(time_buf, "%s %s\r\n",date_str, time_str);
ReallyPrintLine(time_buf);
}
// Prepare the complete log message
TCHAR line[LINE_BUFFER_SIZE];
memset(line, 0, sizeof(line));
_vsnprintf(line, sizeof(line) - 2 * sizeof(TCHAR), format, ap);
line[LINE_BUFFER_SIZE-2] = (TCHAR)'\0';
#if (!defined(_UNICODE) && !defined(_MBCS))
int len = strlen(line);
if (len > 0 && len <= sizeof(line) - 2 * sizeof(TCHAR) && line[len-1] == (TCHAR)'\n') {
// Replace trailing '\n' with MS-DOS style end-of-line.
line[len-1] = (TCHAR)'\r';
line[len] = (TCHAR)'\n';
line[len+1] = (TCHAR)'\0';
}
#endif
ReallyPrintLine(line);
ReallyPrintLine(TEXT("\n"));
}
void CCoBroker::AddList(const cLog::cEventDesc &EventDesc, const TCHAR *Item, ...) throw( )
{
try
{
// Exit if verbosity level is _NO_TRACE_ of high than defined level
if( (_NO_TRACE_ == EventDesc.getVerbosity()) || (EventDesc.getVerbosity() >= _TRACE_CALLS_) )
return;
SYSTEMTIME SysTime;
GetLocalTime(&SysTime);
TCHAR Buf[MAX_PATH];
tstring TimeStr;
if(!GetTimeFormat(LOCALE_USER_DEFAULT,0,&SysTime,NULL,Buf,MAX_PATH))
TimeStr += _T("Invalid time");
else
TimeStr += Buf;
TimeStr += _T("> ");
va_list vl;
tstring str;
for(va_start(vl, Item); Item; Item=va_arg(vl, PTCHAR))
{
str += Item;
}
va_end(vl);
TimeStr += str;
TimeStr+=_T(" ");
if (EventDesc.getCallStack())
TimeStr+=EventDesc.getCallStack();//call stack
//HRESULT result;
//result=NotifyLogMessage(CComBSTR(TimeStr.c_str()),EventDesc.getSeverity());
::PostMessage(m_hWnd,m_msgFireNotifyLogMessage, reinterpret_cast<WPARAM>(new CComBSTR(TimeStr.c_str())),EventDesc.getSeverity());
}
catch(...)
{
}
}
void
isc_time_formattimestamp(const isc_time_t *t, char *buf, unsigned int len) {
FILETIME localft;
SYSTEMTIME st;
char DateBuf[50];
char TimeBuf[50];
static const char badtime[] = "99-Bad-9999 99:99:99.999";
REQUIRE(len > 0);
if (FileTimeToLocalFileTime(&t->absolute, &localft) &&
FileTimeToSystemTime(&localft, &st)) {
GetDateFormat(LOCALE_USER_DEFAULT, 0, &st, "dd-MMM-yyyy",
DateBuf, 50);
GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOTIMEMARKER|
TIME_FORCE24HOURFORMAT, &st, NULL, TimeBuf, 50);
snprintf(buf, len, "%s %s.%03u", DateBuf, TimeBuf,
st.wMilliseconds);
} else
snprintf(buf, len, badtime);
}
static void ConvertPGPTimeToString(PGPTime time,
char *dateString,
PGPUInt32 dateStrLength,
char *timeString,
PGPUInt32 timeStrLength)
{
SYSTEMTIME systemtime;
time_t ttTime;
struct tm* ptm;
ttTime = PGPGetStdTimeFromPGPTime(time);
ptm = localtime(&ttTime);
StdTimeToSystemTime(ptm, &systemtime);
GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &systemtime,
NULL, dateString, dateStrLength);
GetTimeFormat(LOCALE_USER_DEFAULT, LOCALE_NOUSEROVERRIDE, &systemtime,
NULL, timeString, timeStrLength);
return;
}
char *GetTimeLeft(DWORD dwTimeLeft,
char *szTimeString,
DWORD dwTimeStringBufSize)
{
DWORD dwTimeLeftPP;
SYSTEMTIME stTime;
ZeroMemory(&stTime, sizeof(stTime));
dwTimeLeftPP = dwTimeLeft + 1;
stTime.wHour = (unsigned)(dwTimeLeftPP / 60 / 60);
stTime.wMinute = (unsigned)((dwTimeLeftPP / 60) % 60);
stTime.wSecond = (unsigned)(dwTimeLeftPP % 60);
ZeroMemory(szTimeString, dwTimeStringBufSize);
/* format time string using user's local time format information */
GetTimeFormat(LOCALE_USER_DEFAULT,
TIME_NOTIMEMARKER|TIME_FORCE24HOURFORMAT,
&stTime,
NULL,
szTimeString,
dwTimeStringBufSize);
return(szTimeString);
}
/* Update all locale samples */
static VOID
UpdateLocaleSample(HWND hwndDlg, LCID lcidLocale)
{
TCHAR OutBuffer[MAX_SAMPLES_STR_SIZE];
/* Get number format sample */
GetNumberFormat(lcidLocale, NO_FLAG, SAMPLE_NUMBER, NULL, OutBuffer,
MAX_SAMPLES_STR_SIZE);
SendMessage(GetDlgItem(hwndDlg, IDC_NUMSAMPLE_EDIT),
WM_SETTEXT, 0, (LPARAM)OutBuffer);
/* Get monetary format sample */
GetCurrencyFormat(lcidLocale, LOCALE_USE_CP_ACP, SAMPLE_NUMBER, NULL,
OutBuffer, MAX_SAMPLES_STR_SIZE);
SendMessage(GetDlgItem(hwndDlg, IDC_MONEYSAMPLE_EDIT),
WM_SETTEXT, 0, (LPARAM)OutBuffer);
/* Get time format sample */
GetTimeFormat(lcidLocale, NO_FLAG, NULL, NULL, OutBuffer, MAX_SAMPLES_STR_SIZE);
SendMessage(GetDlgItem(hwndDlg, IDC_TIMESAMPLE_EDIT),
WM_SETTEXT,
0,
(LPARAM)OutBuffer);
/* Get short date format sample */
GetDateFormat(lcidLocale, DATE_SHORTDATE, NULL, NULL, OutBuffer,
MAX_SAMPLES_STR_SIZE);
SendMessage(GetDlgItem(hwndDlg, IDC_SHORTTIMESAMPLE_EDIT), WM_SETTEXT,
0, (LPARAM)OutBuffer);
/* Get long date sample */
GetDateFormat(lcidLocale, DATE_LONGDATE, NULL, NULL, OutBuffer,
MAX_SAMPLES_STR_SIZE);
SendMessage(GetDlgItem(hwndDlg, IDC_FULLTIMESAMPLE_EDIT),
WM_SETTEXT, 0, (LPARAM)OutBuffer);
}
CString FormatDateTime32bit(const Variant& value)
{
unsigned int uiTime = GetUnsignedIntValue(value);
FILETIME fileTime = { 0 };
BOOL bRet = DosDateTimeToFileTime(HIWORD(uiTime), LOWORD(uiTime), &fileTime);
if (bRet != TRUE)
return _T("N/A");
SYSTEMTIME systemTime = { 0 };
bRet = FileTimeToSystemTime(&fileTime, &systemTime);
if (bRet != TRUE)
return _T("N/A");
CString cszDate;
GetDateFormat(LOCALE_USER_DEFAULT, 0, &systemTime, _T("yyyy'-'MM'-'dd"), cszDate.GetBuffer(32), 32);
cszDate.ReleaseBuffer();
CString cszTime;
GetTimeFormat(LOCALE_USER_DEFAULT, 0, &systemTime, _T(" HH':'mm':'ss"), cszTime.GetBuffer(32), 32);
cszTime.ReleaseBuffer();
return cszDate + cszTime;
}
/* Ad-hoc API exported by Opera: date and time */
/* static */ OP_STATUS
ES_ImportedAPI::FormatLocalTime(ES_ImportedAPI::DateFormatSpec how, uni_char *buf, unsigned length, ES_ImportedAPI::TimeElements* time)
{
#if defined(MSWIN) || defined(WINGOGI)
SYSTEMTIME dtime;
unsigned len = 0;
dtime.wYear = time->year;
dtime.wMonth = time->month + 1;
dtime.wDayOfWeek = time->day_of_week;
dtime.wDay = time->day_of_month;
dtime.wHour = time->hour;
dtime.wMinute = time->minute;
dtime.wSecond = time->second;
dtime.wMilliseconds = time->millisecond;
if (how == GET_DATE_AND_TIME || how == GET_DATE)
if ((len = GetDateFormat(LOCALE_USER_DEFAULT, DATE_LONGDATE, &dtime, NULL, buf, length)) == 0)
goto failure;
if (how == GET_DATE_AND_TIME)
buf[len - 1] = ' ';
if (how == GET_DATE_AND_TIME || how == GET_TIME)
if ((len = GetTimeFormat(LOCALE_USER_DEFAULT, 0, &dtime, NULL, buf + len, length - len)) == 0)
goto failure;
return OpStatus::OK;
failure:
// It seems that GetDateFormat or GetTimeFormat fails on Windows 95 (and perhaps some
// installations of Windows 98). It would be bad to return an empty string, so just
// handle it by the default action.
#endif // MSWIN || WINGOGI
return OpStatus::ERR;
}
void ConvertDate(const FILETIME& ft,wchar_t *DateText,wchar_t *TimeText)
{
if (ft.dwHighDateTime==0 && ft.dwLowDateTime==0)
{
if (DateText!=NULL)
*DateText=0;
if (TimeText!=NULL)
*TimeText=0;
return;
}
SYSTEMTIME st;
FILETIME ct;
FileTimeToLocalFileTime(&ft,&ct);
FileTimeToSystemTime(&ct,&st);
if (TimeText!=NULL)
GetTimeFormat(LOCALE_USER_DEFAULT, 0, &st, 0, TimeText, MAX_DATETIME);
if (DateText!=NULL)
GetDateFormat(LOCALE_USER_DEFAULT, 0, &st, 0, DateText, MAX_DATETIME);
}
STDMETHODIMP CBaseGraph::QueryPreferredFormat(GUID* pFormat)
{
return GetTimeFormat(pFormat);
}
static void MyGetEnvironmentInfo (void)
{
static FilePath stMyApplicationPath;
static DWORD stMyDummy;
static DWORD stMyVersionSize;
static char *stMyVersionInfo;
static UINT stMyVersionInfoSize;
static char stMyTempString [256];
static HANDLE stMyFile;
static DWORD stMyFileSize;
static FILETIME stMyFileTime, stMyDummy1, stMyDummy2;
static SYSTEMTIME stMySystemTime;
//
// Line 1: Date: Oct 20, 2000
//
// Start with current date label
MyAddToBuffer ("Date: ");
// Add the current date
GetDateFormat (LOCALE_USER_DEFAULT, 0, NULL, "MMM d yyyy",
stMyTempString, sizeof (stMyTempString));
MyAddToBuffer (stMyTempString);
// Add a space
MyAddToBuffer (" ");
// Add the current time
GetTimeFormat (LOCALE_USER_DEFAULT, TIME_NOSECONDS, NULL, NULL,
stMyTempString, sizeof (stMyTempString));
MyAddToBuffer (stMyTempString);
// Add a newline
MyAddToBuffer ("\r\n\r\n");
//
// Line 2: File Name: d:\ready\ready.exe
//
// Start with file name label
MyAddToBuffer ("File Name: ");
// Add the application path
GetModuleFileName (NULL, stMyApplicationPath, sizeof (stMyApplicationPath));
MyAddToBuffer (stMyApplicationPath);
// Add a newline
MyAddToBuffer ("\r\n");
//
// Line 3 (Maybe): Version: 1.0.2 [Mini/Restricted/IBM/71]
//
// Start with the version label
MyAddToBuffer ("Version: ");
// Set to empty string by default
stMyVersionSize = GetFileVersionInfoSize (stMyApplicationPath, &stMyDummy);
if ((stMyVersionSize != 0) && (stMyVersionSize <= stCrashBufferLeft))
{
if (GetFileVersionInfo (stMyApplicationPath, stMyDummy,
stCrashBufferLeft, stCrashBufferPtr))
{
if (VerQueryValue (stCrashBufferPtr,
"\\StringFileInfo\\04090000\\ProductVersion",
&stMyVersionInfo, &stMyVersionInfoSize))
{
// Add the version number (size includes \0)
memmove (stCrashBufferPtr, stMyVersionInfo,
stMyVersionInfoSize);
stCrashBufferLeft -= stMyVersionInfoSize - 1;
stCrashBufferPtr += stMyVersionInfoSize - 1;
}
else
{
MyAddToBuffer ("Unknown");
}
}
else
{
MyAddToBuffer ("Unknown");
}
}
else
{
MyAddToBuffer ("Unknown");
}
if (gProgram.globalsInitialized)
{
// Add a spaces
MyAddToBuffer (" [");
if (gProgram.miniVersion)
MyAddToBuffer ("Mini/");
if (gProgram.restrictedVersion)
MyAddToBuffer ("Restricted/");
if (gProgram.assistedByIBM)
MyAddToBuffer ("IBM/");
if (gProgram.expiryDateString [0] != 0)
{
MyAddToBuffer (gProgram.expiryDateString);
MyAddToBuffer ("/");
}
wsprintf (stMyTempString, "%d]", gProgram.installKind);
MyAddToBuffer (stMyTempString);
} // if (gProgram.globalsInitialized)
// Add a newline
MyAddToBuffer ("\r\n");
//
// Line 4: File Size: 2876346
//
stMyFile = CreateFile (stMyApplicationPath, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, 0, 0);
if (stMyFile != (HANDLE) INVALID_HANDLE_VALUE)
{
stMyFileSize = GetFileSize (stMyFile, NULL);
// Start with the size label
MyAddToBuffer ("File Size: ");
// Add the file size
wsprintf (stMyTempString, "%d\r\n", stMyFileSize);
MyAddToBuffer (stMyTempString);
//
// Line 5: File Date: Oct 10, 2000
//
GetFileTime (stMyFile, &stMyDummy1, &stMyDummy2, &stMyFileTime);
if (FileTimeToSystemTime (&stMyFileTime, &stMySystemTime))
{
// Start with the date label
MyAddToBuffer ("File Date: ");
// Add the file date
GetDateFormat (LOCALE_USER_DEFAULT, 0, &stMySystemTime,
"MMM d yyyy", stMyTempString, sizeof (stMyTempString));
MyAddToBuffer (stMyTempString);
MyAddToBuffer (" ");
// Add the file time
GetTimeFormat (LOCALE_USER_DEFAULT, TIME_NOSECONDS, &stMySystemTime,
NULL, stMyTempString, sizeof (stMyTempString));
MyAddToBuffer (stMyTempString);
}
CloseHandle (stMyFile);
}
//
// Line 6: Operating System: Windows 95
//
MyAddToBuffer ("\r\nOperating System: ");
switch (gProgram.operatingSystem)
{
case UNKNOWN_OS:
MyAddToBuffer ("Unknown Windows version\r\n");
break;
case WIN_95:
MyAddToBuffer ("Windows 95\r\n");
break;
case WIN_95_OSR2:
MyAddToBuffer ("Windows 95 Service Pack 2\r\n");
break;
case WIN_98:
MyAddToBuffer ("Windows 98\r\n");
break;
case WIN_98_SE:
MyAddToBuffer ("Windows 98 Second Edition\r\n");
break;
case WIN_ME:
MyAddToBuffer ("Windows Me\r\n");
break;
case WIN_NT:
MyAddToBuffer ("Windows NT\r\n");
break;
case WIN_2000:
MyAddToBuffer ("Windows 2000\r\n");
break;
case WIN_XP:
MyAddToBuffer ("Windows XP\r\n");
break;
case WIN_NEWER:
MyAddToBuffer ("After Windows XP\r\n");
break;
default:
MyAddToBuffer ("Bad OS Value (%d)\r\n", gProgram.operatingSystem);
break;
} // switch
//
// Line 7: JVM: Ready Built-in JRE (1.4.2 or later)
//
MyAddToBuffer ("JVM: ");
switch (gProperties.JVMType)
{
case JRE_131:
MyAddToBuffer ("Ready JRE 1.3.1\r\n");
break;
case JRE_BUILT_IN:
MyAddToBuffer ("Ready Built-in JRE (1.4.2 or later)\r\n");
break;
case JRE_IN_JRE_DIR:
MyAddToBuffer ("Ready User-installed JRE\r\n");
break;
case JDK_IN_JRE_DIR:
MyAddToBuffer ("Ready User-installed JDK\r\n");
break;
case JRE_IN_REGISTRY:
MyAddToBuffer ("Ready System JRE\r\n");
break;
case JDK_IN_REGISTRY:
MyAddToBuffer ("Ready System JDK\r\n");
break;
} // switch
//
// Line 8: "assert": enabled
//
if (gProperties.oldJavaCompile)
{
MyAddToBuffer ("\"assert\" Statements: disabled\r\n");
}
else
{
MyAddToBuffer ("\"assert\" Statements: enabled\r\n");
}
} // MyGetEnvironmentInfo
STDMETHODIMP CBaseMuxerFilter::QueryPreferredFormat(GUID* pFormat)
{
return GetTimeFormat(pFormat);
}
LONG
SecMgrpDlgProcInitReport(
HWND hwnd,
UINT wMsg,
DWORD wParam,
LONG lParam
)
/*++
Routine Description:
This function is the dialog process for the dialog that informs the user
that a new report file is being initialized. It asks the user to be patient
and then goes about notifying all the smedlys of the new report file.
Arguments
None - all information is available in module-wide variables.
Return Values:
--*/
{
HWND
Button;
HCURSOR
hCursor;
DWORD
StringId,
OutputLineLength;
BOOL
Result;
TCHAR
OutputLine[SECMGR_MAX_RESOURCE_STRING_LENGTH];
switch (wMsg) {
case WM_INITDIALOG:
if (!SecMgrpReportActive) {
EndDialog(hwnd, 0);
return(TRUE);
}
SetForegroundWindow(hwnd);
ShowWindow(hwnd, SW_NORMAL);
//
// Change the cursor to an hourglass
//
hCursor = SetCursor( LoadCursor(NULL, IDC_WAIT) );
ShowCursor(TRUE);
//
// put header information in the new report file
//
//
// time
//
LoadString( SecMgrphInstance,
SECMGRP_STRING_REPORT_TIME,
OutputLine,
sizeof(OutputLine)
);
SecMgrPrintReportLine( OutputLine );
OutputLineLength = GetTimeFormat( (SHORT)NtCurrentTeb()->CurrentLocale,
TIME_FORCE24HOURFORMAT, // Flags
NULL, // use current time
NULL, // Format for current locale
OutputLine, // Receives time string
sizeof(OutputLine)
);
ASSERT(OutputLineLength != 0);
SecMgrPrintReportLine( OutputLine );
//
// Date
//
LoadString( SecMgrphInstance,
SECMGRP_STRING_REPORT_DATE,
OutputLine,
sizeof(OutputLine)
);
SecMgrPrintReportLine( OutputLine );
OutputLineLength = GetDateFormat( (SHORT)NtCurrentTeb()->CurrentLocale,
0, // Flags
NULL, // use current date
NULL, // Format for current locale
OutputLine, // Receives date string
sizeof(OutputLine)
);
ASSERT(OutputLineLength != 0);
SecMgrPrintReportLine( OutputLine );
//
// Machine
//
LoadString( SecMgrphInstance,
SECMGRP_STRING_REPORT_MACHINE,
OutputLine,
sizeof(OutputLine)
);
SecMgrPrintReportLine( OutputLine );
OutputLineLength = sizeof(OutputLine);
Result = GetComputerName( OutputLine, &OutputLineLength );
ASSERT(Result);
SecMgrPrintReportLine( OutputLine );
//
// Security Level
//
SecMgrpReportSecurityLevel( SECMGRP_STRING_REPORT_LEVEL, SecMgrpCurrentLevel );
SecMgrPrintReportLine( L"\n\n" );
//
// Now notify the smedlys
// There are two passes.
// Pass 1 - Before we print out the summary list
// Pass 2 - After we print out the summary list
//
SecMgrpSmedlyReportFileChange( SecMgrpReportActive, 1 ); //Pass 1
SecMgrpFillInItemList( TRUE, hwnd );
SecMgrpSmedlyReportFileChange( SecMgrpReportActive, 2 ); //Pass 2
//
// That's it - we're done
//
EndDialog(hwnd, 0);
return(TRUE);
case WM_SYSCOMMAND:
switch (wParam & 0xfff0) {
case SC_CLOSE:
EndDialog(hwnd, 0);
return(TRUE);
}
return(FALSE);
default:
break;
}
return FALSE;
}
extern "C" BOOL EditPrint(HWND hwnd,LPCWSTR pszDocTitle,LPCWSTR pszPageFormat)
{
// Don't print empty documents
if (SendMessage(hwnd,SCI_GETLENGTH,0,0) == 0) {
MsgBox(MBWARN,IDS_PRINT_EMPTY);
return TRUE;
}
int startPos;
int endPos;
HDC hdc;
RECT rectMargins;
RECT rectPhysMargins;
RECT rectSetup;
POINT ptPage;
POINT ptDpi;
//RECT rectSetup;
TEXTMETRIC tm;
int headerLineHeight;
HFONT fontHeader;
int footerLineHeight;
HFONT fontFooter;
WCHAR dateString[MIDSZ_BUFFER] = { L'\0' };
DOCINFO di = {sizeof(DOCINFO), nullptr, nullptr, nullptr, 0};
int lengthDoc;
int lengthDocMax;
int lengthPrinted;
struct Sci_RangeToFormat frPrint;
int pageNum;
BOOL printPage;
WCHAR pageString[32] = { L'\0' };
HPEN pen;
HPEN penOld;
PRINTDLG pdlg = { sizeof(PRINTDLG), nullptr, nullptr, nullptr, nullptr,
0, 0, 0, 0, 0, 0, nullptr, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
pdlg.hwndOwner = GetParent(hwnd);
pdlg.hInstance = g_hInstance;
pdlg.Flags = PD_USEDEVMODECOPIES | PD_ALLPAGES | PD_RETURNDC;
pdlg.nFromPage = 1;
pdlg.nToPage = 1;
pdlg.nMinPage = 1;
pdlg.nMaxPage = 0xffffU;
pdlg.nCopies = 1;
pdlg.hDC = nullptr;
pdlg.hDevMode = hDevMode;
pdlg.hDevNames = hDevNames;
startPos = (int)SendMessage(hwnd,SCI_GETSELECTIONSTART,0,0);
endPos = (int)SendMessage(hwnd,SCI_GETSELECTIONEND,0,0);
if (startPos == endPos) {
pdlg.Flags |= PD_NOSELECTION;
} else {
pdlg.Flags |= PD_SELECTION;
}
// |= 0 - Don't display dialog box, just use the default printer and options
pdlg.Flags |= (flagPrintFileAndLeave == 1) ? PD_RETURNDEFAULT : 0;
if (!PrintDlg(&pdlg)) {
return TRUE; // False means error...
}
hDevMode = pdlg.hDevMode;
hDevNames = pdlg.hDevNames;
hdc = pdlg.hDC;
// Get printer resolution
ptDpi.x = GetDeviceCaps(hdc, LOGPIXELSX); // dpi in X direction
ptDpi.y = GetDeviceCaps(hdc, LOGPIXELSY); // dpi in Y direction
// Start by getting the physical page size (in device units).
ptPage.x = GetDeviceCaps(hdc, PHYSICALWIDTH); // device units
ptPage.y = GetDeviceCaps(hdc, PHYSICALHEIGHT); // device units
// Get the dimensions of the unprintable
// part of the page (in device units).
rectPhysMargins.left = GetDeviceCaps(hdc, PHYSICALOFFSETX);
rectPhysMargins.top = GetDeviceCaps(hdc, PHYSICALOFFSETY);
// To get the right and lower unprintable area,
// we take the entire width and height of the paper and
// subtract everything else.
rectPhysMargins.right = ptPage.x // total paper width
- GetDeviceCaps(hdc, HORZRES) // printable width
- rectPhysMargins.left; // left unprintable margin
rectPhysMargins.bottom = ptPage.y // total paper height
- GetDeviceCaps(hdc, VERTRES) // printable height
- rectPhysMargins.top; // right unprintable margin
// At this point, rectPhysMargins contains the widths of the
// unprintable regions on all four sides of the page in device units.
// Take in account the page setup given by the user (if one value is not null)
if (pagesetupMargin.left != 0 || pagesetupMargin.right != 0 ||
pagesetupMargin.top != 0 || pagesetupMargin.bottom != 0) {
// Convert the hundredths of millimeters (HiMetric) or
// thousandths of inches (HiEnglish) margin values
// from the Page Setup dialog to device units.
// (There are 2540 hundredths of a mm in an inch.)
WCHAR localeInfo[3];
GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IMEASURE, localeInfo, 3);
if (localeInfo[0] == L'0') { // Metric system. L'1' is US System
rectSetup.left = MulDiv (pagesetupMargin.left, ptDpi.x, 2540);
rectSetup.top = MulDiv (pagesetupMargin.top, ptDpi.y, 2540);
rectSetup.right = MulDiv(pagesetupMargin.right, ptDpi.x, 2540);
rectSetup.bottom = MulDiv(pagesetupMargin.bottom, ptDpi.y, 2540);
} else {
rectSetup.left = MulDiv(pagesetupMargin.left, ptDpi.x, 1000);
rectSetup.top = MulDiv(pagesetupMargin.top, ptDpi.y, 1000);
rectSetup.right = MulDiv(pagesetupMargin.right, ptDpi.x, 1000);
rectSetup.bottom = MulDiv(pagesetupMargin.bottom, ptDpi.y, 1000);
}
// Dont reduce margins below the minimum printable area
rectMargins.left = max(rectPhysMargins.left, rectSetup.left);
rectMargins.top = max(rectPhysMargins.top, rectSetup.top);
rectMargins.right = max(rectPhysMargins.right, rectSetup.right);
rectMargins.bottom = max(rectPhysMargins.bottom, rectSetup.bottom);
} else {
rectMargins.left = rectPhysMargins.left;
rectMargins.top = rectPhysMargins.top;
rectMargins.right = rectPhysMargins.right;
rectMargins.bottom = rectPhysMargins.bottom;
}
// rectMargins now contains the values used to shrink the printable
// area of the page.
// Convert device coordinates into logical coordinates
DPtoLP(hdc, (LPPOINT)&rectMargins, 2);
DPtoLP(hdc, (LPPOINT)&rectPhysMargins, 2);
// Convert page size to logical units and we're done!
DPtoLP(hdc, (LPPOINT) &ptPage, 1);
headerLineHeight = MulDiv(8,ptDpi.y, 72);
fontHeader = CreateFont(headerLineHeight,
0, 0, 0,
FW_BOLD,
0,
0,
0, 0, 0,
0, 0, 0,
L"Arial");
SelectObject(hdc, fontHeader);
GetTextMetrics(hdc, &tm);
headerLineHeight = tm.tmHeight + tm.tmExternalLeading;
if (iPrintHeader == 3)
headerLineHeight = 0;
footerLineHeight = MulDiv(7,ptDpi.y, 72);
fontFooter = CreateFont(footerLineHeight,
0, 0, 0,
FW_NORMAL,
0,
0,
0, 0, 0,
0, 0, 0,
L"Arial");
SelectObject(hdc, fontFooter);
GetTextMetrics(hdc, &tm);
footerLineHeight = tm.tmHeight + tm.tmExternalLeading;
if (iPrintFooter == 1)
footerLineHeight = 0;
di.lpszDocName = pszDocTitle;
di.lpszOutput = nullptr;
di.lpszDatatype = nullptr;
di.fwType = 0;
if (StartDoc(hdc, &di) < 0) {
DeleteDC(hdc);
if (fontHeader)
DeleteObject(fontHeader);
if (fontFooter)
DeleteObject(fontFooter);
return FALSE;
}
// Get current date...
SYSTEMTIME st;
GetLocalTime(&st);
GetDateFormat(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&st,nullptr,dateString,MIDSZ_BUFFER);
// Get current time...
if (iPrintHeader == 0)
{
WCHAR timeString[SMALL_BUFFER] = { L'\0' };
GetTimeFormat(LOCALE_USER_DEFAULT,TIME_NOSECONDS,&st,nullptr,timeString,SMALL_BUFFER);
StringCchCat(dateString,COUNTOF(dateString),L" ");
StringCchCat(dateString,COUNTOF(dateString),timeString);
}
// Set print color mode
int printColorModes[5] = {
SC_PRINT_NORMAL,
SC_PRINT_INVERTLIGHT,
SC_PRINT_BLACKONWHITE,
SC_PRINT_COLOURONWHITE,
SC_PRINT_COLOURONWHITEDEFAULTBG };
SendMessage(hwnd,SCI_SETPRINTCOLOURMODE,printColorModes[iPrintColor],0);
// Set print zoom...
SendMessage(hwnd,SCI_SETPRINTMAGNIFICATION,(WPARAM)iPrintZoom,0);
lengthDoc = (int)SendMessage(hwnd,SCI_GETLENGTH,0,0);
lengthDocMax = lengthDoc;
lengthPrinted = 0;
// Requested to print selection
if (pdlg.Flags & PD_SELECTION) {
if (startPos > endPos) {
lengthPrinted = endPos;
lengthDoc = startPos;
} else {
lengthPrinted = startPos;
lengthDoc = endPos;
}
if (lengthPrinted < 0)
lengthPrinted = 0;
if (lengthDoc > lengthDocMax)
lengthDoc = lengthDocMax;
}
// We must substract the physical margins from the printable area
frPrint.hdc = hdc;
frPrint.hdcTarget = hdc;
frPrint.rc.left = rectMargins.left - rectPhysMargins.left;
frPrint.rc.top = rectMargins.top - rectPhysMargins.top;
frPrint.rc.right = ptPage.x - rectMargins.right - rectPhysMargins.left;
frPrint.rc.bottom = ptPage.y - rectMargins.bottom - rectPhysMargins.top;
frPrint.rcPage.left = 0;
frPrint.rcPage.top = 0;
frPrint.rcPage.right = ptPage.x - rectPhysMargins.left - rectPhysMargins.right - 1;
frPrint.rcPage.bottom = ptPage.y - rectPhysMargins.top - rectPhysMargins.bottom - 1;
frPrint.rc.top += headerLineHeight + headerLineHeight / 2;
frPrint.rc.bottom -= footerLineHeight + footerLineHeight / 2;
// Print each page
pageNum = 1;
while (lengthPrinted < lengthDoc) {
printPage = (!(pdlg.Flags & PD_PAGENUMS) ||
(pageNum >= pdlg.nFromPage) && (pageNum <= pdlg.nToPage));
StringCchPrintf(pageString,COUNTOF(pageString),pszPageFormat,pageNum);
if (printPage) {
// Show wait cursor...
SendMessage(g_hwndEdit, SCI_SETCURSOR, (WPARAM)SC_CURSORWAIT, 0);
// Display current page number in Statusbar
StatusUpdatePrintPage(pageNum);
StartPage(hdc);
SetTextColor(hdc, RGB(0,0,0));
SetBkColor(hdc, RGB(0xFF, 0xFF, 0xFF));
SelectObject(hdc, fontHeader);
UINT ta = SetTextAlign(hdc, TA_BOTTOM);
RECT rcw = {frPrint.rc.left, frPrint.rc.top - headerLineHeight - headerLineHeight / 2,
frPrint.rc.right, frPrint.rc.top - headerLineHeight / 2};
rcw.bottom = rcw.top + headerLineHeight;
if (iPrintHeader < 3)
{
ExtTextOut(hdc, frPrint.rc.left + 5, frPrint.rc.top - headerLineHeight / 2,
/*ETO_OPAQUE*/0, &rcw, pszDocTitle,
lstrlen(pszDocTitle), nullptr);
}
// Print date in header
if (iPrintHeader == 0 || iPrintHeader == 1)
{
SIZE sizeInfo;
SelectObject(hdc,fontFooter);
GetTextExtentPoint32(hdc,dateString,StringCchLenW(dateString,COUNTOF(dateString)),&sizeInfo);
ExtTextOut(hdc, frPrint.rc.right - 5 - sizeInfo.cx, frPrint.rc.top - headerLineHeight / 2,
/*ETO_OPAQUE*/0, &rcw, dateString,
StringCchLenW(dateString,COUNTOF(dateString)), nullptr);
}
if (iPrintHeader < 3)
{
SetTextAlign(hdc, ta);
pen = CreatePen(0, 1, RGB(0,0,0));
penOld = (HPEN)SelectObject(hdc, pen);
MoveToEx(hdc, frPrint.rc.left, frPrint.rc.top - headerLineHeight / 4, nullptr);
LineTo(hdc, frPrint.rc.right, frPrint.rc.top - headerLineHeight / 4);
SelectObject(hdc, penOld);
DeleteObject(pen);
}
}
frPrint.chrg.cpMin = lengthPrinted;
frPrint.chrg.cpMax = lengthDoc;
lengthPrinted = (int)SendMessage(hwnd, SCI_FORMATRANGE, printPage, (LPARAM)&frPrint);
if (printPage) {
SetTextColor(hdc, RGB(0,0,0));
SetBkColor(hdc, RGB(0xFF, 0xFF, 0xFF));
SelectObject(hdc, fontFooter);
UINT ta = SetTextAlign(hdc, TA_TOP);
RECT rcw = {frPrint.rc.left, frPrint.rc.bottom + footerLineHeight / 2,
frPrint.rc.right, frPrint.rc.bottom + footerLineHeight + footerLineHeight / 2};
if (iPrintFooter == 0)
{
SIZE sizeFooter;
GetTextExtentPoint32(hdc,pageString,StringCchLenW(pageString,COUNTOF(pageString)),&sizeFooter);
ExtTextOut(hdc, frPrint.rc.right - 5 - sizeFooter.cx, frPrint.rc.bottom + footerLineHeight / 2,
/*ETO_OPAQUE*/0, &rcw, pageString,
StringCchLenW(pageString,COUNTOF(pageString)), nullptr);
SetTextAlign(hdc, ta);
pen = ::CreatePen(0, 1, RGB(0,0,0));
penOld = (HPEN)SelectObject(hdc, pen);
SetBkColor(hdc, RGB(0,0,0));
MoveToEx(hdc, frPrint.rc.left, frPrint.rc.bottom + footerLineHeight / 4, nullptr);
LineTo(hdc, frPrint.rc.right, frPrint.rc.bottom + footerLineHeight / 4);
SelectObject(hdc, penOld);
DeleteObject(pen);
}
EndPage(hdc);
}
pageNum++;
if ((pdlg.Flags & PD_PAGENUMS) && (pageNum > pdlg.nToPage))
break;
}
SendMessage(hwnd,SCI_FORMATRANGE, FALSE, 0);
EndDoc(hdc);
DeleteDC(hdc);
if (fontHeader)
DeleteObject(fontHeader);
if (fontFooter)
DeleteObject(fontFooter);
// Reset Statusbar to default mode
StatusSetSimple(g_hwndStatus,FALSE);
// Remove wait cursor...
{ POINT pt; SendMessage(g_hwndEdit, SCI_SETCURSOR, (WPARAM)SC_CURSORNORMAL, 0); GetCursorPos(&pt); SetCursorPos(pt.x, pt.y); }
return TRUE;
}
void DrawIdleScreen(void)
{
unsigned char msd;
unsigned char lsd;
unsigned char Row = 6;
unsigned char Col = 0;
int Minutes;
/* display hour */
int Hour = GetRTCHOUR();
/* if required convert to twelve hour format */
if ( GetTimeFormat() == TWELVE_HOUR )
{
if ( Hour == 0 )
{
Hour = 12;
}
else if ( Hour > 12 )
{
Hour -= 12;
}
}
msd = Hour / 10;
lsd = Hour % 10;
/* if first digit is zero then leave location blank */
if ( msd != 0 )
{
WriteTimeDigit(msd,Row,Col,LEFT_JUSTIFIED);
}
Col += 1;
WriteTimeDigit(lsd,Row,Col,RIGHT_JUSTIFIED);
Col += 2;
/* the colon takes the first 5 bits on the byte*/
WriteTimeColon(Row,Col,RIGHT_JUSTIFIED);
Col+=1;
/* display minutes */
Minutes = GetRTCMIN();
msd = Minutes / 10;
lsd = Minutes % 10;
WriteTimeDigit(msd,Row,Col,RIGHT_JUSTIFIED);
Col += 2;
WriteTimeDigit(lsd,Row,Col,LEFT_JUSTIFIED);
if ( nvDisplaySeconds )
{
/* the final colon's spacing isn't quite the same */
int Seconds = GetRTCSEC();
msd = Seconds / 10;
lsd = Seconds % 10;
Col +=2;
WriteTimeColon(Row,Col,LEFT_JUSTIFIED);
Col += 1;
WriteTimeDigit(msd,Row,Col,LEFT_JUSTIFIED);
Col += 1;
WriteTimeDigit(lsd,Row,Col,RIGHT_JUSTIFIED);
}
else /* now things starting getting fun....*/
{
DisplayAmPm();
if ( QueryBluetoothOn() == 0 )
{
CopyColumnsIntoMyBuffer(pBluetoothOffIdlePageIcon,
IDLE_PAGE_ICON_STARTING_ROW,
IDLE_PAGE_ICON_SIZE_IN_ROWS,
IDLE_PAGE_ICON_STARTING_COL,
IDLE_PAGE_ICON_SIZE_IN_COLS);
}
else if ( QueryPhoneConnected() == 0 )
{
CopyColumnsIntoMyBuffer(pPhoneDisconnectedIdlePageIcon,
IDLE_PAGE_ICON_STARTING_ROW,
IDLE_PAGE_ICON_SIZE_IN_ROWS,
IDLE_PAGE_ICON_STARTING_COL,
IDLE_PAGE_ICON_SIZE_IN_COLS);
}
else
{
if ( QueryBatteryCharging() )
{
CopyColumnsIntoMyBuffer(pBatteryChargingIdlePageIconType2,
IDLE_PAGE_ICON2_STARTING_ROW,
IDLE_PAGE_ICON2_SIZE_IN_ROWS,
IDLE_PAGE_ICON2_STARTING_COL,
IDLE_PAGE_ICON2_SIZE_IN_COLS);
}
else
{
unsigned int bV = 3500;
if ( bV < 3500 )
{
CopyColumnsIntoMyBuffer(pLowBatteryIdlePageIconType2,
IDLE_PAGE_ICON2_STARTING_ROW,
IDLE_PAGE_ICON2_SIZE_IN_ROWS,
IDLE_PAGE_ICON2_STARTING_COL,
IDLE_PAGE_ICON2_SIZE_IN_COLS);
}
else
{
DisplayDayOfWeek();
DisplayDate();
}
}
}
}
}
STDMETHODIMP CStreamSwitcherPassThru::GetTimeFormat(GUID* pFormat)
{
CallPeerSeeking(GetTimeFormat(pFormat));
}
//================================================================================================
//-------------+++--> Format T-Clock's OutPut String From Current Date, Time, & System Information:
unsigned MakeFormat(char buf[FORMAT_MAX_SIZE], const char* fmt, SYSTEMTIME* pt, int beat100) //------------------+++-->
{
const char* bufend = buf+FORMAT_MAX_SIZE;
const char* pos;
char* out = buf;
ULONGLONG TickCount = 0;
while(*fmt) {
if(*fmt == '"') {
for(++fmt; *fmt&&*fmt!='"'; )
*out++ = *fmt++;
if(*fmt) ++fmt;
continue;
}
if(*fmt=='\\' && fmt[1]=='n') {
fmt+=2;
*out++='\n';
}
/// for testing
else if(*fmt == 'S' && fmt[1] == 'S' && (fmt[2] == 'S' || fmt[2] == 's')) {
fmt += 3;
out += api.WriteFormatNum(out, (int)pt->wSecond, 2, 0);
*out++ = '.';
out += api.WriteFormatNum(out, (int)pt->wMilliseconds, 3, 0);
}
else if(*fmt == 'y' && fmt[1] == 'y') {
int len;
len = 2;
if(*(fmt + 2) == 'y' && *(fmt + 3) == 'y') len = 4;
out += api.WriteFormatNum(out, (len==2)?(int)pt->wYear%100:(int)pt->wYear, len, 0);
fmt += len;
} else if(*fmt == 'm') {
if(*(fmt + 1) == 'm' && *(fmt + 2) == 'e') {
*out++ = m_MonthEng[pt->wMonth-1][0];
*out++ = m_MonthEng[pt->wMonth-1][1];
*out++ = m_MonthEng[pt->wMonth-1][2];
fmt += 3;
} else if(fmt[1] == 'm' && fmt[2] == 'm') {
if(*(fmt + 3) == 'm') {
fmt += 4;
for(pos=m_MonthLong; *pos; ) *out++=*pos++;
} else {
fmt += 3;
for(pos=m_MonthShort; *pos; ) *out++=*pos++;
}
} else {
if(fmt[1] == 'm') {
fmt += 2;
*out++ = (char)((int)pt->wMonth / 10) + '0';
} else {
++fmt;
if(pt->wMonth > 9)
*out++ = (char)((int)pt->wMonth / 10) + '0';
}
*out++ = (char)((int)pt->wMonth % 10) + '0';
}
} else if(*fmt == 'a' && fmt[1] == 'a' && fmt[2] == 'a') {
if(*(fmt + 3) == 'a') {
fmt += 4;
for(pos=m_DayOfWeekLong; *pos; ) *out++=*pos++;
} else {
fmt += 3;
for(pos=m_DayOfWeekShort; *pos; ) *out++=*pos++;
}
} else if(*fmt=='d') {
if(fmt[1]=='d' && fmt[2]=='e'){
fmt+=3;
for(pos=m_DayOfWeekEng[pt->wDayOfWeek]; *pos; ) *out++=*pos++;
}else if(fmt[1]=='d' && fmt[2]=='d') {
fmt+=3;
if(*fmt=='d'){
++fmt;
pos=m_DayOfWeekLong;
}else{
pos=m_DayOfWeekShort;
}
for(; *pos; ) *out++=*pos++;
}else{
if(fmt[1]=='d') {
fmt+=2;
*out++ = (char)((int)pt->wDay / 10) + '0';
}else{
++fmt;
if(pt->wDay > 9)
*out++ = (char)((int)pt->wDay / 10) + '0';
}
*out++ = (char)((int)pt->wDay % 10) + '0';
}
} else if(*fmt=='h') {
int hour = pt->wHour;
while(hour >= 12) // faster than mod 12 if "hour" <= 24
hour -= 12;
if(!hour && !g_bHourZero)
hour = 12;
if(fmt[1] == 'h') {
fmt += 2;
*out++ = (char)(hour / 10) + '0';
} else {
++fmt;
if(hour > 9)
*out++ = (char)(hour / 10) + '0';
}
*out++ = (char)(hour % 10) + '0';
} else if(*fmt=='H') {
if(fmt[1] == 'H') {
fmt += 2;
*out++ = (char)(pt->wHour / 10) + '0';
} else {
++fmt;
if(pt->wHour > 9)
*out++ = (char)(pt->wHour / 10) + '0';
}
*out++ = (char)(pt->wHour % 10) + '0';
} else if((*fmt=='w'||*fmt=='W') && (fmt[1]=='+'||fmt[1]=='-')) {
char is_12h = (*fmt == 'w');
char is_negative = (*++fmt == '-');
int hour = 0;
for(; *++fmt<='9'&&*fmt>='0'; ){
hour *= 10;
hour += *fmt-'0';
}
if(is_negative) hour = -hour;
hour = (pt->wHour + hour)%24;
if(hour < 0) hour += 24;
if(is_12h){
while(hour >= 12) // faster than mod 12 if "hour" <= 24
hour -= 12;
if(!hour && !g_bHourZero)
hour = 12;
}
*out++ = (char)(hour / 10) + '0';
*out++ = (char)(hour % 10) + '0';
} else if(*fmt == 'n') {
if(fmt[1] == 'n') {
fmt += 2;
*out++ = (char)((int)pt->wMinute / 10) + '0';
} else {
++fmt;
if(pt->wMinute > 9)
*out++ = (char)((int)pt->wMinute / 10) + '0';
}
*out++ = (char)((int)pt->wMinute % 10) + '0';
} else if(*fmt == 's') {
if(fmt[1] == 's') {
fmt += 2;
*out++ = (char)((int)pt->wSecond / 10) + '0';
} else {
++fmt;
if(pt->wSecond > 9)
*out++ = (char)((int)pt->wSecond / 10) + '0';
}
*out++ = (char)((int)pt->wSecond % 10) + '0';
} else if(*fmt == 't' && fmt[1] == 't') {
fmt += 2;
if(pt->wHour < 12) pos = m_AM; else pos = m_PM;
while(*pos) *out++ = *pos++;
} else if(*fmt == 'A' && fmt[1] == 'M') {
if(fmt[2] == '/' &&
fmt[3] == 'P' && fmt[4] == 'M') {
if(pt->wHour < 12) *out++ = 'A'; //--+++--> 2010 - Noon / MidNight Decided Here!
else *out++ = 'P';
*out++ = 'M'; fmt += 5;
} else if(fmt[2] == 'P' && fmt[3] == 'M') {
fmt += 4;
if(pt->wHour < 12) pos = m_AM; else pos = m_PM;
while(*pos) *out++ = *pos++;
} else *out++ = *fmt++;
} else if(*fmt == 'a' && fmt[1] == 'm' && fmt[2] == '/' &&
fmt[3] == 'p' && fmt[4] == 'm') {
if(pt->wHour < 12) *out++ = 'a';
else *out++ = 'p';
*out++ = 'm'; fmt += 5;
}
// internet time
else if(*fmt == '@' && fmt[1] == '@' && fmt[2] == '@') {
fmt += 3;
*out++ = '@';
*out++ = (char)(beat100 / 10000) + '0';
*out++ = (char)((beat100 % 10000) / 1000) + '0';
*out++ = (char)((beat100 % 1000) / 100) + '0';
if(*fmt=='.' && fmt[1]=='@') {
fmt += 2;
*out++ = '.';
*out++ = (char)((beat100 % 100) / 10) + '0';
if(*fmt=='@'){
++fmt;
*out++ = (char)((beat100 % 10)) + '0';
}
}
}
// alternate calendar
else if(*fmt == 'Y' && m_AltYear > -1) {
int n = 1;
while(*fmt == 'Y') { n *= 10; ++fmt; }
if(n < m_AltYear) {
n = 1; while(n < m_AltYear) n *= 10;
}
for(;;) {
*out++ = (char)((m_AltYear % n) / (n/10)) + '0';
if(n == 10) break;
n /= 10;
}
} else if(*fmt == 'g') {
for(pos=m_EraStr; *pos&&*fmt=='g'; ){
char* p2 = CharNextExA(m_codepage, pos, 0);
while(pos != p2) *out++ = *pos++;
++fmt;
}
while(*fmt == 'g') fmt++;
}
else if(*fmt == 'L' && strncmp(fmt, "LDATE", 5) == 0) {
GetDateFormat(LOCALE_USER_DEFAULT,
DATE_LONGDATE, pt, NULL, out, (int)(bufend-out));
for(; *out; ++out);
fmt += 5;
}
else if(*fmt == 'D' && strncmp(fmt, "DATE", 4) == 0) {
GetDateFormat(LOCALE_USER_DEFAULT,
DATE_SHORTDATE, pt, NULL, out, (int)(bufend-out));
for(; *out; ++out);
fmt += 4;
}
else if(*fmt == 'T' && strncmp(fmt, "TIME", 4) == 0) {
GetTimeFormat(LOCALE_USER_DEFAULT,
0, pt, NULL, out, (int)(bufend-out));
for(; *out; ++out);
fmt += 4;
} else if(*fmt == 'S') { // uptime
int width, padding, num;
const char* old_fmt = ++fmt;
char specifier = api.GetFormat(&fmt, &width, &padding);
if(!TickCount) TickCount = api.GetTickCount64();
switch(specifier){
case 'd'://days
num = (int)(TickCount/86400000);
break;
case 'a'://hours total
num = (int)(TickCount/3600000);
break;
case 'h'://hours (max 24)
num = (TickCount/3600000)%24;
break;
case 'n'://minutes
num = (TickCount/60000)%60;
break;
case 's'://seconds
num = (TickCount/1000)%60;
break;
case 'T':{// ST, uptime as h:mm:ss
ULONGLONG past = TickCount/1000;
int hour, minute;
num = past%60; past /= 60;
minute = past%60; past /= 60;
hour = (int)past;
out += api.WriteFormatNum(out, hour, width, padding);
*out++ = ':';
out += api.WriteFormatNum(out, minute, 2, 0);
*out++ = ':';
width = 2; padding = 0;
break;}
default:
specifier = '\0';
fmt = old_fmt;
*out++ = 'S';
}
if(specifier)
out += api.WriteFormatNum(out, num, width, padding);
} else if(*fmt == 'W') { // Week-of-Year
struct tm tmnow;
time_t ts = time(NULL);
localtime_r(&ts, &tmnow);
++fmt;
if(*fmt == 's') { // Week-Of-Year Starts Sunday
out += strftime(out, bufend-out, "%U", &tmnow);
++fmt;
} else if(*fmt == 'm') { // Week-Of-Year Starts Monday
out += strftime(out, bufend-out, "%W", &tmnow);
++fmt;
} else if(*fmt == 'i') { // ISO-8601 week (1st version by henriko.se, 2nd by White-Tiger)
int wday,borderdays,week;
for(;;){
wday = (!tmnow.tm_wday?6:tmnow.tm_wday-1); // convert from Sun-Sat to Mon-Sun (0-5)
borderdays = (tmnow.tm_yday + 7 - wday) % 7; // +7 to prevent it from going negative
week = (tmnow.tm_yday + 6 - wday) / 7;
if(borderdays >= 4){ // year starts with at least 4 days
++week;
} else if(!week){ // we're still in last year's week
--tmnow.tm_year;
tmnow.tm_mon = 11;
tmnow.tm_mday = 31;
tmnow.tm_isdst = -1;
if(mktime(&tmnow)==-1){ // mktime magically updates tm_yday, tm_wday
week = 1;
break; // fail safe
}
tmnow.tm_mon = 0; // just to speed up the "if" below, since we know that it can't be week 1
continue; // repeat (once)
}
if(tmnow.tm_mon==11 && tmnow.tm_mday>=29){ // end of year, could be week 1
borderdays = 31 - tmnow.tm_mday + wday;
if(borderdays < 3)
week = 1;
}
break;
}
out += wsprintf(out,"%d",week);
++fmt;
} else if(*fmt == 'u') {
int week = 1 + (tmnow.tm_yday + 6 - tmnow.tm_wday) / 7;
out += wsprintf(out,"%d",week);
++fmt;
} else if(*fmt == 'w') { // SWN (Simple Week Number)
out += wsprintf(out,"%d",1 + tmnow.tm_yday / 7);
++fmt;
}
}
//================================================================================================
//======================================= JULIAN DATE Code ========================================
else if(*fmt == 'J' && *(fmt + 1) == 'D') {
double y, M, d, h, m, s, bc, JD;
struct tm Julian;
int id, is, i=0;
char* szJulian;
time_t UTC = time(NULL);
gmtime_r(&UTC, &Julian);
y = Julian.tm_year +1900; // Year
M = Julian.tm_mon +1; // Month
d = Julian.tm_mday; // Day
h = Julian.tm_hour; // Hours
m = Julian.tm_min; // Minutes
s = Julian.tm_sec; // Seconds
// This Handles the January 1, 4713 B.C up to
bc = 100.0 * y + M - 190002.5; // Year 0 Part.
JD = 367.0 * y;
JD -= floor(7.0*(y + floor((M+9.0)/12.0))/4.0);
JD += floor(275.0*M/9.0);
JD += d;
JD += (h + (m + s/60.0)/60.0)/24.0;
JD += 1721013.5; // BCE 2 November 18 00:00:00.0 UT - Tuesday
JD -= 0.5*bc/fabs(bc);
JD += 0.5;
szJulian = _fcvt(JD, 4, &id, &is); // Make it a String
while(*szJulian) {
if(i == id) { //--//-++-> id = Decimal Point Precision/Position
*out++ = '.'; // ReInsert the Decimal Point Where it Belongs.
} else {
*out++ = *szJulian++; //--+++--> Done!
}
i++;
}
fmt +=2;
}
//================================================================================================
//======================================= ORDINAL DATE Code =======================================
else if(*fmt == 'O' && *(fmt + 1) == 'D') { //--------+++--> Ordinal Date UTC:
char szOD[16] = {0};
struct tm today;
time_t UTC = time(NULL);
char* od;
gmtime_r(&UTC, &today);
strftime(szOD, 16, "%Y-%j", &today);
od = szOD;
while(*od) *out++ = *od++;
fmt +=2;
}
//==========================================================================
else if(*fmt == 'O' && *(fmt + 1) == 'd') { //------+++--> Ordinal Date Local:
char szOD[16] = {0};
struct tm today;
time_t ts = time(NULL);
char* od;
localtime_r(&ts, &today);
strftime(szOD, 16, "%Y-%j", &today);
od = szOD;
while(*od) *out++ = *od++;
fmt +=2;
}
//==========================================================================
else if(*fmt == 'D' && strncmp(fmt, "DOY", 3) == 0) { //--+++--> Day-Of-Year:
char szDoy[8] = {0};
struct tm today;
time_t ts = time(NULL);
char* doy;
localtime_r(&ts, &today);
strftime(szDoy, 8, "%j", &today);
doy = szDoy;
while(*doy) *out++ = *doy++;
fmt +=3;
}
//==========================================================================
else if(*fmt == 'P' && strncmp(fmt, "POSIX", 5) == 0) { //-> Posix/Unix Time:
char szPosix[16] = {0}; // This will Give the Number of Seconds That Have
char* posix; //--+++--> Elapsed Since the Unix Epoch: 1970-01-01 00:00:00
wsprintf(szPosix, "%ld", time(NULL));
posix = szPosix;
while(*posix) *out++ = *posix++;
fmt +=5;
}
//==========================================================================
else if(*fmt == 'T' && strncmp(fmt, "TZN", 3) == 0) { //--++-> TimeZone Name:
#ifndef __GNUC__ /* forces us to link with msvcr100 */
char szTZName[TZNAME_MAX] = {0};
size_t lRet;
char* tzn;
int iDST;
_get_daylight(&iDST);
if(iDST) {
_get_tzname(&lRet, szTZName, TZNAME_MAX, 1);
} else {
_get_tzname(&lRet, szTZName, TZNAME_MAX, 0);
}
tzn = szTZName;
while(*tzn) *out++ = *tzn++;
#endif
fmt +=3;
}
//=================================================================================================
else {
for(pos=CharNext(fmt); fmt!=pos; ) *out++=*fmt++;
}
}
*out='\0';
return (unsigned)(out-buf);
}
void CLibraryFrame::RunLocalSearch(CQuerySearch* pSearch)
{
CWaitCursor pCursor;
pSearch->BuildWordList( true, true );
CSingleLock oLock( &Library.m_pSection, TRUE );
CAlbumFolder* pRoot = Library.GetAlbumRoot();
if ( ! pRoot ) return;
CAlbumFolder* pFolder = pRoot->GetFolderByURI( CSchema::uriSearchFolder );
if ( pFolder == NULL )
{
pFolder = pRoot->AddFolder( CSchema::uriSearchFolder, L"Search Results" );
if ( pFolder->m_pSchema != NULL )
{
int nColon = pFolder->m_pSchema->m_sTitle.Find( L':' );
if ( nColon >= 0 )
pFolder->m_sName = pFolder->m_pSchema->m_sTitle.Mid( nColon + 1 );
}
}
else
{
// Get translated name of the default search folder
// We will clear it, not others as user may want to keep several folders
CString strFolderName;
int nColon = pFolder->m_pSchema->m_sTitle.Find( L':' );
if ( nColon >= 0 )
strFolderName = pFolder->m_pSchema->m_sTitle.Mid( nColon + 1 );
if ( ! strFolderName.IsEmpty() )
pFolder = pRoot->GetFolder( strFolderName );
if ( pFolder == NULL )
{
pFolder = pRoot->AddFolder( CSchema::uriSearchFolder, L"Search Results" );
if ( pFolder->m_pSchema != NULL && ! strFolderName.IsEmpty() )
pFolder->m_sName = strFolderName;
}
else
pFolder->Clear();
}
if ( pFolder->m_pSchema )
{
CString strDate, strTime;
SYSTEMTIME pTime;
GetLocalTime( &pTime );
GetDateFormat( LOCALE_USER_DEFAULT, 0, &pTime, L"yyyy-MM-dd", strDate.GetBuffer( 64 ), 64 );
GetTimeFormat( LOCALE_USER_DEFAULT, 0, &pTime, L"hh:mm tt", strTime.GetBuffer( 64 ), 64 );
strDate.ReleaseBuffer(); strTime.ReleaseBuffer();
CXMLElement* pOuter = pFolder->m_pSchema->Instantiate();
CXMLElement* pInner = pOuter->AddElement( L"searchFolder" );
pInner->AddAttribute( L"title", pFolder->m_sName );
pInner->AddAttribute( L"content", pSearch->m_sSearch );
pInner->AddAttribute( L"date", strDate );
pInner->AddAttribute( L"time", strTime );
pFolder->SetMetadata( pOuter );
delete pOuter;
}
if ( CFileList* pFiles = Library.Search( pSearch, 0, TRUE ) )
{
for ( POSITION pos = pFiles->GetHeadPosition(); pos; )
{
const CLibraryFile* pFile = pFiles->GetNext( pos );
if ( Settings.Search.SchemaTypes && pSearch->m_pSchema != NULL )
{
if ( ! pSearch->m_pSchema->FilterType( pFile->m_sName ) )
pFile = NULL;
}
if ( pFile != NULL && pFile->IsAvailable() )
pFolder->AddFile( const_cast< CLibraryFile* >( pFile ) );
}
delete pFiles;
}
oLock.Unlock();
Update();
Display( pFolder );
GetParent()->PostMessage( WM_COMMAND, ID_VIEW_LIBRARY );
}
///////////////////////////////////////////////////////////////////////////////////////////
// Function: NLSDlgProc
//
// Description: Message-processing function for text tab
//
// Comments:
//
///////////////////////////////////////////////////////////////////////////////////////////
INT_PTR CALLBACK NLSDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
BOOL bProcessedMsg = TRUE;
switch(uMsg)
{
case WM_INITDIALOG:
{
LVCOLUMN lvcCol = {0};
UINT lcid = 0;
LVFINDINFO lvInfo = {0};
int iItem = 0;
// load our own icon
SendMessage(GetParent(hDlg), WM_SETICON, ICON_BIG, (LPARAM) (LoadIcon(g_hInst, MAKEINTRESOURCE(IDI_MAINICON))));
// Create our list column for the listview control
g_hwndList = GetDlgItem(hDlg, IDC_LV_LCID);
g_hDlg = hDlg;
lvcCol.mask = LVCF_TEXT;
LoadString(g_hRes, STR_LANGID, g_tcsTemp, MAX_STR);
lvcCol.pszText = g_tcsTemp;
ListView_InsertColumn(g_hwndList, COLUMN_LANGID, (LV_COLUMN *)&lvcCol);
LoadString(g_hRes, STR_LANG, g_tcsTemp, MAX_STR);
lvcCol.pszText = g_tcsTemp;
ListView_InsertColumn(g_hwndList, COLUMN_LANGUAGE, (LV_COLUMN *)&lvcCol);
LoadString(g_hRes, STR_NLANG, g_tcsTemp, MAX_STR);
lvcCol.pszText = g_tcsTemp;
ListView_InsertColumn(g_hwndList, COLUMN_NATIVELANG, (LV_COLUMN *)&lvcCol);
LoadString(g_hRes, STR_NCOUNTRY, g_tcsTemp, MAX_STR);
lvcCol.pszText = g_tcsTemp;
ListView_InsertColumn(g_hwndList, COLUMN_NATIVECOUNTRYREGION, (LV_COLUMN *)&lvcCol);
LoadString(g_hRes, STR_ACP, g_tcsTemp, MAX_STR);
lvcCol.pszText = g_tcsTemp;
ListView_InsertColumn(g_hwndList, COLUMN_ACP, (LV_COLUMN *)&lvcCol);
LoadString(g_hRes, STR_OEMCP, g_tcsTemp, MAX_STR);
lvcCol.pszText = g_tcsTemp;
ListView_InsertColumn(g_hwndList, COLUMN_OEMCP, (LV_COLUMN *)&lvcCol);
// fill out our listview control with available locales (supported ones).
EnumSystemLocales(EnumLocalesProc, LCID_SUPPORTED);
// Initialize formatting fields related to the selected locale in the listview
InitNLSFields(hDlg, LOCALE_USER_DEFAULT);
// Set the column width of the listview control.
ListView_SetColumnWidth(g_hwndList, COLUMN_LANGID, LVSCW_AUTOSIZE_USEHEADER);
ListView_SetColumnWidth(g_hwndList, COLUMN_LANGUAGE, LVSCW_AUTOSIZE_USEHEADER);
ListView_SetColumnWidth(g_hwndList, COLUMN_NATIVELANG, LVSCW_AUTOSIZE_USEHEADER);
ListView_SetColumnWidth(g_hwndList, COLUMN_NATIVECOUNTRYREGION, LVSCW_AUTOSIZE_USEHEADER);
ListView_SetColumnWidth(g_hwndList, COLUMN_ACP, LVSCW_AUTOSIZE_USEHEADER);
ListView_SetColumnWidth(g_hwndList, COLUMN_OEMCP, LVSCW_AUTOSIZE_USEHEADER);
// Find user's current locale and select that item in the listview control.
lcid = GetUserDefaultLCID();
// Our list has all the LCIDs in 4 digits (0409) whereas GetUserDefaultLCID returs (409).
if (lcid < 0x1000)
{
_sntprintf(g_tcsTemp,MAX_STR,TEXT("0%x"), lcid);
}
else
{
_sntprintf(g_tcsTemp,MAX_STR,TEXT("%x"), lcid);
}
lvInfo.flags = LVFI_STRING;
lvInfo.psz = g_tcsTemp;
iItem = ListView_FindItem(g_hwndList, 0, &lvInfo);
ListView_SetItemState (g_hwndList, iItem, LVIS_FOCUSED | LVIS_SELECTED, 0x000F);
ListView_EnsureVisible(g_hwndList, iItem, FALSE);
// Set some of the extended styles of our list view (cool reports ;-)
ListView_SetExtendedListViewStyle(g_hwndList, LVS_EX_FULLROWSELECT | LVS_EX_HEADERDRAGDROP | LVS_EX_GRIDLINES | LVS_EX_TWOCLICKACTIVATE);
}
break;
case WM_NOTIFY:
switch (((NMHDR *)lParam)->code)
{
case LVN_COLUMNCLICK:
{
NM_LISTVIEW nmv;
static int iLastSort = COLUMN_LANGID;
LPARAM lSortParam = -1;
LVFINDINFO lvInfo;
int iItem;
// When a column is clicked we need to redo our sorting of preview table.
nmv = *(const NM_LISTVIEW *) lParam;
// We don't sort for native language and native country name (avoid confusion).
if ((nmv.iSubItem == COLUMN_NATIVELANG) || (nmv.iSubItem == COLUMN_NATIVECOUNTRYREGION))
{
break;
}
// If our last sorting was on a different column, we need to do more
// than simply reverting our sorting.
// Because of listview sorting limitations, we need to redo our list...
if (iLastSort != nmv.iSubItem)
{
// The list view sorting is based on a q-sort, we need to redo our list!
ListView_DeleteAllItems(g_hwndList);
g_iCounter = 0;
EnumSystemLocales(EnumLocalesProc, LCID_SUPPORTED);
// Make sure the last selection remains active after sorting...
if (g_iCurLocale < 0x1000)
{
_sntprintf(g_tcsTemp,MAX_STR,TEXT("0%x"), g_iCurLocale);
}
else
{
_sntprintf(g_tcsTemp,MAX_STR,TEXT("%x"), g_iCurLocale);
}
lvInfo.flags = LVFI_STRING;
lvInfo.psz = g_tcsTemp;
iItem = ListView_FindItem(g_hwndList, 0, &lvInfo);
ListView_SetItemState (g_hwndList, iItem, LVIS_FOCUSED | LVIS_SELECTED, 0x000F);
// Update our flag for the last column sorted and set the sorting flag
iLastSort = nmv.iSubItem;
lSortParam = iLastSort;
}
// Do the actual sorting...
ListView_SortItems(g_hwndList, (PFNLVCOMPARE)CompareFunc, lSortParam);
// Make sure our selection is visible after the sorting!
ListView_EnsureVisible(g_hwndList, ListView_GetSelectionMark(g_hwndList), FALSE);
}
break;
case LVN_ITEMCHANGED: /* fall-through */
case LVN_ITEMACTIVATE:
{
LPNM_LISTVIEW lpnmlv = (LPNM_LISTVIEW)lParam;
static int iItem;
LVITEM lvItem = {0};
// Item selection has been changed.
// Find the new langId and update our formatting fields...
if (iItem != lpnmlv->iItem)
{
iItem = lpnmlv->iItem;
lvItem.mask = LVIF_TEXT;
lvItem.iItem = iItem;
lvItem.pszText = g_tcsTemp;
lvItem.cchTextMax = STR_LEN;
ListView_GetItem(g_hwndList, &lvItem);
g_iCurLocale = iConvertStrToInt(lvItem.pszText);
InitNLSFields(hDlg, g_iCurLocale);
}
// Show advanced data on the selected locale...
if (((NMHDR *)lParam)->code == LVN_ITEMACTIVATE)
{
bProcessedMsg = (DialogBox(g_hRes, MAKEINTRESOURCE(DLG_LCID), hDlg, LcidDlgProc) != -1);
}
}
break;
}
break;
case WM_COMMAND:
switch(LOWORD(wParam))
{
case IDCANCEL: /* fall-through*/
case IDOK:
break;
case IDC_TIMEFORMAT:
{
if(HIWORD(wParam) == CBN_SELCHANGE)
{
// Time formating selection has been changed.
// Re-edit time
HWND hList = NULL;
LRESULT index = 0;
TCHAR tcTemp[MAX_STR];
hList = GetDlgItem(hDlg, IDC_TIMEFORMAT);
if(NULL == hList)
{
bProcessedMsg = FALSE;
break;
}
index = SendMessage(hList, CB_GETCURSEL, 0, 0);
SendMessage(hList, CB_GETLBTEXT, index, (LPARAM) g_tcsTemp);
GetTimeFormat(g_iCurLocale, 0, NULL, g_tcsTemp, tcTemp, MAX_STR);
SetWindowText(GetDlgItem(hDlg, IDC_TIMESAMPLE), tcTemp);
}
}
break;
case IDC_SDATEFORMAT:
{
if(HIWORD(wParam) == CBN_SELCHANGE)
{
// short date formating selection has been changed.
// Re-edit short date
HWND hList = NULL;
LRESULT index = 0;
TCHAR tcTemp[MAX_STR];
hList = GetDlgItem(hDlg, IDC_SDATEFORMAT);
if(NULL == hList)
{
bProcessedMsg = FALSE;
break;
}
index = SendMessage(hList, CB_GETCURSEL, 0, 0);
SendMessage(hList, CB_GETLBTEXT, index, (LPARAM) g_tcsTemp);
GetDateFormat(g_iCurLocale, 0, NULL, g_tcsTemp, tcTemp, MAX_STR);
SetWindowText(GetDlgItem(hDlg, IDC_SDATESAMPLE), tcTemp);
}
}
break;
case IDC_LDATEFORMAT:
{
if(HIWORD(wParam) == CBN_SELCHANGE)
{
// long date formating selection has been changed.
// Re-edit long date
HWND hList = NULL;
LRESULT index = 0;
TCHAR tcTemp[MAX_STR];
hList = GetDlgItem(hDlg, IDC_LDATEFORMAT);
if(NULL == hList)
{
bProcessedMsg = FALSE;
break;
}
index = SendMessage(hList, CB_GETCURSEL, 0, 0);
SendMessage(hList, CB_GETLBTEXT, index, (LPARAM) g_tcsTemp);
GetDateFormat(g_iCurLocale, 0, NULL, g_tcsTemp, tcTemp, MAX_STR);
SetWindowText(GetDlgItem(hDlg, IDC_LDATESAMPLE), tcTemp);
}
}
break;
}
break;
default:
bProcessedMsg = FALSE;
}
return bProcessedMsg;
}
void
log_vmsg(int pri, const char* type,
const char *format, va_list args)
{
char message[MAXSYSLOGMSGLEN];
unsigned int* tid = (unsigned int*)ub_thread_key_get(logkey);
time_t now;
#if defined(HAVE_STRFTIME) && defined(HAVE_LOCALTIME_R)
char tmbuf[32];
struct tm tm;
#elif defined(UB_ON_WINDOWS)
char tmbuf[128], dtbuf[128];
#endif
(void)pri;
vsnprintf(message, sizeof(message), format, args);
#ifdef HAVE_SYSLOG_H
if(logging_to_syslog) {
syslog(pri, "[%d:%x] %s: %s",
(int)getpid(), tid?*tid:0, type, message);
return;
}
#elif defined(UB_ON_WINDOWS)
if(logging_to_syslog) {
char m[32768];
HANDLE* s;
LPCTSTR str = m;
DWORD tp = MSG_GENERIC_ERR;
WORD wt = EVENTLOG_ERROR_TYPE;
if(strcmp(type, "info") == 0) {
tp=MSG_GENERIC_INFO;
wt=EVENTLOG_INFORMATION_TYPE;
} else if(strcmp(type, "warning") == 0) {
tp=MSG_GENERIC_WARN;
wt=EVENTLOG_WARNING_TYPE;
} else if(strcmp(type, "notice") == 0
|| strcmp(type, "debug") == 0) {
tp=MSG_GENERIC_SUCCESS;
wt=EVENTLOG_SUCCESS;
}
snprintf(m, sizeof(m), "[%s:%x] %s: %s",
ident, tid?*tid:0, type, message);
s = RegisterEventSource(NULL, SERVICE_NAME);
if(!s) return;
ReportEvent(s, wt, 0, tp, NULL, 1, 0, &str, NULL);
DeregisterEventSource(s);
return;
}
#endif /* HAVE_SYSLOG_H */
if(!logfile) return;
if(log_now)
now = (time_t)*log_now;
else now = (time_t)time(NULL);
#if defined(HAVE_STRFTIME) && defined(HAVE_LOCALTIME_R)
if(log_time_asc && strftime(tmbuf, sizeof(tmbuf), "%b %d %H:%M:%S",
localtime_r(&now, &tm))%(sizeof(tmbuf)) != 0) {
/* %sizeof buf!=0 because old strftime returned max on error */
fprintf(logfile, "%s %s[%d:%x] %s: %s\n", tmbuf,
ident, (int)getpid(), tid?*tid:0, type, message);
} else
#elif defined(UB_ON_WINDOWS)
if(log_time_asc && GetTimeFormat(LOCALE_USER_DEFAULT, 0, NULL, NULL,
tmbuf, sizeof(tmbuf)) && GetDateFormat(LOCALE_USER_DEFAULT, 0,
NULL, NULL, dtbuf, sizeof(dtbuf))) {
fprintf(logfile, "%s %s %s[%d:%x] %s: %s\n", dtbuf, tmbuf,
ident, (int)getpid(), tid?*tid:0, type, message);
} else
#endif
fprintf(logfile, "[" ARG_LL "d] %s[%d:%x] %s: %s\n", (long long)now,
ident, (int)getpid(), tid?*tid:0, type, message);
#ifdef UB_ON_WINDOWS
/* line buffering does not work on windows */
fflush(logfile);
#endif
}
///////////////////////////////////////////////////////////////////////////////////////////
// Function: InitNLSFields
//
// Description: Initialize NLS formatting fields for a given LCID
//
// Comments:
//
///////////////////////////////////////////////////////////////////////////////////////////
void InitNLSFields(HWND hDlg, LCID lcid)
{
TCHAR tcsTemp[MAX_STR];
HWND hList = NULL;
// Init larg number fields...
LoadString(g_hInst, STR_LARGEPOSNUMBER, g_tcsTemp, MAX_STR);
GetNumberFormat(lcid, 0, g_tcsTemp, NULL, tcsTemp, MAX_STR);
SetWindowText(GetDlgItem(hDlg, IDC_POS_NUMBER), tcsTemp);
LoadString(g_hInst, STR_LARGENEGNUMBER, g_tcsTemp, MAX_STR);
GetNumberFormat(lcid, 0, g_tcsTemp, NULL, tcsTemp, MAX_STR);
SetWindowText(GetDlgItem(hDlg, IDC_NEG_NUMBER), tcsTemp);
// Init the currency field format...
LoadString(g_hInst, STR_LARGEPOSNUMBER, g_tcsTemp, MAX_STR);
GetCurrencyFormat(lcid, 0, g_tcsTemp, NULL, tcsTemp, MAX_STR);
SetWindowText(GetDlgItem(hDlg, IDC_POS_CURRENCY), tcsTemp);
LoadString(g_hInst, STR_LARGENEGNUMBER, g_tcsTemp, MAX_STR);
GetCurrencyFormat(lcid, 0, g_tcsTemp, NULL, tcsTemp, MAX_STR);
SetWindowText(GetDlgItem(hDlg, IDC_NEG_CURRENCY), tcsTemp);
// Init time field format...
// Delete our previous list of items...
hList = GetDlgItem(g_hDlg, IDC_TIMEFORMAT);
if(NULL != hList)
{
SendMessage(hList, CB_RESETCONTENT , 0, 0);
// Enumerates the time formats that are available for a specified locale.
EnumTimeFormats(EnumTimeFormatsProc, lcid, 0);
SendMessage(hList, CB_SETCURSEL, 0, 0); // item index
SendMessage(hList, CB_GETLBTEXT, 0, (LPARAM) g_tcsTemp);
GetTimeFormat(lcid, 0, NULL, g_tcsTemp, tcsTemp, MAX_STR);
SetWindowText(GetDlgItem(hDlg, IDC_TIMESAMPLE), tcsTemp);
}
// Init calendar field format...
// Delete our previous list of items...
hList = GetDlgItem(g_hDlg, IDC_CALFORMAT);
if(NULL != hList)
{
SendMessage(hList, CB_RESETCONTENT , 0, 0);
// Enumerates the short date formats that are available for a specified locale.
EnumCalendarInfo(EnumCalendarInfoProc, lcid, ENUM_ALL_CALENDARS, CAL_SCALNAME);
SendMessage(hList, CB_SETCURSEL, 0, 0); // item index
SendMessage(hList, CB_GETLBTEXT, 0, (LPARAM) g_tcsTemp);
}
// Init short date field format...
// Delete our previous list of items...
hList = GetDlgItem(g_hDlg, IDC_SDATEFORMAT);
if(NULL != hList)
{
SendMessage(hList, CB_RESETCONTENT , 0, 0);
// Enumerates the short date formats that are available for a specified locale.
EnumDateFormats(EnumSDateFormatsProc, lcid, DATE_SHORTDATE);
SendMessage(hList, CB_SETCURSEL, 0, 0); // item index
SendMessage(hList, CB_GETLBTEXT, 0, (LPARAM) g_tcsTemp);
GetDateFormat(lcid, 0, NULL, g_tcsTemp, tcsTemp, MAX_STR);
SetWindowText(GetDlgItem(hDlg, IDC_SDATESAMPLE), tcsTemp);
}
// Init long date field format...
// Delete our previous list of items...
hList = GetDlgItem(g_hDlg, IDC_LDATEFORMAT);
if(NULL != hList)
{
SendMessage(hList, CB_RESETCONTENT , 0, 0);
// Enumerates the long date formats that are available for a specified locale
EnumDateFormats(EnumLDateFormatsProc, lcid, DATE_LONGDATE);
SendMessage(hList, CB_SETCURSEL, 0, 0); // item index
SendMessage(hList, CB_GETLBTEXT, 0, (LPARAM) g_tcsTemp);
GetDateFormat(lcid, 0, NULL, g_tcsTemp, tcsTemp, MAX_STR);
SetWindowText(GetDlgItem(hDlg, IDC_LDATESAMPLE), tcsTemp);
}
}
INT_PTR srvVariablesHandler(WPARAM, LPARAM lParam)
{
ARGUMENTSINFO *ai = (ARGUMENTSINFO*)lParam;
ai->flags = AIF_DONTPARSE;
TCString Result;
if (!mir_tstrcmp(ai->targv[0], VAR_AWAYSINCE_TIME)) {
GetTimeFormat(LOCALE_USER_DEFAULT, 0, g_ProtoStates[VarParseData.szProto].AwaySince, (ai->argc > 1 && *ai->targv[1]) ? ai->targv[1] : _T("H:mm"), Result.GetBuffer(256), 256);
Result.ReleaseBuffer();
}
else if (!mir_tstrcmp(ai->targv[0], VAR_AWAYSINCE_DATE)) {
GetDateFormat(LOCALE_USER_DEFAULT, 0, g_ProtoStates[VarParseData.szProto].AwaySince, (ai->argc > 1 && *ai->targv[1]) ? ai->targv[1] : NULL, Result.GetBuffer(256), 256);
Result.ReleaseBuffer();
}
else if (!mir_tstrcmp(ai->targv[0], VAR_STATDESC)) {
Result = (VarParseData.Flags & VPF_XSTATUS) ? STR_XSTATUSDESC : pcli->pfnGetStatusModeDescription(g_ProtoStates[VarParseData.szProto].Status, 0);
}
else if (!mir_tstrcmp(ai->targv[0], VAR_MYNICK)) {
if (g_MoreOptPage.GetDBValueCopy(IDC_MOREOPTDLG_MYNICKPERPROTO) && VarParseData.szProto)
Result = db_get_s(NULL, VarParseData.szProto, "Nick", (TCHAR*)NULL);
if (Result == NULL)
Result = pcli->pfnGetContactDisplayName(NULL, 0);
if (Result == NULL)
Result = TranslateT("Stranger");
}
else if (!mir_tstrcmp(ai->targv[0], VAR_REQUESTCOUNT)) {
mir_sntprintf(Result.GetBuffer(16), 16, _T("%d"), db_get_w(ai->fi->hContact, MOD_NAME, DB_REQUESTCOUNT, 0));
Result.ReleaseBuffer();
}
else if (!mir_tstrcmp(ai->targv[0], VAR_MESSAGENUM)) {
mir_sntprintf(Result.GetBuffer(16), 16, _T("%d"), db_get_w(ai->fi->hContact, MOD_NAME, DB_MESSAGECOUNT, 0));
Result.ReleaseBuffer();
}
else if (!mir_tstrcmp(ai->targv[0], VAR_TIMEPASSED)) {
ULARGE_INTEGER ul_AwaySince, ul_Now;
SYSTEMTIME st;
GetLocalTime(&st);
SystemTimeToFileTime(&st, (LPFILETIME)&ul_Now);
SystemTimeToFileTime(g_ProtoStates[VarParseData.szProto].AwaySince, (LPFILETIME)&ul_AwaySince);
ul_Now.QuadPart -= ul_AwaySince.QuadPart;
ul_Now.QuadPart /= 10000000; // now it's in seconds
Result.GetBuffer(256);
if (ul_Now.LowPart >= 7200) // more than 2 hours
mir_sntprintf(Result, 256, TranslateT("%d hours"), ul_Now.LowPart / 3600);
else if (ul_Now.LowPart >= 120) // more than 2 minutes
mir_sntprintf(Result, 256, TranslateT("%d minutes"), ul_Now.LowPart / 60);
else
mir_sntprintf(Result, 256, TranslateT("%d seconds"), ul_Now.LowPart);
Result.ReleaseBuffer();
}
else if (!mir_tstrcmp(ai->targv[0], VAR_PREDEFINEDMESSAGE)) {
ai->flags = 0; // reset AIF_DONTPARSE flag
if (ai->argc != 2)
return NULL;
COptPage MsgTreeData(g_MsgTreePage);
COptItem_TreeCtrl *TreeCtrl = (COptItem_TreeCtrl*)MsgTreeData.Find(IDV_MSGTREE);
TreeCtrl->DBToMem(CString(MOD_NAME));
for (int i = 0; i < TreeCtrl->Value.GetSize(); i++) {
if (!(TreeCtrl->Value[i].Flags & TIF_GROUP) && !mir_tstrcmpi(TreeCtrl->Value[i].Title, ai->targv[1])) {
Result = TreeCtrl->Value[i].User_Str1;
break;
}
}
if (Result == NULL) // if we didn't find a message with specified title
return NULL; // return it now, as later we change NULL to ""
}
else if (!mir_tstrcmp(ai->targv[0], VAR_PROTOCOL)) {
if (VarParseData.szProto) {
CString AnsiResult;
CallProtoService(VarParseData.szProto, PS_GETNAME, 256, (LPARAM)AnsiResult.GetBuffer(256));
AnsiResult.ReleaseBuffer();
Result = _A2T(AnsiResult);
}
if (Result == NULL) // if we didn't find a message with specified title
return NULL; // return it now, as later we change NULL to ""
}
TCHAR *szResult = (TCHAR*)malloc((Result.GetLen() + 1) * sizeof(TCHAR));
if (!szResult)
return NULL;
mir_tstrcpy(szResult, (Result != NULL) ? Result : _T(""));
return (INT_PTR)szResult;
}
WORD
TZF_Timestamp (wchar_t* const out)
{
SYSTEMTIME stLogTime;
#if 0
// Check for Windows 8 / Server 2012
static bool __hasSystemTimePrecise =
(LOBYTE (LOWORD (GetVersion ())) == 6 &&
HIBYTE (LOWORD (GetVersion ())) >= 2) ||
LOBYTE (LOWORD (GetVersion () > 6));
// More accurate timestamp is available on Windows 6.2+
if (__hasSystemTimePrecise) {
FILETIME ftLogTime;
GetSystemTimePreciseAsFileTime (&ftLogTime);
FileTimeToSystemTime (&ftLogTime, &stLogTime);
} else {
#else
GetLocalTime (&stLogTime);
#endif
//}
wchar_t date [64] = { L'\0' };
wchar_t time [64] = { L'\0' };
GetDateFormat (LOCALE_INVARIANT,DATE_SHORTDATE, &stLogTime,NULL,date,64);
GetTimeFormat (LOCALE_INVARIANT,TIME_NOTIMEMARKER,&stLogTime,NULL,time,64);
out [0] = L'\0';
lstrcatW (out, date);
lstrcatW (out, L" ");
lstrcatW (out, time);
lstrcatW (out, L".");
return stLogTime.wMilliseconds;
}
tzf_logger_t dll_log;
void
tzf_logger_t::close (void)
{
if (fLog != NULL) {
fflush (fLog);
fclose (fLog);
}
initialized = false;
silent = true;
DeleteCriticalSection (&log_mutex);
}
bool
tzf_logger_t::init (const char* const szFileName,
const char* const szMode)
{
if (initialized)
return true;
//
// Split the path, so we can create the log directory if necessary
//
if (strstr (szFileName, "\\")) {
char* szSplitPath = strdup (szFileName);
// Replace all instances of '/' with '\'
size_t len = strlen (szSplitPath);
for (size_t i = 0; i < len; i++) {
if (szSplitPath [i] == '/')
szSplitPath [i] = '\\';
}
char* szSplitter = strrchr (szSplitPath, '\\');
*szSplitter = '\0';
char path [MAX_PATH] = { '\0' };
char* subpath = strtok (szSplitPath, "\\");
// For each subdirectory, create it...
while (subpath != nullptr) {
strcat (path, subpath);
CreateDirectoryA (path, NULL);
strcat (path, "\\");
subpath = strtok (NULL, "\\");
}
free (szSplitPath);
}
fLog = fopen (szFileName, szMode);
BOOL bRet = InitializeCriticalSectionAndSpinCount (&log_mutex, 2500);
if ((! bRet) || (fLog == NULL)) {
silent = true;
return false;
}
initialized = true;
return initialized;
}
void
tzf_logger_t::LogEx (bool _Timestamp,
_In_z_ _Printf_format_string_
wchar_t const* const _Format, ...)
{
va_list _ArgList;
if (! initialized)
return;
EnterCriticalSection (&log_mutex);
if ((! fLog) || silent) {
LeaveCriticalSection (&log_mutex);
return;
}
if (_Timestamp) {
wchar_t wszLogTime [128];
WORD ms = TZF_Timestamp (wszLogTime);
fwprintf (fLog, L"%s%03u: ", wszLogTime, ms);
}
va_start (_ArgList, _Format);
{
vfwprintf (fLog, _Format, _ArgList);
}
va_end (_ArgList);
fflush (fLog);
LeaveCriticalSection (&log_mutex);
}
PTSTR Expand(PTSTR ptzDst, TCHAR tMacro, CXT& XT)
{
INT i;
switch (tMacro)
{
case 'E':
for (PCTSTR p = XT.ptzFile; *p; *ptzDst++ = *p++);
return ptzDst;
case 'C':
if (PCTSTR q = UStrRChr(XT.ptzFile, '\\'))
{
for (PCTSTR p = XT.ptzFile; p < q; *ptzDst++ = *p++);
}
return ptzDst;
case 'T':
ptzDst += GetTimeFormat(LOCALE_USER_DEFAULT, 0, NULL, NULL, ptzDst, MAX_NAME) - 1;
return ptzDst;
case 'D':
ptzDst += GetDateFormat(LOCALE_USER_DEFAULT, 0, NULL, NULL, ptzDst, MAX_NAME) - 1;
return ptzDst;
case 'X':
case 'x':
ptzDst += UStrPrint(ptzDst, (tMacro == 'X') ? TEXT("%#X") : TEXT("%d"), XT.hXVar);
return ptzDst;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
for (PTSTR p = g_tzXVar[tMacro - '0']; *p; p++) *ptzDst++ = *p;
return ptzDst;
case 'A': i = CSIDL_APPDATA; break;
case 'Y': i = CSIDL_MYDOCUMENTS; break;
case 'S': i = CSIDL_STARTUP; break;
case 'M': i = CSIDL_STARTMENU; break;
case 'P': i = CSIDL_PROGRAMS; break;
case 'V': i = CSIDL_FAVORITES; break;
case 'Z': i = CSIDL_MYPICTURES; break;
case 'U': i = CSIDL_MYMUSIC; break;
case 'I': i = CSIDL_MYVIDEO; break;
case 'F': i = CSIDL_PROGRAM_FILES; break;
case 'O': i = CSIDL_SENDTO; break;
case 'o': i = CSIDL_DESKTOPDIRECTORY; break;
case 'd': i = CSIDL_COMMON_DESKTOPDIRECTORY; break;
case 'a': i = CSIDL_COMMON_APPDATA; break;
case 'y': i = CSIDL_COMMON_DOCUMENTS; break;
case 's': i = CSIDL_COMMON_STARTUP; break;
case 'm': i = CSIDL_COMMON_STARTMENU; break;
case 'p': i = CSIDL_COMMON_PROGRAMS; break;
case 'v': i = CSIDL_COMMON_FAVORITES; break;
case 'z': i = CSIDL_COMMON_PICTURES; break;
case 'u': i = CSIDL_COMMON_MUSIC; break;
case 'i': i = CSIDL_COMMON_VIDEO; break;
case 'f': i = CSIDL_PROGRAM_FILES_COMMON; break;
case 'W': case 'w': i = CSIDL_WINDOWS; break;
case 'R': *ptzDst++ = '\r'; return ptzDst;
case 'N': *ptzDst++ = '\n'; return ptzDst;
default: *ptzDst++ = tMacro; return ptzDst;
}
SHGetSpecialFolderPath(NULL, ptzDst, i, TRUE);
ptzDst += UStrLen(ptzDst);
return ptzDst;
}
static void write_log(int log_action, const char* buff)
{
/******************************************************************************
*
* w r i t e _ l o g
*
******************************************************************************
*
* Description: Writes the guardian information to either the Windows 95
* property sheet structure (log_entry) or to the Windows NT
* Event Log
*****************************************************************************/
const size_t BUFF_SIZE = 512;
char tmp_buff[BUFF_SIZE];
// Move to the end of the log_entry list
log_info* log_temp = log_entry;
while (log_temp->next)
log_temp = log_temp->next;
log_info* tmp = static_cast<log_info*>(malloc(sizeof(log_info)));
memset(tmp, 0, sizeof(log_info));
#ifdef NOT_USED_OR_REPLACED
time_t ltime;
time(<ime);
const tm* today = localtime(<ime);
sprintf(tmp->log_time, "%02d:%02d", today->tm_hour, today->tm_min);
sprintf(tmp->log_date, "%02d/%02d/%02d", today->tm_mon + 1, today->tm_mday, today->tm_year % 100);
#else
// TMN: Fixed this after bug-report. Should it really force
// 24hr format in e.g US, where they use AM/PM wharts?
GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS | TIME_FORCE24HOURFORMAT, NULL, NULL,
tmp->log_time, sizeof(tmp->log_time));
GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, NULL, NULL,
tmp->log_date, sizeof(tmp->log_date));
#endif
if (log_action >= IDS_LOG_START && log_action <= IDS_LOG_TERM)
{
// Only Windows 95 needs this information since it goes in the property sheet
LoadString(hInstance_gbl, log_action, tmp_buff, sizeof(tmp->log_action));
sprintf(tmp->log_action, "%s", tmp_buff);
tmp->next = NULL;
log_temp->next = tmp;
}
if (service_flag)
{
// on NT
HANDLE hLog = RegisterEventSource(NULL, service_name->c_str());
if (!hLog)
gds__log("Error opening Windows NT Event Log");
else
{
char buffer[BUFF_SIZE];
char* act_buff[1];
act_buff[0] = buffer;
LoadString(hInstance_gbl, log_action + 1, tmp_buff, sizeof(tmp_buff));
sprintf(act_buff[0], "%s", buff);
LPTSTR lpMsgBuf;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_ARGUMENT_ARRAY |
FORMAT_MESSAGE_FROM_STRING,
tmp_buff, 0, 0, (LPTSTR) &lpMsgBuf, 0,
reinterpret_cast<va_list*>(act_buff));
const int len = MIN(BUFF_SIZE - 1, strlen(lpMsgBuf) - 1);
strncpy(act_buff[0], lpMsgBuf, len);
act_buff[0][len] = 0;
LocalFree(lpMsgBuf);
WORD wLogType;
switch (log_action)
{
case IDS_LOG_START:
case IDS_LOG_STOP:
wLogType = EVENTLOG_INFORMATION_TYPE;
break;
default:
wLogType = EVENTLOG_ERROR_TYPE;
}
if (!ReportEvent
(hLog, wLogType, 0, log_action + 1, NULL, 1, 0,
const_cast<const char**>(act_buff), NULL))
{
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
(LPTSTR) & lpMsgBuf, 0, NULL);
gds__log("Unable to update NT Event Log.\n\tOS Message: %s", lpMsgBuf);
LocalFree(lpMsgBuf);
}
DeregisterEventSource(hLog);
}
}
// Write to the Firebird log
if (*buff)
gds__log(buff);
}
/****************************************************************************
* WCMD_HandleTildaModifiers
*
* Handle the ~ modifiers when expanding %0-9 or (%a-z in for command)
* %~xxxxxV (V=0-9 or A-Z)
* Where xxxx is any combination of:
* ~ - Removes quotes
* f - Fully qualified path (assumes current dir if not drive\dir)
* d - drive letter
* p - path
* n - filename
* x - file extension
* s - path with shortnames
* a - attributes
* t - date/time
* z - size
* $ENVVAR: - Searches ENVVAR for (contents of V) and expands to fully
* qualified path
*
* To work out the length of the modifier:
*
* Note: In the case of %0-9 knowing the end of the modifier is easy,
* but in a for loop, the for end WCHARacter may also be a modifier
* eg. for %a in (c:\a.a) do echo XXX
* where XXX = %~a (just ~)
* %~aa (~ and attributes)
* %~aaxa (~, attributes and extension)
* BUT %~aax (~ and attributes followed by 'x')
*
* Hence search forwards until find an invalid modifier, and then
* backwards until find for variable or 0-9
*/
void WCMD_HandleTildaModifiers(WCHAR **start, WCHAR *forVariable, WCHAR *forValue, BOOL justFors) {
#define NUMMODIFIERS 11
static const WCHAR validmodifiers[NUMMODIFIERS] = {
'~', 'f', 'd', 'p', 'n', 'x', 's', 'a', 't', 'z', '$'
};
static const WCHAR space[] = {' ', '\0'};
WIN32_FILE_ATTRIBUTE_DATA fileInfo;
WCHAR outputparam[MAX_PATH];
WCHAR finaloutput[MAX_PATH];
WCHAR fullfilename[MAX_PATH];
WCHAR thisoutput[MAX_PATH];
WCHAR *pos = *start+1;
WCHAR *firstModifier = pos;
WCHAR *lastModifier = NULL;
int modifierLen = 0;
BOOL finished = FALSE;
int i = 0;
BOOL exists = TRUE;
BOOL skipFileParsing = FALSE;
BOOL doneModifier = FALSE;
/* Search forwards until find invalid character modifier */
while (!finished) {
/* Work on the previous character */
if (lastModifier != NULL) {
for (i=0; i<NUMMODIFIERS; i++) {
if (validmodifiers[i] == *lastModifier) {
/* Special case '$' to skip until : found */
if (*lastModifier == '$') {
while (*pos != ':' && *pos) pos++;
if (*pos == 0x00) return; /* Invalid syntax */
pos++; /* Skip ':' */
}
break;
}
}
if (i==NUMMODIFIERS) {
finished = TRUE;
}
}
/* Save this one away */
if (!finished) {
lastModifier = pos;
pos++;
}
}
while (lastModifier > firstModifier) {
WINE_TRACE("Looking backwards for parameter id: %s / %s\n",
wine_dbgstr_w(lastModifier), wine_dbgstr_w(forVariable));
if (!justFors && context && (*lastModifier >= '0' || *lastModifier <= '9')) {
/* Its a valid parameter identifier - OK */
break;
} else if (forVariable && *lastModifier == *(forVariable+1)) {
/* Its a valid parameter identifier - OK */
break;
} else {
lastModifier--;
}
}
if (lastModifier == firstModifier) return; /* Invalid syntax */
/* Extract the parameter to play with */
if ((*lastModifier >= '0' && *lastModifier <= '9')) {
strcpyW(outputparam, WCMD_parameter (context -> command,
*lastModifier-'0' + context -> shift_count[*lastModifier-'0'], NULL));
} else {
strcpyW(outputparam, forValue);
}
/* So now, firstModifier points to beginning of modifiers, lastModifier
points to the variable just after the modifiers. Process modifiers
in a specific order, remembering there could be duplicates */
modifierLen = lastModifier - firstModifier;
finaloutput[0] = 0x00;
/* Useful for debugging purposes: */
/*printf("Modifier string '%*.*s' and variable is %c\n Param starts as '%s'\n",
(modifierLen), (modifierLen), firstModifier, *lastModifier,
outputparam);*/
/* 1. Handle '~' : Strip surrounding quotes */
if (outputparam[0]=='"' &&
memchrW(firstModifier, '~', modifierLen) != NULL) {
int len = strlenW(outputparam);
if (outputparam[len-1] == '"') {
outputparam[len-1]=0x00;
len = len - 1;
}
memmove(outputparam, &outputparam[1], (len * sizeof(WCHAR))-1);
}
/* 2. Handle the special case of a $ */
if (memchrW(firstModifier, '$', modifierLen) != NULL) {
/* Special Case: Search envar specified in $[envvar] for outputparam
Note both $ and : are guaranteed otherwise check above would fail */
WCHAR *start = strchrW(firstModifier, '$') + 1;
WCHAR *end = strchrW(firstModifier, ':');
WCHAR env[MAX_PATH];
WCHAR fullpath[MAX_PATH];
/* Extract the env var */
memcpy(env, start, (end-start) * sizeof(WCHAR));
env[(end-start)] = 0x00;
/* If env var not found, return empty string */
if ((GetEnvironmentVariable(env, fullpath, MAX_PATH) == 0) ||
(SearchPath(fullpath, outputparam, NULL,
MAX_PATH, outputparam, NULL) == 0)) {
finaloutput[0] = 0x00;
outputparam[0] = 0x00;
skipFileParsing = TRUE;
}
}
/* After this, we need full information on the file,
which is valid not to exist. */
if (!skipFileParsing) {
if (GetFullPathName(outputparam, MAX_PATH, fullfilename, NULL) == 0)
return;
exists = GetFileAttributesExW(fullfilename, GetFileExInfoStandard,
&fileInfo);
/* 2. Handle 'a' : Output attributes */
if (exists &&
memchrW(firstModifier, 'a', modifierLen) != NULL) {
WCHAR defaults[] = {'-','-','-','-','-','-','-','-','-','\0'};
doneModifier = TRUE;
strcpyW(thisoutput, defaults);
if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
thisoutput[0]='d';
if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
thisoutput[1]='r';
if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE)
thisoutput[2]='a';
if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)
thisoutput[3]='h';
if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM)
thisoutput[4]='s';
if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED)
thisoutput[5]='c';
/* FIXME: What are 6 and 7? */
if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
thisoutput[8]='l';
strcatW(finaloutput, thisoutput);
}
/* 3. Handle 't' : Date+time */
if (exists &&
memchrW(firstModifier, 't', modifierLen) != NULL) {
SYSTEMTIME systime;
int datelen;
doneModifier = TRUE;
if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
/* Format the time */
FileTimeToSystemTime(&fileInfo.ftLastWriteTime, &systime);
GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &systime,
NULL, thisoutput, MAX_PATH);
strcatW(thisoutput, space);
datelen = strlenW(thisoutput);
GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &systime,
NULL, (thisoutput+datelen), MAX_PATH-datelen);
strcatW(finaloutput, thisoutput);
}
/* 4. Handle 'z' : File length */
if (exists &&
memchrW(firstModifier, 'z', modifierLen) != NULL) {
/* FIXME: Output full 64 bit size (sprintf does not support I64 here) */
ULONG/*64*/ fullsize = /*(fileInfo.nFileSizeHigh << 32) +*/
fileInfo.nFileSizeLow;
static const WCHAR fmt[] = {'%','u','\0'};
doneModifier = TRUE;
if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
wsprintf(thisoutput, fmt, fullsize);
strcatW(finaloutput, thisoutput);
}
/* 4. Handle 's' : Use short paths (File doesn't have to exist) */
if (memchrW(firstModifier, 's', modifierLen) != NULL) {
if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
/* Don't flag as doneModifier - %~s on its own is processed later */
GetShortPathName(outputparam, outputparam,
sizeof(outputparam)/sizeof(outputparam[0]));
}
/* 5. Handle 'f' : Fully qualified path (File doesn't have to exist) */
/* Note this overrides d,p,n,x */
if (memchrW(firstModifier, 'f', modifierLen) != NULL) {
doneModifier = TRUE;
if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
strcatW(finaloutput, fullfilename);
} else {
WCHAR drive[10];
WCHAR dir[MAX_PATH];
WCHAR fname[MAX_PATH];
WCHAR ext[MAX_PATH];
BOOL doneFileModifier = FALSE;
if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
/* Split into components */
WCMD_splitpath(fullfilename, drive, dir, fname, ext);
/* 5. Handle 'd' : Drive Letter */
if (memchrW(firstModifier, 'd', modifierLen) != NULL) {
strcatW(finaloutput, drive);
doneModifier = TRUE;
doneFileModifier = TRUE;
}
/* 6. Handle 'p' : Path */
if (memchrW(firstModifier, 'p', modifierLen) != NULL) {
strcatW(finaloutput, dir);
doneModifier = TRUE;
doneFileModifier = TRUE;
}
/* 7. Handle 'n' : Name */
if (memchrW(firstModifier, 'n', modifierLen) != NULL) {
strcatW(finaloutput, fname);
doneModifier = TRUE;
doneFileModifier = TRUE;
}
/* 8. Handle 'x' : Ext */
if (memchrW(firstModifier, 'x', modifierLen) != NULL) {
strcatW(finaloutput, ext);
doneModifier = TRUE;
doneFileModifier = TRUE;
}
/* If 's' but no other parameter, dump the whole thing */
if (!doneFileModifier &&
memchrW(firstModifier, 's', modifierLen) != NULL) {
doneModifier = TRUE;
if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
strcatW(finaloutput, outputparam);
}
}
}
/* If No other modifier processed, just add in parameter */
if (!doneModifier) strcpyW(finaloutput, outputparam);
/* Finish by inserting the replacement into the string */
pos = WCMD_strdupW(lastModifier+1);
strcpyW(*start, finaloutput);
strcatW(*start, pos);
free(pos);
}
void DrawSimpleIdleScreen(void)
{
unsigned char msd;
unsigned char lsd;
unsigned char Row = 6;
unsigned char Col = 0;
int Minutes;
/* display hour */
int Hour = GetRTCHOUR();
if (Hour < 0 || Hour > 23) {
Hour = 0;
}
/* if required convert to twelve hour format */
if ( GetTimeFormat() == TWELVE_HOUR )
{
if ( Hour == 0 )
{
Hour = 12;
}
else if ( Hour > 12 )
{
Hour -= 12;
}
}
msd = Hour / 10;
lsd = Hour % 10;
/* if first digit is zero then leave location blank */
if ( msd != 0 )
{
WriteTimeDigit(msd, Row, Col, LEFT_JUSTIFIED);
}
Col += 1;
WriteTimeDigit(lsd, Row, Col, RIGHT_JUSTIFIED);
Col += 2;
/* the colon takes the first 5 bits on the byte*/
WriteTimeColon(Row,Col,RIGHT_JUSTIFIED);
Col += 1;
/* display minutes */
Minutes = GetRTCMIN();
if (Minutes < 0 || Minutes > 59) {
Minutes = 0;
}
msd = Minutes / 10;
lsd = Minutes % 10;
WriteTimeDigit(msd, Row, Col, RIGHT_JUSTIFIED);
Col += 2;
WriteTimeDigit(lsd, Row, Col, LEFT_JUSTIFIED);
if ( nvDisplaySeconds )
{
/* the final colon's spacing isn't quite the same */
int Seconds = GetRTCSEC();
msd = Seconds / 10;
lsd = Seconds % 10;
Col +=2;
WriteTimeColon(Row,Col,LEFT_JUSTIFIED);
Col += 1;
WriteTimeDigit(msd,Row,Col,LEFT_JUSTIFIED);
Col += 1;
WriteTimeDigit(lsd,Row,Col,RIGHT_JUSTIFIED);
}
else
{
DisplayAmPm();
DisplayDayOfWeek();
DisplayDate();
}
}
