1186 lines
31 KiB
C++
1186 lines
31 KiB
C++
/*****************************************************************************
|
|
*
|
|
* sdview.cpp
|
|
*
|
|
* Lame SD Viewer app.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#include "sdview.h"
|
|
|
|
HINSTANCE g_hinst;
|
|
HCURSOR g_hcurWait;
|
|
HCURSOR g_hcurArrow;
|
|
HCURSOR g_hcurAppStarting;
|
|
LONG g_lThreads;
|
|
UINT g_wShowWindow;
|
|
CGlobals GlobalSettings;
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Stubs - will be filled in with goodies eventually
|
|
*
|
|
*****************************************************************************/
|
|
|
|
DWORD CALLBACK CFileOut_ThreadProc(LPVOID lpParameter)
|
|
{
|
|
MessageBox(NULL, RECAST(LPTSTR, lpParameter), TEXT("fileout"), MB_OK);
|
|
return EndThreadTask(0);
|
|
}
|
|
|
|
#if 0
|
|
DWORD CALLBACK COpened_ThreadProc(LPVOID lpParameter)
|
|
{
|
|
MessageBox(NULL, RECAST(LPTSTR, lpParameter), TEXT("opened"), MB_OK);
|
|
return EndThreadTask(0);
|
|
}
|
|
#endif
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Eschew the C runtime. Also, bonus-initialize memory to zero.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void * __cdecl operator new(size_t cb)
|
|
{
|
|
return RECAST(LPVOID, LocalAlloc(LPTR, cb));
|
|
}
|
|
|
|
void __cdecl operator delete(void *pv)
|
|
{
|
|
LocalFree(RECAST(HLOCAL, pv));
|
|
}
|
|
|
|
int __cdecl _purecall(void)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Assertion goo
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#ifdef DEBUG
|
|
void AssertFailed(char *psz, char *pszFile, int iLine)
|
|
{
|
|
static BOOL fAsserting = FALSE;
|
|
|
|
if (!fAsserting) {
|
|
fAsserting = TRUE;
|
|
String strTitle(TEXT("Assertion failed - "));
|
|
strTitle << pszFile << TEXT(" - line ") << iLine;
|
|
MessageBox(NULL, psz, strTitle, MB_OK);
|
|
fAsserting = FALSE;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* LaunchThreadTask
|
|
*
|
|
*****************************************************************************/
|
|
|
|
BOOL LaunchThreadTask(LPTHREAD_START_ROUTINE pfn, LPCTSTR pszArgs)
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
LPTSTR psz = StrDup(pszArgs);
|
|
if (psz) {
|
|
InterlockedIncrement(&g_lThreads);
|
|
if (_QueueUserWorkItem(pfn, CCAST(LPTSTR, psz), WT_EXECUTELONGFUNCTION)) {
|
|
fSuccess = TRUE;
|
|
} else {
|
|
LocalFree(psz);
|
|
InterlockedDecrement(&g_lThreads);
|
|
}
|
|
}
|
|
return fSuccess;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* EndThreadTask
|
|
*
|
|
* When a task finishes, exit with "return EndThreadTask(dwExitCode)".
|
|
* This decrements the count of active thread tasks and terminates
|
|
* the process if this is the last one.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
DWORD
|
|
EndThreadTask(DWORD dwExitCode)
|
|
{
|
|
if (InterlockedDecrement(&g_lThreads) <= 0) {
|
|
ExitProcess(dwExitCode);
|
|
}
|
|
return dwExitCode;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Listview stuff
|
|
*
|
|
*****************************************************************************/
|
|
|
|
int ListView_GetCurSel(HWND hwnd)
|
|
{
|
|
return ListView_GetNextItem(hwnd, -1, LVNI_FOCUSED);
|
|
}
|
|
|
|
void ListView_SetCurSel(HWND hwnd, int iIndex)
|
|
|
|
{
|
|
ListView_SetItemState(hwnd, iIndex,
|
|
LVIS_SELECTED | LVIS_FOCUSED,
|
|
LVIS_SELECTED | LVIS_FOCUSED);
|
|
}
|
|
|
|
int ListView_GetSubItemText(HWND hwnd, int iItem, int iSubItem, LPTSTR pszBuf, int cch)
|
|
{
|
|
LVITEM lvi;
|
|
lvi.iSubItem = iSubItem;
|
|
lvi.pszText= pszBuf;
|
|
lvi.cchTextMax = cch;
|
|
return (int)::SendMessage(hwnd, LVM_GETITEMTEXT, iItem, RECAST(LPARAM, &lvi));
|
|
}
|
|
|
|
void ChangeTabsToSpaces(LPTSTR psz)
|
|
{
|
|
while ((psz = StrChr(psz, TEXT('\t'))) != NULL) *psz = TEXT(' ');
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* LoadPopupMenu
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HMENU LoadPopupMenu(LPCTSTR pszMenu)
|
|
{
|
|
HMENU hmenuParent = LoadMenu(g_hinst, pszMenu);
|
|
if (hmenuParent) {
|
|
HMENU hmenuPopup = GetSubMenu(hmenuParent, 0);
|
|
RemoveMenu(hmenuParent, 0, MF_BYPOSITION);
|
|
DestroyMenu(hmenuParent);
|
|
return hmenuPopup;
|
|
} else {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* EnableDisableOrRemoveMenuItem
|
|
*
|
|
* Enable, disable or remove, accordingly.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void EnableDisableOrRemoveMenuItem(HMENU hmenu, UINT id, BOOL fEnable, BOOL fDelete)
|
|
{
|
|
if (fEnable) {
|
|
EnableMenuItem(hmenu, id, MF_BYCOMMAND | MF_ENABLED);
|
|
} else if (fDelete) {
|
|
DeleteMenu(hmenu, id, MF_BYCOMMAND);
|
|
} else {
|
|
EnableMenuItem(hmenu, id, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* MakeMenuPretty
|
|
*
|
|
* Remove separators at the top and at the bottom, and collapse
|
|
* multiple consecutive separators.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void MakeMenuPretty(HMENU hmenu)
|
|
{
|
|
BOOL fPrevSep = TRUE;
|
|
int iCount = GetMenuItemCount(hmenu);
|
|
for (int iItem = 0; iItem < iCount; iItem++) {
|
|
UINT uiState = GetMenuState(hmenu, 0, MF_BYPOSITION);
|
|
if (uiState & MF_SEPARATOR) {
|
|
if (fPrevSep) {
|
|
DeleteMenu(hmenu, iItem, MF_BYPOSITION);
|
|
iCount--;
|
|
iItem--; // Will be incremented by loop control
|
|
}
|
|
fPrevSep = TRUE;
|
|
} else {
|
|
fPrevSep = FALSE;
|
|
}
|
|
}
|
|
if (iCount && fPrevSep) {
|
|
DeleteMenu(hmenu, iCount - 1, MF_BYPOSITION);
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* JiggleMouse
|
|
*
|
|
*
|
|
* Jiggle the mouse to force a cursor recomputation.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void JiggleMouse()
|
|
{
|
|
POINT pt;
|
|
if (GetCursorPos(&pt)) {
|
|
SetCursorPos(pt.x, pt.y);
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* BGTask
|
|
*
|
|
*****************************************************************************/
|
|
|
|
BGTask::~BGTask()
|
|
{
|
|
if (_hDone) {
|
|
/*
|
|
* Theoretically we don't need to pump messages because
|
|
* we destroyed all the windows we created so our thread
|
|
* should be clear of any windows. Except that Cicero will
|
|
* secretly create a window on our thread, so we have
|
|
* to pump messages anyway...
|
|
*/
|
|
while (MsgWaitForMultipleObjects(1, &_hDone, FALSE,
|
|
INFINITE, QS_ALLINPUT) == WAIT_OBJECT_0+1) {
|
|
MSG msg;
|
|
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
}
|
|
CloseHandle(_hDone);
|
|
}
|
|
}
|
|
|
|
BOOL BGTask::BGStartTask(LPTHREAD_START_ROUTINE pfn, LPVOID Context)
|
|
{
|
|
ASSERT(!_fPending);
|
|
if (BGConstructed()) {
|
|
/*
|
|
* Must reset before queueing the work item to avoid a race where
|
|
* the work item completes before we return from the Queue call.
|
|
*/
|
|
ResetEvent(_hDone);
|
|
_fPending = QueueUserWorkItem(pfn, Context, WT_EXECUTELONGFUNCTION);
|
|
if (_fPending) {
|
|
JiggleMouse();
|
|
} else {
|
|
BGEndTask(); // pretend task completed (because it never started)
|
|
}
|
|
}
|
|
return _fPending;
|
|
}
|
|
|
|
void BGTask::BGEndTask()
|
|
{
|
|
SetEvent(_hDone);
|
|
_fPending = FALSE;
|
|
JiggleMouse();
|
|
}
|
|
|
|
LRESULT BGTask::BGFilterSetCursor(LRESULT lres)
|
|
{
|
|
if (BGTaskPending()) {
|
|
if (GetCursor() == g_hcurArrow) {
|
|
SetCursor(g_hcurAppStarting);
|
|
lres = TRUE;
|
|
}
|
|
}
|
|
return lres;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* PremungeFileSpec
|
|
*
|
|
* Due to complex view specifications this can be led astray when "..."
|
|
* gets involved. As a workaround (HACK!) we change "..." to "???",
|
|
* do the mapping, then map back.
|
|
*
|
|
* We choose "???" because it has so many magical properties...
|
|
*
|
|
* - not a valid filename, so cannot match a local file specification.
|
|
* - not a valid Source Depot wildcard, so cannot go wild on the server,
|
|
* - not a single question mark, which SD treats as equivalent to "help".
|
|
* - same length as "..." so can be updated in place.
|
|
*
|
|
* Any revision specifiers remain attached to the string.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void _ChangeTo(LPTSTR psz, LPCTSTR pszFrom, LPCTSTR pszTo)
|
|
{
|
|
ASSERT(lstrlen(pszFrom) == lstrlen(pszTo));
|
|
while ((psz = StrStr(psz, pszFrom)) != NULL) {
|
|
memcpy(psz, pszTo, lstrlen(pszTo) * sizeof(pszTo[0]));
|
|
}
|
|
}
|
|
|
|
void PremungeFilespec(LPTSTR psz)
|
|
{
|
|
_ChangeTo(psz, TEXT("..."), TEXT("???"));
|
|
}
|
|
|
|
void PostmungeFilespec(LPTSTR psz)
|
|
{
|
|
_ChangeTo(psz, TEXT("???"), TEXT("..."));
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* MapToXPath
|
|
*
|
|
*****************************************************************************/
|
|
|
|
BOOL MapToXPath(LPCTSTR pszSD, String& strOut, MAPTOX X)
|
|
{
|
|
if (X == MAPTOX_DEPOT) {
|
|
//
|
|
// Early-out: Is it already a full depot path?
|
|
//
|
|
if (pszSD[0] == TEXT('/')) {
|
|
strOut = pszSD;
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Borrow strOut to compose the query string.
|
|
//
|
|
Substring ssPath;
|
|
strOut.Reset();
|
|
if (Parse(TEXT("$p"), pszSD, &ssPath) && ssPath.Length() > 0) {
|
|
strOut << ssPath;
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
|
|
PremungeFilespec(strOut);
|
|
|
|
String str;
|
|
str << TEXT("where ") << QuoteSpaces(strOut);
|
|
|
|
WaitCursor wait;
|
|
SDChildProcess proc(str);
|
|
IOBuffer buf(proc.Handle());
|
|
while (buf.NextLine(str)) {
|
|
str.Chomp();
|
|
Substring rgss[3];
|
|
if (rgss[2].SetStart(Parse(TEXT("$P $P "), str, rgss))) {
|
|
PostmungeFilespec(str);
|
|
rgss[2].SetEnd(str + str.Length());
|
|
strOut.Reset();
|
|
strOut << rgss[X] << ssPath._pszMax;
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* MapToLocalPath
|
|
*
|
|
* MapToXPath does most of the work, but then we have to do some
|
|
* magic munging if we are running from a fake directory.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
BOOL MapToLocalPath(LPCTSTR pszSD, String& strOut)
|
|
{
|
|
BOOL fSuccess = MapToXPath(pszSD, strOut, MAPTOX_LOCAL);
|
|
if (fSuccess && !GlobalSettings.GetFakeDir().IsEmpty()) {
|
|
if (strOut.BufferLength() < MAX_PATH) {
|
|
if (!strOut.Grow(MAX_PATH - strOut.BufferLength())) {
|
|
return FALSE; // Out of memory
|
|
}
|
|
}
|
|
LPCTSTR pszRest = strOut + lstrlen(GlobalSettings.GetFakeDir());
|
|
if (*pszRest == TEXT('\\')) {
|
|
pszRest++;
|
|
}
|
|
PathCombine(strOut.Buffer(), GlobalSettings.GetLocalRoot(), pszRest);
|
|
fSuccess = TRUE;
|
|
}
|
|
return fSuccess;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* SpawnProcess
|
|
*
|
|
*****************************************************************************/
|
|
|
|
BOOL SpawnProcess(LPTSTR pszCommand)
|
|
{
|
|
STARTUPINFO si = { 0 };
|
|
PROCESS_INFORMATION pi;
|
|
|
|
BOOL fSuccess = CreateProcess(NULL, pszCommand, NULL, NULL, FALSE, 0,
|
|
NULL, NULL, &si, &pi);
|
|
if (fSuccess) {
|
|
CloseHandle(pi.hThread);
|
|
CloseHandle(pi.hProcess);
|
|
}
|
|
|
|
return fSuccess;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* WindiffChangelist
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void WindiffChangelist(int iChange)
|
|
{
|
|
if (iChange > 0) {
|
|
String str;
|
|
str << TEXT("windiff.exe -ld") << iChange;
|
|
SpawnProcess(str);
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* WindiffOneChange
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void WindiffOneChange(LPTSTR pszPath)
|
|
{
|
|
Substring rgss[2];
|
|
if (Parse(TEXT("$P#$d$e"), pszPath, rgss)) {
|
|
String str;
|
|
str << TEXT("windiff.exe ");
|
|
|
|
rgss[0].Finalize();
|
|
int iVersion = StrToInt(rgss[1].Start());
|
|
if (iVersion > 1) {
|
|
/* Edit is easy */
|
|
str << QuoteSpaces(rgss[0].Start()) << TEXT("#") << (iVersion - 1);
|
|
} else {
|
|
/* Add uses NUL as the base file */
|
|
str << TEXT("NUL");
|
|
}
|
|
|
|
str << TEXT(' ');
|
|
str << QuoteSpaces(rgss[0].Start()) << TEXT("#") << iVersion;
|
|
|
|
SpawnProcess(str);
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* ParseBugNumber
|
|
*
|
|
* See if there's a bug number in there.
|
|
*
|
|
* Digits at the beginning - bug number.
|
|
* Digits after a space or punctuation mark - bug number.
|
|
* Digits after the word "bug" or the letter "B" - bug number.
|
|
*
|
|
* A valid bug number must begin with a nonzero digit.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
int ParseBugNumber(LPCTSTR psz)
|
|
{
|
|
Substring ss;
|
|
LPCTSTR pszStart = psz;
|
|
|
|
while (*psz) {
|
|
if (IsDigit(*psz)) {
|
|
if (*psz == TEXT('0')) {
|
|
// Nope, cannot begin with zero
|
|
} else if (psz == pszStart) {
|
|
return StrToInt(psz); // woo-hoo!
|
|
} else switch (psz[-1]) {
|
|
case 'B':
|
|
case 'g':
|
|
case 'G':
|
|
return StrToInt(psz); // Comes after a B or a G
|
|
|
|
default:
|
|
if (!IsAlpha(psz[-1])) {
|
|
return StrToInt(psz); // Comes after a space or punctuation
|
|
}
|
|
}
|
|
// Phooey, a digit string beginning with 0; not a bug.
|
|
while (IsDigit(*psz)) psz++;
|
|
} else {
|
|
psz++;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* ParseBugNumberFromSubItem
|
|
*
|
|
* Sometimes we use this just to parse regular numbers since regular
|
|
* numbers pass the Bug Number Test.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
int ParseBugNumberFromSubItem(HWND hwnd, int iItem, int iSubItem)
|
|
{
|
|
TCHAR sz[MAX_PATH];
|
|
sz[0] = TEXT('\0');
|
|
if (iItem >= 0) {
|
|
ListView_GetSubItemText(hwnd, iItem, iSubItem, sz, ARRAYSIZE(sz));
|
|
}
|
|
|
|
return ParseBugNumber(sz);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* AdjustBugMenu
|
|
*
|
|
*****************************************************************************/
|
|
|
|
inline void _TrimAtTab(LPTSTR psz)
|
|
{
|
|
psz = StrChr(psz, TEXT('\t'));
|
|
if (psz) *psz = TEXT('\0');
|
|
}
|
|
|
|
void AdjustBugMenu(HMENU hmenu, int iBug, BOOL fContextMenu)
|
|
{
|
|
TCHAR sz[MAX_PATH];
|
|
String str;
|
|
|
|
if (iBug) {
|
|
str << StringResource(IDS_VIEWBUG_FORMAT);
|
|
wnsprintf(sz, ARRAYSIZE(sz), str, iBug);
|
|
if (fContextMenu) {
|
|
_TrimAtTab(sz);
|
|
}
|
|
ModifyMenu(hmenu, IDM_VIEWBUG, MF_BYCOMMAND, IDM_VIEWBUG, sz);
|
|
} else {
|
|
str << StringResource(IDS_VIEWBUG_NONE);
|
|
ModifyMenu(hmenu, IDM_VIEWBUG, MF_BYCOMMAND, IDM_VIEWBUG, str);
|
|
}
|
|
EnableDisableOrRemoveMenuItem(hmenu, IDM_VIEWBUG, iBug, fContextMenu);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* OpenBugWindow
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void OpenBugWindow(HWND hwnd, int iBug)
|
|
{
|
|
String str;
|
|
GlobalSettings.FormatBugUrl(str, iBug);
|
|
|
|
LPCTSTR pszArgs = PathGetArgs(str);
|
|
PathRemoveArgs(str);
|
|
PathUnquoteSpaces(str);
|
|
|
|
_AllowSetForegroundWindow(-1);
|
|
ShellExecute(hwnd, NULL, str, pszArgs, 0, SW_NORMAL);
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* SetClipboardText
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#ifdef UNICODE
|
|
#define CF_TSTR CF_UNICODETEXT
|
|
#else
|
|
#define CF_TSTR CF_TEXT
|
|
#endif
|
|
|
|
void SetClipboardText(HWND hwnd, LPCTSTR psz)
|
|
{
|
|
if (OpenClipboard(hwnd)) {
|
|
EmptyClipboard();
|
|
int cch = lstrlen(psz) + 1;
|
|
HGLOBAL hglob = GlobalAlloc(GMEM_MOVEABLE, cch * sizeof(*psz));
|
|
if (hglob) {
|
|
LPTSTR pszCopy = RECAST(LPTSTR, GlobalLock(hglob));
|
|
if (pszCopy) {
|
|
lstrcpy(pszCopy, psz);
|
|
GlobalUnlock(hglob);
|
|
if (SetClipboardData(CF_TSTR, hglob)) {
|
|
hglob = NULL; // ownership transfer
|
|
}
|
|
}
|
|
if (hglob) {
|
|
GlobalFree(hglob);
|
|
}
|
|
}
|
|
CloseClipboard();
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* ContainsWildcards
|
|
*
|
|
* The SD wildcards are
|
|
*
|
|
* * (asterisk)
|
|
* ... (ellipsis)
|
|
* %n (percent sign followed by anything)
|
|
* (null) (null string -- shorthand for "//...")
|
|
*
|
|
*****************************************************************************/
|
|
|
|
BOOL ContainsWildcards(LPCTSTR psz)
|
|
{
|
|
if (*psz == TEXT('#') || *psz == TEXT('@') || *psz == TEXT('\0')) {
|
|
return TRUE; // Null string wildcard
|
|
}
|
|
|
|
for (; *psz; psz++) {
|
|
if (*psz == TEXT('*') || *psz == TEXT('%')) {
|
|
return TRUE;
|
|
}
|
|
if (psz[0] == TEXT('.') && psz[1] == TEXT('.') && psz[2] == TEXT('.')) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Downlevel support
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#ifdef SUPPORT_DOWNLEVEL
|
|
|
|
/*
|
|
* If there is no thread pool, then chew an entire thread.
|
|
*/
|
|
BOOL WINAPI
|
|
Emulate_QueueUserWorkItem(LPTHREAD_START_ROUTINE pfn, LPVOID Context, ULONG Flags)
|
|
{
|
|
DWORD dwId;
|
|
HANDLE hThread = CreateThread(NULL, 0, pfn, Context, 0, &dwId);
|
|
if (hThread) {
|
|
CloseHandle(hThread);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL WINAPI
|
|
Emulate_AllowSetForegroundWindow(DWORD dwProcessId)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
QUEUEUSERWORKITEM _QueueUserWorkItem;
|
|
ALLOWSETFOREGROUNDWINDOW _AllowSetForegroundWindow;
|
|
|
|
template<class T>
|
|
T GetProcFromModule(LPCTSTR pszModule, LPCSTR pszProc, T Default)
|
|
{
|
|
T t;
|
|
HMODULE hmod = GetModuleHandle(pszModule);
|
|
if (pszModule) {
|
|
t = RECAST(T, GetProcAddress(hmod, pszProc));
|
|
if (!t) {
|
|
t = Default;
|
|
}
|
|
} else {
|
|
t = Default;
|
|
}
|
|
return t;
|
|
}
|
|
|
|
|
|
#define GetProc(mod, fn) \
|
|
_##fn = GetProcFromModule(TEXT(mod), #fn, Emulate_##fn)
|
|
|
|
void InitDownlevel()
|
|
{
|
|
GetProc("KERNEL32", QueueUserWorkItem);
|
|
GetProc("USER32", AllowSetForegroundWindow);
|
|
|
|
}
|
|
|
|
#undef GetProc
|
|
|
|
#else
|
|
|
|
#define InitDownlevel()
|
|
|
|
#endif
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Main program stuff
|
|
*
|
|
*****************************************************************************/
|
|
|
|
LONG GetDllVersion(LPCTSTR pszDll)
|
|
{
|
|
HINSTANCE hinst = LoadLibrary(pszDll);
|
|
DWORD dwVersion = 0;
|
|
if (hinst) {
|
|
DLLGETVERSIONPROC DllGetVersion;
|
|
DllGetVersion = (DLLGETVERSIONPROC)GetProcAddress(hinst, "DllGetVersion");
|
|
if (DllGetVersion) {
|
|
DLLVERSIONINFO dvi;
|
|
dvi.cbSize = sizeof(dvi);
|
|
if (SUCCEEDED(DllGetVersion(&dvi))) {
|
|
dwVersion = MAKELONG(dvi.dwMinorVersion, dvi.dwMajorVersion);
|
|
}
|
|
}
|
|
// Leak the DLL - we're going to use him anyway
|
|
}
|
|
return dwVersion;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Globals
|
|
*
|
|
*****************************************************************************/
|
|
|
|
BOOL InitGlobals()
|
|
{
|
|
g_hinst = GetModuleHandle(0);
|
|
g_hcurWait = LoadCursor(NULL, IDC_WAIT);
|
|
g_hcurArrow = LoadCursor(NULL, IDC_ARROW);
|
|
g_hcurAppStarting = LoadCursor(NULL, IDC_APPSTARTING);
|
|
|
|
if (GetDllVersion(TEXT("Comctl32.dll")) < MAKELONG(71, 4) ||
|
|
GetDllVersion(TEXT("Shlwapi.dll")) < MAKELONG(71, 4)) {
|
|
TCHAR sz[MAX_PATH];
|
|
LoadString(g_hinst, IDS_IE4, sz, ARRAYSIZE(sz));
|
|
//$$//BUGBUG// MessageBox(NULL, sz, g_szTitle, MB_OK);
|
|
return FALSE;
|
|
}
|
|
|
|
InitDownlevel();
|
|
InitCommonControls();
|
|
|
|
/*
|
|
* Get the SW_ flag for the first window.
|
|
*/
|
|
STARTUPINFOA si;
|
|
si.cb = sizeof(si);
|
|
si.dwFlags = 0;
|
|
GetStartupInfoA(&si);
|
|
|
|
if (si.dwFlags & STARTF_USESHOWWINDOW) {
|
|
g_wShowWindow = si.wShowWindow;
|
|
} else {
|
|
g_wShowWindow = SW_SHOWDEFAULT;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void TermGlobals()
|
|
{
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Help
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void Help(HWND hwnd, LPCTSTR pszAnchor)
|
|
{
|
|
|
|
TCHAR szSelf[MAX_PATH];
|
|
GetModuleFileName(g_hinst, szSelf, ARRAYSIZE(szSelf));
|
|
|
|
String str;
|
|
str << TEXT("res://") << szSelf << TEXT("/tips.htm");
|
|
|
|
if (pszAnchor) {
|
|
str << pszAnchor;
|
|
}
|
|
|
|
_AllowSetForegroundWindow(-1);
|
|
ShellExecute(hwnd, NULL, str, 0, 0, SW_NORMAL);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* CGlobals::Initialize
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void CGlobals::Initialize()
|
|
{
|
|
/*
|
|
* The order of these three steps is important.
|
|
*
|
|
* - We have to get the path before we can call sd.
|
|
*
|
|
* - We need the "sd info" in order to determine what
|
|
* the proper fake directory is.
|
|
*/
|
|
|
|
_InitSdPath();
|
|
_InitInfo();
|
|
_InitFakeDir();
|
|
_InitServerVersion();
|
|
_InitBugPage();
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* CGlobals::_InitSdPath
|
|
*
|
|
* The environment variable "SD" provides the path to the program to use.
|
|
* The default is "sd", but for debugging, you can set it to "fakesd",
|
|
* or if you're using that other company's product, you might even want
|
|
* to set it to that other company's program...
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void CGlobals::_InitSdPath()
|
|
{
|
|
TCHAR szSd[MAX_PATH];
|
|
LPTSTR pszSdExe;
|
|
|
|
DWORD cb = GetEnvironmentVariable(TEXT("SD"), szSd, ARRAYSIZE(szSd));
|
|
if (cb == 0 || cb > ARRAYSIZE(szSd)) {
|
|
pszSdExe = TEXT("SD.EXE"); // Default value
|
|
} else {
|
|
pszSdExe = szSd;
|
|
}
|
|
|
|
cb = SearchPath(NULL, pszSdExe, TEXT(".exe"), ARRAYSIZE(_szSd), _szSd, NULL);
|
|
if (cb == 0 || cb > ARRAYSIZE(_szSd)) {
|
|
/*
|
|
* Not found on path, eek! Just use sd.exe and wait for the
|
|
* fireworks.
|
|
*/
|
|
lstrcpyn(_szSd, TEXT("SD.EXE"), ARRAYSIZE(_szSd));
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* CGlobals::_InitInfo
|
|
*
|
|
* Collect the results of the "sd info" command.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void CGlobals::_InitInfo()
|
|
{
|
|
static const LPCTSTR s_rgpsz[] = {
|
|
TEXT("User name: "),
|
|
TEXT("Client name: "),
|
|
TEXT("Client root: "),
|
|
TEXT("Current directory: "),
|
|
TEXT("Server version: "),
|
|
};
|
|
|
|
COMPILETIME_ASSERT(ARRAYSIZE(s_rgpsz) == ARRAYSIZE(_rgpszSettings));
|
|
|
|
WaitCursor wait;
|
|
SDChildProcess proc(TEXT("info"));
|
|
IOBuffer buf(proc.Handle());
|
|
String str;
|
|
while (buf.NextLine(str)) {
|
|
str.Chomp();
|
|
int i;
|
|
for (i = 0; i < ARRAYSIZE(s_rgpsz); i++) {
|
|
LPTSTR pszRest = Parse(s_rgpsz[i], str, NULL);
|
|
if (pszRest) {
|
|
_rgpszSettings[i] = pszRest;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* CGlobals::_InitFakeDir
|
|
*
|
|
* See if the user is borrowing another person's enlistment.
|
|
* If so, then virtualize the directory (by walking the tree
|
|
* looking for an sd.ini file) to keep sd happy.
|
|
*
|
|
* DO NOT WHINE if anything is wrong. Magical resolution of
|
|
* borrowed directories is just a nicety.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void CGlobals::_InitFakeDir()
|
|
{
|
|
/*
|
|
* If the client root is not a prefix of the current directory,
|
|
* then cook up a virtual current directory that will keep sd happy.
|
|
*/
|
|
_StringCache& pszClientRoot = _rgpszSettings[SETTING_CLIENTROOT];
|
|
_StringCache& pszLocalDir = _rgpszSettings[SETTING_LOCALDIR];
|
|
if (!pszClientRoot.IsEmpty() && !pszLocalDir.IsEmpty() &&
|
|
!PathIsPrefix(pszClientRoot, pszLocalDir)) {
|
|
|
|
TCHAR szDir[MAX_PATH];
|
|
TCHAR szOriginalDir[MAX_PATH];
|
|
TCHAR szSdIni[MAX_PATH];
|
|
|
|
szDir[0] = TEXT('\0');
|
|
|
|
GetCurrentDirectory(ARRAYSIZE(szDir), szDir);
|
|
if (!szDir[0]) return; // Freaky
|
|
|
|
lstrcpyn(szOriginalDir, szDir, ARRAYSIZE(szOriginalDir));
|
|
|
|
do {
|
|
PathCombine(szSdIni, szDir, TEXT("sd.ini"));
|
|
if (PathFileExists(szSdIni)) {
|
|
|
|
_pszLocalRoot = szDir;
|
|
//
|
|
// Now work from the root back to the current directory.
|
|
//
|
|
LPTSTR pszSuffix = szOriginalDir + lstrlen(szDir);
|
|
if (pszSuffix[0] == TEXT('\\')) {
|
|
pszSuffix++;
|
|
}
|
|
|
|
PathCombine(szSdIni, _rgpszSettings[SETTING_CLIENTROOT], pszSuffix);
|
|
_pszFakeDir = szSdIni;
|
|
break;
|
|
}
|
|
} while (PathRemoveFileSpec(szDir));
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* CGlobals::_InitServerVersion
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void CGlobals::_InitServerVersion()
|
|
{
|
|
Substring rgss[5];
|
|
if (Parse(TEXT("$w $d.$d.$d.$d"), _rgpszSettings[SETTING_SERVERVERSION], rgss)) {
|
|
for (int i = 0; i < VERSION_MAX; i++) {
|
|
_rguiVer[i] = StrToInt(rgss[1+i].Start());
|
|
}
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* CGlobals::_InitBugPage
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void CGlobals::_InitBugPage()
|
|
{
|
|
TCHAR szRaid[MAX_PATH];
|
|
|
|
DWORD cb = GetEnvironmentVariable(TEXT("SDVRAID"), szRaid, ARRAYSIZE(szRaid));
|
|
if (cb == 0 || cb > ARRAYSIZE(szRaid)) {
|
|
LoadString(g_hinst, IDS_DEFAULT_BUGPAGE, szRaid, ARRAYSIZE(szRaid));
|
|
}
|
|
|
|
LPTSTR pszSharp = StrChr(szRaid, TEXT('#'));
|
|
if (pszSharp) {
|
|
*pszSharp++ = TEXT('\0');
|
|
}
|
|
_pszBugPagePre = szRaid;
|
|
_pszBugPagePost = pszSharp;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* CommandLineParser
|
|
*
|
|
*****************************************************************************/
|
|
|
|
class CommandLineParser
|
|
{
|
|
public:
|
|
CommandLineParser() : _tok(GetCommandLine()) {}
|
|
BOOL ParseCommandLine();
|
|
void Invoke();
|
|
|
|
private:
|
|
BOOL ParseMetaParam();
|
|
BOOL TokenWithUndo();
|
|
void UndoToken() { _tok.Restart(_pszUndo); }
|
|
|
|
private:
|
|
Tokenizer _tok;
|
|
LPCTSTR _pszUndo;
|
|
LPTHREAD_START_ROUTINE _pfn;
|
|
String _str;
|
|
};
|
|
|
|
BOOL CommandLineParser::TokenWithUndo()
|
|
{
|
|
_pszUndo = _tok.Unparsed();
|
|
return _tok.Token(_str);
|
|
}
|
|
|
|
BOOL CommandLineParser::ParseMetaParam()
|
|
{
|
|
switch (_str[2]) {
|
|
case TEXT('s'):
|
|
if (_str[3] == TEXT('\0')) {
|
|
_tok.Token(_str);
|
|
GlobalSettings.SetSdOpts(_str);
|
|
} else {
|
|
GlobalSettings.SetSdOpts(_str+3);
|
|
}
|
|
break;
|
|
|
|
case TEXT('#'):
|
|
switch (_str[3]) {
|
|
case TEXT('+'):
|
|
case TEXT('\0'):
|
|
GlobalSettings.SetChurn(TRUE);
|
|
break;
|
|
case TEXT('-'):
|
|
GlobalSettings.SetChurn(FALSE);
|
|
break;
|
|
default:
|
|
return FALSE;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CommandLineParser::ParseCommandLine()
|
|
{
|
|
_tok.Token(_str); // Throw away program name
|
|
|
|
/*
|
|
* First collect the meta-parameters. These begin with two dashes.
|
|
*/
|
|
|
|
while (TokenWithUndo()) {
|
|
if (_str[0] == TEXT('-') && _str[1] == TEXT('-')) {
|
|
if (!ParseMetaParam()) {
|
|
return FALSE;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Next thing had better be a command!
|
|
*/
|
|
if (lstrcmpi(_str, TEXT("changes")) == 0) {
|
|
_pfn = CChanges_ThreadProc;
|
|
} else if (lstrcmpi(_str, TEXT("describe")) == 0) {
|
|
_pfn = CDescribe_ThreadProc;
|
|
} else if (lstrcmpi(_str, TEXT("filelog")) == 0) {
|
|
_pfn = CFileLog_ThreadProc;
|
|
} else if (lstrcmpi(_str, TEXT("fileout")) == 0) {
|
|
_pfn = CFileOut_ThreadProc;
|
|
} else if (lstrcmpi(_str, TEXT("opened")) == 0) {
|
|
_pfn = COpened_ThreadProc;
|
|
} else {
|
|
/*
|
|
* Eek! Must use psychic powers!
|
|
*/
|
|
|
|
Substring ss;
|
|
if (_str[0] == TEXT('\0')) {
|
|
/*
|
|
* If no args, then it's "changes".
|
|
*/
|
|
_pfn = CChanges_ThreadProc;
|
|
} else if (_str[0] == TEXT('-')) {
|
|
/*
|
|
* If it begins with a dash, then it's "changes".
|
|
*/
|
|
_pfn = CChanges_ThreadProc;
|
|
} else if (Parse(TEXT("$d$e"), _str, &ss)) {
|
|
/*
|
|
* If first word is all digits, then it's "describe".
|
|
*/
|
|
_pfn = CDescribe_ThreadProc;
|
|
} else if (_tok.Finished() && !ContainsWildcards(_str)) {
|
|
/*
|
|
* If only one argument that contains no wildcards,
|
|
* then it's "filelog".
|
|
*/
|
|
_pfn = CFileLog_ThreadProc;
|
|
} else {
|
|
/*
|
|
* If all else fails, assume "changes".
|
|
*/
|
|
_pfn = CChanges_ThreadProc;
|
|
}
|
|
|
|
UndoToken(); /* Undo all the tokens we accidentally ate */
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CommandLineParser::Invoke()
|
|
{
|
|
LPTSTR psz = StrDup(_tok.Unparsed());
|
|
if (psz) {
|
|
InterlockedIncrement(&g_lThreads);
|
|
ExitThread(_pfn(psz));
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Entry
|
|
*
|
|
* Program entry point.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
EXTERN_C void PASCAL
|
|
Entry(void)
|
|
{
|
|
if (InitGlobals()) {
|
|
CommandLineParser parse;
|
|
if (!parse.ParseCommandLine()) {
|
|
Help(NULL, NULL);
|
|
} else {
|
|
GlobalSettings.Initialize();
|
|
parse.Invoke();
|
|
}
|
|
}
|
|
|
|
ExitProcess(0);
|
|
}
|