//
// Copyright 1997 Nicholas J. Irias. All rights reserved.
//
//
// P4win.cpp : Defines the class behaviors for the application.
//
#include "stdafx.h"
#include "P4win.h"
#include "hlp\p4win.hh"
#include "MainFrm.h"
#include "Document.h"
#include "DepotView.h"
#include "resource.h"
#include "TokenString.h"
#include "NewWindowDlg.h"
#include "RegKeyEx.h"
#include "cmd_info.h"
#include "Cmd_Login.h"
#include "ImageList.h"
#include <mapi.h>
#include <winver.h>
#include "GuiClientUser.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
int global_cancel = 0;
CString startingfolder;
/////////////////////////////////////////////////////////////////////////////
// CP4winApp
BEGIN_MESSAGE_MAP(CP4winApp, CP4GuiApp)
//{{AFX_MSG_MAP(CP4winApp)
ON_COMMAND(ID_NEW_WINDOW, OnNewWindow)
ON_UPDATE_COMMAND_UI(ID_NEW_WINDOW, OnUpdateNewWindow)
//}}AFX_MSG_MAP
// Standard file based document commands
ON_COMMAND(ID_FILE_NEW, CWinApp::OnFileNew)
ON_COMMAND(ID_FILE_OPEN, CWinApp::OnFileOpen)
// Standard print setup command
ON_COMMAND(ID_FILE_PRINT_SETUP, CWinApp::OnFilePrintSetup)
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CP4winApp construction
CP4winApp::CP4winApp()
{
EnableHtmlHelp();
m_IdleCounter = 1;
m_InitialView = _T('\0');
m_WarningDialog= TRUE;
m_TestFlag= FALSE;
m_hNWSRVLOC = LoadLibrary(_T("NWSRVLOC.dll"));
m_RevHistCount = 0;
m_RevHistEnableShowIntegs = TRUE;
m_viewImageList = 0;
m_toolBarImageList = 0;
m_RevHistLast = 0;
m_bFindInChg = FALSE;
DWORD dummy;
TCHAR cmdLine[] = _T("P4Merge.exe");
m_P4Merge = GetFileVersionInfoSize( cmdLine, &dummy ) > 0 ? 1 : 0;
if (m_P4Merge)
m_P4MergeVer = MainFrame()->GetExeVersion(cmdLine);
}
CP4winApp::~CP4winApp()
{
if(m_viewImageList)
{
m_viewImageList->Detach();
delete m_viewImageList;
}
if(m_toolBarImageList)
{
m_toolBarImageList->Detach();
delete m_toolBarImageList;
}
if(m_hMutex != NULL)
CloseHandle(m_hMutex);
if (m_hNWSRVLOC)
FreeLibrary(m_hNWSRVLOC);
}
/////////////////////////////////////////////////////////////////////////////
// The one and only CP4winApp object
CP4winApp theApp;
/////////////////////////////////////////////////////////////////////////////
// command line parsing
static enum Arg { none, port, user, client, password, view, charset,
selection, fileinfo, revhist, revhistcnt, submit,
diff, find, icons, cr8cli, toolsimp } nextArg = none;
void CP4winApp::ParseArg(LPCTSTR pArg)
{
// usage: [switches]
// switches:
// -q : disable warnings
// -p port : set p4port
// -u user : set p4user
// -c client : set p4client
// -P password : set p4password
// -v view : set initial view
// -C charset : set initial character set
// -s selection: set initial selection
// -I fileinfo : set requested file properties path
// -H revhist : set requested revision history path
// -m revhistcnt: set requested revision history count
// -S submit : submit changelist containing filepath
// -D diff : diff filepath against depot
// -F find : find filepath in depot pane
// -i colors : set requested icons
// -( cr8cli : run new client wizard (if client doesn't exist)
// -T toolsimp : import custom tools from a file
if(nextArg == none)
{
if(lstrlen(pArg) == 2)
{
switch(pArg[1])
{
case _T('Q'): m_TestFlag = TRUE;
case _T('q'): m_WarningDialog = FALSE; return;
case _T('p'): nextArg = port; return;
case _T('u'): nextArg = user; return;
case _T('c'): nextArg = client; return;
case _T('P'): nextArg = password; return;
case _T('v'): nextArg = view; return;
case _T('C'): nextArg = charset; return;
case _T('s'): nextArg = selection; return;
case _T('I'): nextArg = fileinfo; return;
case _T('H'): nextArg = revhist; return;
case _T('m'): nextArg = revhistcnt; return;
case _T('S'): nextArg = submit; return;
case _T('D'): nextArg = diff; return;
case _T('F'): nextArg = find; return;
case _T('i'): nextArg = icons; return;
case _T('('): nextArg = cr8cli; return;
case _T('T'): nextArg = toolsimp; return;
}
}
}
else
{
Arg thisArg = nextArg;
nextArg = none;
switch(thisArg)
{
case port:
if(lstrlen(pArg))
{
GET_P4REGPTR()->SetP4Port(pArg, TRUE, FALSE, FALSE);
return;
}
case user:
if(lstrlen(pArg))
{
GET_P4REGPTR()->SetP4User(pArg, TRUE, FALSE, FALSE);
return;
}
case cr8cli:
m_WarningDialog = FALSE;
m_RunClientWizOnly = TRUE;;
case client:
if(lstrlen(pArg))
{
GET_P4REGPTR()->SetP4Client(pArg, TRUE, FALSE, FALSE);
return;
}
case password:
if(lstrlen(pArg))
{
GET_P4REGPTR()->SetP4Password(pArg, TRUE, FALSE, FALSE);
CCmd_Login *pCmd = new CCmd_Login; // run p4 login
CString portStr = GET_P4REGPTR()->GetP4Port(); // get current port
pCmd->GetClient()->SetPort(portStr); // run login against cur port
CString userStr = GET_P4REGPTR()->GetP4User(); // get current user
pCmd->GetClient()->SetUser(userStr); // run login against cur user
pCmd->Init(NULL, RUN_SYNC, LOSE_LOCK, 0);
pCmd->Run(pArg); // run the login command
delete pCmd;
return;
}
case view:
if(lstrlen(pArg))
{
m_InitialView = (TCHAR)CharUpper((LPTSTR)(TBYTE)pArg[0]);
return;
}
case charset:
if(lstrlen(pArg))
{
GET_P4REGPTR()->SetP4Charset(pArg, TRUE, FALSE, FALSE);
GET_P4REGPTR()->SetP4CharsetFromCmdli(TRUE); // must follow SetP4Charset()!
return;
}
case selection:
if(lstrlen(pArg))
{
m_WarningDialog = FALSE;
m_ExpandPath = DemanglePath(pArg);
if (m_ExpandPath.GetAt(0) != _T('/')
&& m_ExpandPath.GetAt(1) != _T(':')
&& m_ExpandPath.GetAt(0) != _T('\\'))
{
TCHAR buf[MAX_PATH+1];
if (GetCurrentDirectory(sizeof(buf)-1, buf))
{
CString str = CString(buf) + _T('\\') + m_ExpandPath;
m_ExpandPath = str;
}
}
m_bFindInChg = TRUE;
return;
}
case fileinfo:
if(lstrlen(pArg))
{
m_WarningDialog = FALSE;
m_FileInfoPath = DemanglePath(pArg);
return;
}
case revhist:
if(lstrlen(pArg))
{
m_WarningDialog = FALSE;
m_RevHistPath = DemanglePath(pArg);
return;
}
case revhistcnt:
if(lstrlen(pArg))
{
m_RevHistCount = _tstoi(pArg);
return;
}
case submit:
if(lstrlen(pArg))
{
m_WarningDialog = FALSE;
if (m_SubmitPath.IsEmpty())
m_SubmitPath = DemanglePath(pArg);
else
m_SubmitPathList.AddTail(DemanglePath(pArg));
nextArg = submit;
return;
}
case diff:
if(lstrlen(pArg))
{
m_WarningDialog = FALSE;
m_DiffPath = DemanglePath(pArg);
return;
}
case toolsimp:
if(lstrlen(pArg))
{
m_WarningDialog = FALSE;
m_ToolsImportPath = DemanglePath(pArg);
return;
}
case icons:
GET_P4REGPTR()->SetUse256colorIcons((_tstoi(pArg) == 256) ? TRUE : FALSE);
return;
}
}
if (*(pArg+1) == _T(':'))
{
nextArg = revhist;
ParseArg(pArg);
return;
}
ASSERT(0);
m_bGoodArgs = false;
}
/////////////////////////////////////////////////////////////////////////////
// CP4winApp initialization
BOOL CP4winApp::InitInstance()
{
if(!CP4GuiApp::InitInstance())
return FALSE;
LoadStdProfileSettings(0); // Do NOT track MRU files
// Get Perforce connect info from registry
m_RegInfo.ReadRegistry();
m_bGoodArgs = true;
ParseCommandLineArgs();
if(!m_bGoodArgs)
{
MessageBox(NULL, LoadStringResource(IDS_INVALID_COMMAND_LINE_ARGS__USAGE),
LoadStringResource(IDS_P4WINUSAGE), MB_ICONEXCLAMATION);
return FALSE;
}
///////////////////
// Test for previous instance, by attempting to open a named mutex
// If an instance is already running, see if user wants to activate it
m_WM_ACTIVATE= RegisterWindowMessage(_T("Activate Previous P4Win"));
m_WM_SENDCMD = RegisterWindowMessage(_T("P4Win Send Command"));
m_WM_RPLYCMD = RegisterWindowMessage(_T("P4Win Reply Command"));
m_hMutex= OpenMutex(SYNCHRONIZE, FALSE, _T("Running P4Win Instance"));
if(m_hMutex==NULL)
{
// This is the first instance
m_hMutex= CreateMutex(NULL, FALSE, _T("Running P4Win Instance"));
}
else if (!m_ExpandPath.IsEmpty())
{
BOOL b = FALSE;
HANDLE hMapFile = CreateFileMapping(
INVALID_HANDLE_VALUE, // use paging file
NULL, // default security
PAGE_READWRITE, // read/write access
0, // max. object size
P4WIN_SHARED_MEMORY_SIZE, // buffer size
P4WIN_SHARED_MEMORY_NAME); // name of mapping object
if (hMapFile != NULL && hMapFile != INVALID_HANDLE_VALUE)
{
EXPANDPATH *ep = (EXPANDPATH *)MapViewOfFile(hMapFile, // handle to mapping object
FILE_MAP_ALL_ACCESS, 0, 0, P4WIN_SHARED_MEMORY_SIZE);
if (ep != NULL)
{
TCHAR *p = ep->buf;
lstrcpy(p, GET_P4REGPTR()->GetP4Port());
ep->port = p - ep->buf;
p += lstrlen(p) + 1;
lstrcpy(p, GET_P4REGPTR()->GetP4Client());
ep->client = p - ep->buf;
p += lstrlen(p) + 1;
lstrcpy(p, GET_P4REGPTR()->GetP4User());
ep->user = p - ep->buf;
p += lstrlen(p) + 1;
lstrcpy(p, m_ExpandPath);
ep->path = p - ep->buf;
::SendMessage( HWND_BROADCAST, m_WM_SENDCMD, (WPARAM)1, (LPARAM)0 );
Sleep(500);
if (ep->flag)
b = TRUE;
UnmapViewOfFile(ep);
}
CloseHandle(hMapFile);
if (b)
return FALSE;
}
}
else if( m_WarningDialog )
{
// See if user wants to activate previous instance
//
int ret = AfxMessageBox(IDS_P4WIN_IS_ALREADY_RUNNING__OPEN_THE_OLD_WINDOW,
MB_YESNOCANCEL | MB_ICONEXCLAMATION ) ;
// only when user picks NO do we run the app
//
switch( ret )
{
case IDYES:
::SendMessage( HWND_BROADCAST, m_WM_ACTIVATE, 0, 0 );
case IDCANCEL:
return FALSE;
}
}
// Load up the shared image lists
m_viewImageList = new CP4ViewImageList();
m_toolBarImageList = new CP4WinToolBarImageList();
if(GET_P4REGPTR()->Use256colorIcons())
{
m_viewImageList->Use256ColorIcons();
m_toolBarImageList->Use256ColorIcons();
}
m_viewImageList->Create();
m_toolBarImageList->Create();
// Load up the busy cursor, after reading registry cwinapp
m_hBusyCursor= GET_P4REGPTR()->GetP4BusyCursor() ? ::LoadCursorFromFile(_T("P4_Busy.ani")) : NULL;
if(m_hBusyCursor==NULL)
m_hBusyCursor= LoadStandardCursor(IDC_WAIT);
// Write our version number to the registry so P4wei knows what version we are.
LPCTSTR sKey = _T("Software\\Perforce\\P4Win\\");
LPCTSTR sVersion = _T("Version");
CRegKeyEx key;
if(ERROR_SUCCESS == key.Create(HKEY_CURRENT_USER, sKey, REG_NONE, REG_OPTION_NON_VOLATILE, KEY_WRITE))
key.SetValueString(m_appVersion, sVersion);
// Register the application's document templates. Document templates
// serve as the connection between documents, frame windows and views.
CSingleDocTemplate* pDocTemplate;
pDocTemplate = new CSingleDocTemplate(
IDR_MAINFRAME,
RUNTIME_CLASS(CP4winDoc),
RUNTIME_CLASS(CMainFrame), // main SDI frame window
RUNTIME_CLASS(CDepotView));
AddDocTemplate(pDocTemplate);
int i;
CString ver = ((CP4GuiApp*)AfxGetApp())->GetAppVersionString();
CString info = ver.Mid(3,3) + _T(" ");
if ((i = ver.ReverseFind(_T('.'))) != -1)
ver.Delete(i);
#ifdef UNICODE
info += _T("U");
#endif
CString info_ver = info + ver;
info_ver.Replace(' ', '.');
CharString cs = CharFromCString(info_ver);
strcpy(m_version, cs);
OnFileNew();
// Make sure our name is P4Win, not P4win or p4win
if (m_pszAppName && *m_pszAppName && *(m_pszAppName+1) == '4')
{
TCHAR *p = (TCHAR *)m_pszAppName;
*p = _totupper(*m_pszAppName);
*(p+2) = _totupper(*(m_pszAppName+2));
}
return TRUE;
}
////////////////////////////////////////////////////////////////////////////
// Set a new busy state for Perforce server
BOOL CP4winApp::GetServerLock(int &key)
{
// Actually set busy
BOOL gotLock= m_CS.GetServerLock( key);
// Get and set cursor position - Windows will then generate the necessary
// WM_SETCURSOR messages to get the right OnSetCursor() function called
if( gotLock )
{
POINT pt;
if(::GetCursorPos(&pt))
::SetCursorPos(pt.x, pt.y);
}
return gotLock;
}
void CP4winApp::ReleaseServerLock(int &key)
{
m_CS.ReleaseServerLock( key );
// Get and set cursor position - Windows will then generate the necessary
// WM_SETCURSOR messages to get the right OnSetCursor() function called
POINT pt;
if(::GetCursorPos(&pt))
::SetCursorPos(pt.x, pt.y);
}
////////////////////////////////////////////////////////////////////////////
// Access functions for shared image list.
int CP4winApp::GetFileImageIndex(CP4FileStats *fs, BOOL IsChangesWindow)
{
// Start at first file
int state;
// What type of file is it?
CString fileType = fs->GetHeadType();
int iType = ((fileType.Find(_T("text")) != -1) || (fileType.Find(_T("symlink")) != -1)) ? 0 : 1;
// get base image:
if(!IsChangesWindow && fs->GetHaveRev() > fs->GetHeadRev() &&
fs->GetMyOpenAction() == 0 )
{
// A ghost file. We Have the file, but its outside the
// client view.
state = CP4ViewImageList::FSB_GHOST;
}
else if(iType)
{
// normal binary file
state = CP4ViewImageList::FSB_BINARY;
}
else
{
// normal text file
state = CP4ViewImageList::FSB_TEXT;
}
// lock state overlay
if(fs->IsMyLock() || fs->IsMyOpenExclusive())
state |= CP4ViewImageList::FSB_YOUR_LOCK;
else if(fs->IsOtherLock() || fs->IsOtherOpenExclusive())
state |= CP4ViewImageList::FSB_THEIR_LOCK;
// my action overlay
switch(fs->GetMyOpenAction())
{
case F_ADD:
case F_BRANCH:
case F_IMPORT:
state |= CP4ViewImageList::FSB_YOUR_ADD;
break;
case F_EDIT:
case F_INTEGRATE:
state |= CP4ViewImageList::FSB_YOUR_EDIT;
break;
case F_DELETE:
state |= CP4ViewImageList::FSB_YOUR_DELETE;
break;
}
// other action overlay
switch(fs->GetOtherOpenAction())
{
case F_ADD:
case F_BRANCH:
case F_IMPORT:
state |= CP4ViewImageList::FSB_THEIR_ADD;
break;
case F_EDIT:
case F_INTEGRATE:
state |= CP4ViewImageList::FSB_THEIR_EDIT;
break;
case F_DELETE:
state |= CP4ViewImageList::FSB_THEIR_DELETE;
break;
}
// sync state overlay, depends on which view we're in
if(IsChangesWindow)
{
if(fs->IsUnresolved())
state |= CP4ViewImageList::FSB_NOT_SYNCED;
}
else
{
if(fs->GetHaveRev())
{
if(fs->GetHaveRev() >= fs->GetHeadRev() ||
fs->GetMyOpenAction() == F_ADD)
state |= CP4ViewImageList::FSB_SYNCED;
else if(fs->GetHaveRev() < fs->GetHeadRev())
state |= CP4ViewImageList::FSB_NOT_SYNCED;
}
}
return CP4ViewImageList::GetFileIndex(state);
}
/*
_________________________________________________________________
*/
void CP4winApp::StatusAdd( LPCTSTR txt, StatusView level, bool showDialog )
{
// get out if we call with garbage or an empty string
//
if ( txt == NULL )
return;
if ( lstrlen( txt ) < 1 )
return;
LPTSTR msg = new TCHAR[ lstrlen( txt ) + 1 ];
lstrcpy( msg, txt );
// don't post the message until we get a window. since i
// put up messages constantly, i can easily post before a
// window is up. this is cheesy, but simpler than doing an
// onidle(), and after all, these are just boring status messages.
//
CWnd *pWnd = AfxGetApp( )->m_pMainWnd;
if ( pWnd )
::PostMessage( pWnd->m_hWnd, WM_STATUSADD, ( WPARAM ) msg, MAKELPARAM(level, showDialog ? 1 : 0));
else
delete [ ] msg;
}
void CP4winApp::StatusAdd( CStringArray *pArray, StatusView level, bool showDialog )
{
// get out if we call with garbage or an empty string
//
if ( pArray == NULL )
return;
// don't post the message until we get a window. since i
// put up messages constantly, i can easily post before a
// window is up. this is cheesy, but simpler than doing an
// onidle(), and after all, these are just boring status messages.
//
CWnd *pWnd = AfxGetApp( )->m_pMainWnd;
if ( pWnd )
::PostMessage( pWnd->m_hWnd, WM_STATUSADDARRAY, ( WPARAM ) pArray, MAKELPARAM(level, showDialog ? 1 : 0));
else
delete [ ] pArray;
}
void CP4winApp::WinHelp(DWORD dwData, UINT nCmd)
{
// MFC automatically assigns help IDs for all menu commands,
// dialogs and frames (see p4win.hm as produced by makehelp.bat).
// For the time being, only helpIDs that come from the p4win.hh
// file (sequential IDs that start at 1) will be taken as context
// help. Every other help request will be sent to the help contents.
//
// TODO: The menu commands (0x10001 to 0x1ffff) could all have popup
// context menues. But if a single menu command help id is
// missing in the help file, there will be an ugly message
// for the user.
//
// An alternative is to direct all menu command IDs to a single
// topic in the help file
//
// Yet another option is to use the IDs in p4win.hm for everything
// and then set up enough aliases so that nothing falls thru. The
// robohelp help compiler warns about .hm entries that dont have
// topics.
if(dwData < 0x10000 && nCmd != HH_HELP_FINDER)
CWinApp::HtmlHelp(dwData, HH_HELP_CONTEXT);
else
CWinApp::HtmlHelp(dwData, HH_HELP_FINDER);
}
// Spawn a helper app. For console applications, a batch file is used to ensure
// that filename arguments with ebmedded spaces are passed correctly.
BOOL CP4winApp::RunApp(int app, RunAppMode mode, HWND hWnd, BOOL isUnicode,
RUNAPPTHREADINFO *lprati, CString &errorText,
LPCTSTR arg1, LPCTSTR arg2, LPCTSTR arg3, LPCTSTR arg4,
LPCTSTR arg5, LPCTSTR arg6, LPCTSTR arg7, LPCTSTR arg8,
LPCTSTR arg9, LPCTSTR arg10,LPCTSTR arg11,LPCTSTR arg12,
LPCTSTR arg13,LPCTSTR arg14,LPCTSTR arg15,LPCTSTR arg16,
LPCTSTR arg17)
{
CString orgArgX;
CString orgArgY;
TCHAR buf1[LONGPATH*2 + 1];
TCHAR buf2[LONGPATH + 1];
TCHAR buf3[LONGPATH + 1];
TCHAR buf4[LONGPATH + 1];
TCHAR buf5[LONGPATH + 1];
int i;
// Find out if we're running NT or win95
OSVERSIONINFO osVer;
osVer.dwOSVersionInfoSize= sizeof(OSVERSIONINFO);
GetVersionEx(&osVer);
// Set up the spawn operation
#ifdef UNICODE
DWORD dwCreationFlags = NORMAL_PRIORITY_CLASS | CREATE_UNICODE_ENVIRONMENT;
#else
DWORD dwCreationFlags = NORMAL_PRIORITY_CLASS;
#endif
PROCESS_INFORMATION procInfo;
STARTUPINFO startInfo;
TCHAR cmdTitle[255];
GetStartupInfo(&startInfo);
startInfo.lpReserved= startInfo.lpDesktop= NULL;
startInfo.dwFlags |= STARTF_USESHOWWINDOW;
startInfo.wShowWindow = SW_SHOWNORMAL;
// Find out what app we're running
CString appName, appText, title;
int numArgs = 0;
int bInternal = 0;
BOOL isConsole=FALSE;
BOOL isClose=FALSE;
BOOL bSquid=FALSE;
switch(app)
{
case DIFF_APP:
{
orgArgX = arg4;
orgArgY = arg6;
// First, get the file extension, if any, and find out if
// it has an associated diff for that extension
appName.Empty();
CString extension = GetFilesExtension(arg2);
if (!extension.CompareNoCase(_T("tmp")))
extension = GetFilesExtension(arg1);
if(!extension.IsEmpty())
appName= GET_P4REGPTR()->GetAssociatedDiff(extension);
if (!appName.IsEmpty())
{
bInternal = 0;
CString appProg = appName;
if ((i = appProg.ReverseFind(_T('\\'))) > -1)
appProg = appProg.Right(appProg.GetLength() - i - 1);
if (appProg == _T("P4Diff.exe"))
bInternal = 2;
else if (!appProg.CompareNoCase(_T("Squid.exe")))
bSquid = TRUE;
}
else if ((bInternal = GET_P4REGPTR()->GetDiffInternal()) >= 2)
{
bInternal = 2;
appName= _T("P4Diff.exe");
}
else if (bInternal == 1)
{
if (m_P4Merge && (osVer.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS))
{
appName= _T("P4Merge.exe");
}
else
{
bInternal = 2;
appName= _T("P4Diff.exe");
}
}
else
{
appName= GET_P4REGPTR()->GetDiffApp();
CString appProg = appName;
if ((i = appProg.ReverseFind(_T('\\'))) > -1)
appProg = appProg.Right(appProg.GetLength() - i - 1);
if (appProg == _T("P4Diff.exe"))
bInternal = 2;
else if (!appProg.CompareNoCase(_T("Squid.exe")))
bSquid = TRUE;
else
{
// non-Perforce diff app may require DOS console to work correctly
isConsole= GET_P4REGPTR()->GetDiffAppIsConsole();
isClose = GET_P4REGPTR()->GetDiffAppIsClose();
}
}
appText= LoadStringResource(IDS_APP_DIFF);
title= LoadStringResource(IDS_TITLE_DIFF);
numArgs=2;
if (arg1!=NULL && lstrlen(arg1) > 0)
{
if (*(arg1+1) == _T(':'))
{
if (GetFileAttributes(arg1) == -1)
{
appText.FormatMessage(IDS_DIFF_FILENOTFOUND, arg1);
AddToStatus(appText, SV_ERROR);
return FALSE;
}
}
}
else
{
ASSERT(0);
}
if (arg2!=NULL && lstrlen(arg2) > 0)
{
if (*(arg2+1) == _T(':'))
{
if (GetFileAttributes(arg2) == -1)
{
appText.FormatMessage(IDS_DIFF_FILENOTFOUND, arg2);
AddToStatus(appText, SV_ERROR);
return FALSE;
}
}
}
else
{
ASSERT(0);
}
if (bInternal == 2)
{
ASSERT(arg7==NULL && arg8==NULL && arg9==NULL);
switch (GET_P4REGPTR()->GetWhtSpFlag())
{
case 1:
arg7 = _T("-b");
break;
case 2:
arg7 = _T("-w");
break;
default:
arg7 = _T("-e");
break;
}
_stprintf(buf1, _T("%d"), -1); // Temp until implment passing context
_stprintf(buf2, _T("%d"), GET_P4REGPTR()->GetTabWidth());
arg8 = buf1;
arg9 = buf2;
// On win/9x, we can't have a nice long command line - throw away -r and -l
if (!arg3 || (osVer.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS))
{
arg3 = arg7;
arg4 = arg8;
arg5 = arg9;
arg6 = NULL;
numArgs=5;
}
else if (!arg5)
{
ASSERT(arg3!=NULL && lstrlen(arg3) > 0);
ASSERT(arg4!=NULL && lstrlen(arg4) > 0);
arg5 = arg7;
arg6 = arg8;
arg7 = arg9;
arg8 = NULL;
numArgs=7;
}
else
numArgs=9;
}
else if (bInternal)
{
ASSERT(arg7==NULL && arg8==NULL && arg9==NULL);
LPCTSTR sav1 = arg1;
LPCTSTR sav2 = arg2;
LPCTSTR sav4 = arg4;
LPCTSTR sav6 = arg6;
switch (GET_P4REGPTR()->GetWhtSpFlag())
{
case 0:
arg1 = _T("-dl");
break;
case 1:
arg1 = _T("-db");
break;
case 2:
arg1 = _T("-dw");
break;
case 3:
arg1 = _T("-da");
break;
default:
arg1 = _T(" ");
break;
}
_stprintf(buf1, _T("%d"), GET_P4REGPTR()->GetTabWidth());
arg2 = _T("-tw");
arg3 = buf1;
arg4 = _T("-nl");
arg5 = sav4 ? sav4 : sav1;
arg6 = _T("-nr");
arg7 = sav6 ? sav6 : sav2;
arg8 = sav1;
arg9 = sav2;
numArgs=9;
}
else if (bSquid)
{
// On win/9x, we can't have a nice long command line - throw away -r and -l
if (!arg3 || (osVer.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS))
{
arg3 = arg4 = arg5 = arg6 = NULL;
numArgs=2;
}
else
numArgs = arg5 ? 6 : 4;
}
break;
}
case EDIT_APP:
appName= GET_P4REGPTR()->GetEditApp();
appText= LoadStringResource(IDS_APP_EDITOR);
title.FormatMessage(IDS_TITLE_EDITOR_s, appName);
numArgs=1;
isConsole= GET_P4REGPTR()->GetEditAppIsConsole();
// isClose = GET_P4REGPTR()->GetEditAppIsClose();
ASSERT(arg1!=NULL && lstrlen(arg1) > 0);
ASSERT(arg2==NULL && arg3==NULL && arg4==NULL);
break;
case TREE_APP:
#ifdef UNICODE
switch(MainFrame()->HaveP4QTree())
{
default:
case 1:
if (MainFrame()->GetP4Vver() < 20051)
{
DWORD ver = MainFrame()->GetP4Vver();
DWORD yr = ver / 10;
DWORD pt = ver - (yr*10);
CString txt;
txt.FormatMessage(IDS_P4VTOOOLD, yr, pt, _T("2005.1"));
AfxMessageBox(txt, MB_ICONEXCLAMATION);
return FALSE;
}
appName= _T("p4v.exe");
startInfo.wShowWindow = SW_SHOWNORMAL;
ASSERT(arg10 !=NULL && lstrlen(arg10) > 0);
ASSERT(arg15==NULL);
numArgs = (arg11 == NULL) ? 10 : (arg13 == NULL) ? 12 : 14;
switch(numArgs)
{
case 10:
if (WideCharToMultiByte(CP_UTF8, 0, arg10, -1,
(LPSTR)buf2, sizeof(buf2), NULL, NULL)
&& MultiByteToWideChar(1252, 0, (LPSTR)buf2, -1, buf1, sizeof(buf1)))
arg10 = buf1;
break;
case 12:
if (WideCharToMultiByte(CP_UTF8, 0, arg12, -1,
(LPSTR)buf2, sizeof(buf2), NULL, NULL)
&& MultiByteToWideChar(1252, 0, (LPSTR)buf2, -1, buf1, sizeof(buf1)))
arg12 = buf1;
break;
case 14:
if (WideCharToMultiByte(CP_UTF8, 0, arg14, -1,
(LPSTR)buf2, sizeof(buf2), NULL, NULL)
&& MultiByteToWideChar(1252, 0, (LPSTR)buf2, -1, buf1, sizeof(buf1)))
arg14 = buf1;
break;
default:
ASSERT(0);
break;
}
break;
case 2:
appName= _T("p4tree.exe");
startInfo.wShowWindow = SW_SHOWMAXIMIZED;
ASSERT(arg9 !=NULL && lstrlen(arg9) > 0);
ASSERT(arg14==NULL);
numArgs = (arg10 == NULL) ? 9 : (arg12 == NULL) ? 11 : 13;
break;
case 3:
appName= _T("P4QTree.exe");
startInfo.wShowWindow = SW_SHOWMAXIMIZED;
ASSERT(arg9 !=NULL && lstrlen(arg9) > 0);
ASSERT(arg14==NULL);
numArgs = (arg10 == NULL) ? 9 : (arg12 == NULL) ? 11 : 13;
break;
}
appText= LoadStringResource(IDS_APP_TREE);
title.FormatMessage(IDS_TITLE_EDITOR_s, appName); // Can use the same string as the editor
break;
#else
return FALSE;
#endif
case ANNOTATE_APP:
#ifdef UNICODE
if (MainFrame()->HaveTLV())
{
if (MainFrame()->GetP4Vver() < 20051)
{
DWORD ver = MainFrame()->GetP4Vver();
DWORD yr = ver / 10;
DWORD pt = ver - (yr*10);
CString txt;
txt.FormatMessage(IDS_P4VTOOOLD, yr, pt, _T("2005.1"));
AfxMessageBox(txt, MB_ICONEXCLAMATION);
return FALSE;
}
appName= _T("p4v.exe");
startInfo.wShowWindow = SW_SHOWNORMAL;
ASSERT(arg10 !=NULL && lstrlen(arg10) > 0);
ASSERT(arg15==NULL);
numArgs = (arg11 == NULL) ? 10 : (arg13 == NULL) ? 12 : 14;
switch(numArgs)
{
case 10:
if (WideCharToMultiByte(CP_UTF8, 0, arg10, -1,
(LPSTR)buf2, sizeof(buf2), NULL, NULL)
&& MultiByteToWideChar(1252, 0, (LPSTR)buf2, -1, buf1, sizeof(buf1)))
arg10 = buf1;
break;
case 12:
if (WideCharToMultiByte(CP_UTF8, 0, arg12, -1,
(LPSTR)buf2, sizeof(buf2), NULL, NULL)
&& MultiByteToWideChar(1252, 0, (LPSTR)buf2, -1, buf1, sizeof(buf1)))
arg12 = buf1;
break;
case 14:
if (WideCharToMultiByte(CP_UTF8, 0, arg14, -1,
(LPSTR)buf2, sizeof(buf2), NULL, NULL)
&& MultiByteToWideChar(1252, 0, (LPSTR)buf2, -1, buf1, sizeof(buf1)))
arg14 = buf1;
break;
default:
ASSERT(0);
break;
}
}
startInfo.wShowWindow = SW_SHOWNORMAL;
appText= LoadStringResource(IDS_APP_TREE);
title.FormatMessage(IDS_TITLE_EDITOR_s, appName); // Can use the same string as the editor
break;
#else
return FALSE;
#endif
case MERGE_APP:
{
orgArgX = arg3;
orgArgY = arg5;
ASSERT(arg1!=NULL && lstrlen(arg1) > 0);
ASSERT(arg2!=NULL && lstrlen(arg2) > 0);
ASSERT(arg3!=NULL && lstrlen(arg3) > 0);
ASSERT(arg4!=NULL && lstrlen(arg4) > 0);
// First, get the file extension, if any, and find out if
// it has an associated Merge for that extension
appName.Empty();
CString extension = GetFilesExtension(arg3);
if (!extension.CompareNoCase(_T("tmp")))
extension = GetFilesExtension(arg2);
if (!extension.CompareNoCase(_T("tmp")))
extension = GetFilesExtension(arg1);
if(!extension.IsEmpty())
appName= GET_P4REGPTR()->GetAssociatedMerge(extension);
if (!appName.IsEmpty())
{
numArgs=4;
bInternal=0;
}
else
{
bInternal = GET_P4REGPTR()->GetMergeInternal();
switch (bInternal)
{
case 0:
{
appName= GET_P4REGPTR()->GetMergeApp();
CString appProg = appName;
if ((i = appProg.ReverseFind(_T('\\'))) > -1)
appProg = appProg.Right(appProg.GetLength() - i - 1);
if ((appProg == _T("P4WinMrg.exe")) && (appName.Find(_T("raxis")) == -1))
bInternal = 1;
else
{
isConsole= GET_P4REGPTR()->GetMergeAppIsConsole();
isClose = GET_P4REGPTR()->GetMergeAppIsClose();
numArgs=4;
}
break;
}
default:
case 2:
{
if (m_P4Merge && (osVer.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS))
{
appName= _T("P4Merge.exe");
break;
}
bInternal = 1;
}
case 1:
appName= _T("P4WinMrg.exe");
break;
}
}
if (bInternal == 1)
{
BOOL bNSF = GET_P4REGPTR()->GetMergeNSF();
isConsole = isClose = FALSE;
LPCTSTR svArg = arg5;
arg9 = arg4; // result
arg8 = arg3; // yours
arg7 = arg2; // theirs
arg6 = arg1; // base
switch (GET_P4REGPTR()->GetMrgWhtSpFlag())
{
case 1:
arg5 = _T("-b");
break;
case 2:
arg5 = _T("-w");
break;
default:
arg5 = _T("-s");
break;
}
lstrcpy(buf4, m_bNoCRLF ? _T("-lf") : _T("-crlf"));
_stprintf(buf3, _T("\"-i%d\""), GET_P4REGPTR()->GetMrgTabWidth());
if(bNSF)
lstrcpy(buf2, _T("-nsf"));
else
{
CString msg;
msg.FormatMessage(IDS_WILL_REPLACE_s_IF_MERGE_ACCEPTED, arg8); // yours
lstrcpy(buf2, msg);
}
_stprintf(buf1, _T("\"-t%s\""), svArg);
arg4 = buf4;
arg3 = buf3;
arg2 = buf2;
arg1 = buf1;
numArgs=9;
}
else if (bInternal)
{
isConsole = isClose = FALSE;
LPCTSTR svArg = arg5;
arg17 = arg4; // result
arg16 = arg3; // yours
arg15 = arg2; // theirs
arg14 = arg1; // base
switch (GET_P4REGPTR()->GetMrgWhtSpFlag())
{
case 0:
arg13 = _T("-dl");
break;
case 1:
arg13 = _T("-db");
break;
case 2:
arg13 = _T("-dw");
break;
case 3:
arg13 = _T("-da");
break;
default:
arg13 = _T(" ");
break;
}
_stprintf(buf5, _T("\"%s\""), *arg6 ? arg6 : arg14);
_stprintf(buf4, _T("%d"), GET_P4REGPTR()->GetMrgTabWidth());
CString msg;
msg.FormatMessage(IDS_WILL_REPLACE_s_IF_MERGE_ACCEPTED, arg16); // yours
if (msg.GetAt(0) == _T('-') && msg.GetAt(1) == _T('m'))
msg = msg.Mid(2);
lstrcpy(buf3, msg);
_stprintf(buf2, _T("\"%s\""), arg16);
_stprintf(buf1, _T("\"%s\""), svArg);
arg12 = m_bNoCRLF ? _T("unix") : _T("win");
arg11 = _T("-le");
arg10 = buf4;
arg9 = _T("-tw");
arg8 = buf3;
arg7 = _T("-nm");
arg6 = buf2;
arg5 = _T("-nr");
arg4 = buf1;
arg3 = _T("-nl");
arg2 = buf5;
arg1 = _T("-nb");
numArgs=17;
}
appText= LoadStringResource(IDS_APP_MERGE);
title.FormatMessage(IDS_TITLE_MERGE, appName);
break;
}
case P4_APP:
appName= _T("p4");
appText= LoadStringResource(IDS_APP_P4);
title.FormatMessage(IDS_TITLE_P4, appName);
ASSERT(arg1!=NULL && lstrlen(arg1) > 0);
ASSERT(arg2!=NULL && lstrlen(arg2) > 0);
ASSERT(arg3!=NULL && lstrlen(arg3) > 0);
ASSERT(arg4!=NULL && lstrlen(arg4) > 0);
ASSERT(arg5!=NULL && lstrlen(arg5) > 0);
ASSERT(arg6!=NULL && lstrlen(arg6) > 0);
ASSERT(arg7!=NULL && lstrlen(arg7) > 0);
for (numArgs = 7; ++numArgs < 14; )
{
if (numArgs == 8)
{
if (!arg9)
break;
}
else if (numArgs == 9)
{
if (!arg10)
break;
}
else if (numArgs == 10)
{
if (!arg11)
break;
}
else if (numArgs == 11)
{
if (!arg12)
break;
}
else if (numArgs == 12)
{
if (!arg13)
break;
}
else if (numArgs == 13)
{
if (!arg14)
break;
}
}
startInfo.dwFlags = STARTF_USESHOWWINDOW;
startInfo.wShowWindow = SW_SHOWNORMAL;
dwCreationFlags |= CREATE_NEW_CONSOLE;
break;
default:
ASSERT(0);
return FALSE;
}
if(isConsole)
{
lstrcpy(cmdTitle, title);
startInfo.lpTitle= cmdTitle;
startInfo.dwXCountChars=80;
startInfo.dwYCountChars=1000;
startInfo.dwFlags=STARTF_USECOUNTCHARS;
startInfo.cbReserved2=0;
startInfo.lpReserved2=NULL;
}
// If we drew a blank for the appname, return the error
if(appName.GetLength()==0)
{
errorText.FormatMessage(IDS_MISSING_APPNAME_s_s, appText, appText);
return FALSE;
}
// Copy the arguments, and make sure args with embedded spaces have quotes
// this is primitive, but it saves code in calling functions
CString args[17];
args[0]=arg1;
if(numArgs > 1)
{
args[1]=arg2;
if(numArgs > 2)
{
args[2]=arg3;
if(numArgs > 3)
{
args[3]=arg4;
if(numArgs > 4)
{
args[4]=arg5;
if(numArgs > 5)
{
args[5]=arg6;
if(numArgs > 6)
{
args[6]=arg7;
if(numArgs > 7)
{
args[7]=arg8;
if(numArgs > 8)
{
args[8]=arg9;
if(numArgs > 9)
{
args[9]=arg10;
if(numArgs > 10)
{
args[10]=arg11;
if(numArgs > 11)
{
args[11]=arg12;
if(numArgs > 12)
{
args[12]=arg13;
if(numArgs > 13)
{
args[13]=arg14;
if(numArgs > 14)
{
args[14]=arg15;
if(numArgs > 15)
{
args[15]=arg16;
if(numArgs > 16)
{
args[16]=arg17;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
for(i=0; i<numArgs; i++)
{
args[i].TrimRight();
args[i].TrimLeft();
if(args[i].Find(_T(' ')) != -1 && args[i][0] != _T('\"'))
{
TCHAR buf[1024];
lstrcpy(buf, args[i]);
args[i].Format(_T("\"%s\""), buf);
}
}
appName.TrimRight();
appName.TrimLeft();
if(appName.Find(_T(' ')) != -1 && appName[0] != _T('\"'))
{
TCHAR buf[1024];
lstrcpy(buf, appName);
appName.Format(_T("\"%s\""), buf);
}
// Pass the P4CHARSET to P4Merge.exe if its version is 2005.2 or later and have Unicode files
CString appFileName;
if ((i = appName.ReverseFind(_T('\\'))) != -1)
appFileName = appName.Mid(i+1);
else
appFileName = appName;
if (isUnicode && !appFileName.CollateNoCase(_T("P4Merge.exe")) && m_P4MergeVer >= 20052)
{
CString charset;
if (isUnicode == 16)
charset = _T("utf16");
else
charset = GET_P4REGPTR()->GetP4Charset();
if (charset.GetLength() > 0)
appName += _T(" -C ") + charset + _T(" ");
}
BOOL success;
TCHAR commandLine[1024];
CString tempFile;
// Set up the command line
CString commLine=appName;
i = 0;
if (app == DIFF_APP)
{
if (!GET_P4REGPTR()->GetDiffInternal()
&& GET_P4REGPTR()->GetDiffAppOptArgChk()
&& *(GET_P4REGPTR()->GetDiffOptArgs()))
{
CString optArgs = GET_P4REGPTR()->GetDiffOptArgs();
optArgs.Replace(_T("%1"), _T("%#1"));
optArgs.Replace(_T("%2"), _T("%#2"));
optArgs.Replace(_T("%L"), _T("%#L"));
optArgs.Replace(_T("%R"), _T("%#R"));
commLine += CString(_T(" ")) + optArgs;
i = commLine.Replace(_T("%#1"), args[0]);
i *= commLine.Replace(_T("%#2"), args[1]);
commLine.Replace(_T("%#L"), orgArgX);
commLine.Replace(_T("%#R"), orgArgY);
_stprintf(buf2, _T("%d"), GET_P4REGPTR()->GetTabWidth());
commLine.Replace(_T("%W"), buf2);
}
}
else if (app == MERGE_APP)
{
if (!GET_P4REGPTR()->GetMergeInternal()
&& GET_P4REGPTR()->GetMergeAppOptArgChk()
&& *(GET_P4REGPTR()->GetMergeOptArgs()))
{
CString optArgs = GET_P4REGPTR()->GetMergeOptArgs();
commLine += CString(_T(" ")) + optArgs;
optArgs.Replace(_T("%1"), _T("%#1"));
optArgs.Replace(_T("%2"), _T("%#2"));
optArgs.Replace(_T("%3"), _T("%#3"));
optArgs.Replace(_T("%4"), _T("%#4"));
optArgs.Replace(_T("%T"), _T("%#T"));
optArgs.Replace(_T("%Y"), _T("%#Y"));
i = commLine.Replace(_T("%1"), args[0]);
i *= commLine.Replace(_T("%2"), args[1]);
i *= commLine.Replace(_T("%3"), args[2]);
i *= commLine.Replace(_T("%4"), args[3]);
orgArgY.TrimLeft();
commLine.Replace(_T("%T"), orgArgY);
commLine.Replace(_T("%Y"), orgArgX);
_stprintf(buf2, _T("%d"), GET_P4REGPTR()->GetMrgTabWidth());
commLine.Replace(_T("%W"), buf2);
}
}
if (!i)
{
for(i=0; i<numArgs; i++)
commLine+=_T(" ")+args[i];
}
/* We have to do nasty things with the system settings to fool win/2k/xp/98
into bringing the correct window to the foreground after a spawn with wait
finishes. Starting with Windows 98 & Windows 2000 the OS restricts which
processes can set the foreground window. A process can set the
foreground window only if certain conditions are met - none of which
can be met after a spawn with wait finishes. Therefore change the
system setting that controls this new, useless behavior to disable it
before the spawn is done; then restore the previous settings after
the correct window has been brought to the foreground. Furthermore we
have to use the actual value of SPI_*ETFOREGROUNDLOCKTIMEOUT rather
than the defines because they are not defined on NT.
*/
DWORD dwLockTimeout = 0;
SystemParametersInfo(0x2000 /*==SPI_GETFOREGROUNDLOCKTIMEOUT*/, NULL, &dwLockTimeout, NULL);
if (dwLockTimeout && (mode == RA_WAIT))
SystemParametersInfo(0x2001 /*==SPI_SETFOREGROUNDLOCKTIMEOUT*/, 0, (LPVOID)0, SPIF_SENDWININICHANGE | SPIF_UPDATEINIFILE);
if(isConsole)
{
// Win95 command shell does not have a scrollable screen buffer,
// so pipe diff results to more by using a batch file
if((osVer.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) && (app == DIFF_APP))
{
TCHAR tempPath[LONGPATH];
HANDLE h=0;
commLine+=_T(" | more");
if(GetTempPath(LONGPATH, tempPath) == 0)
{
errorText.FormatMessage(IDS_COULD_NOT_RUN_s_TEMP_COMMAND_PATH_ERROR, appText);
if (dwLockTimeout && (mode == RA_WAIT))
SystemParametersInfo(0x2001 /*==SPI_SETFOREGROUNDLOCKTIMEOUT*/, 0, (LPVOID)dwLockTimeout, SPIF_SENDWININICHANGE | SPIF_UPDATEINIFILE);
return FALSE;
}
for(i=0; i<100; i++)
{
tempFile.Format(_T("%sP4W%05ld.BAT"), tempPath, i);
h=CreateFile(tempFile, GENERIC_WRITE, 0, 0, CREATE_NEW, 0, 0);
if(h != INVALID_HANDLE_VALUE)
break;
}
if(i==100)
{
errorText.FormatMessage(IDS_COULD_NOT_RUN_s_COULD_NOT_OPEN_TEMP_COMMAND_FILE, appText);
if (dwLockTimeout && (mode == RA_WAIT))
SystemParametersInfo(0x2001 /*==SPI_SETFOREGROUNDLOCKTIMEOUT*/, 0, (LPVOID)dwLockTimeout, SPIF_SENDWININICHANGE | SPIF_UPDATEINIFILE);
return FALSE;
}
DWORD numWrite;
if(!WriteFile(h, commLine, lstrlen(commLine), &numWrite, 0))
{
CloseHandle(h);
errorText.FormatMessage(IDS_COULD_NOT_RUN_s_COULD_NOT_WRITE_TEMP_COMMAND_FILE, appText);
if (dwLockTimeout && (mode == RA_WAIT))
SystemParametersInfo(0x2001 /*==SPI_SETFOREGROUNDLOCKTIMEOUT*/, 0, (LPVOID)dwLockTimeout, SPIF_SENDWININICHANGE | SPIF_UPDATEINIFILE);
return FALSE;
}
CloseHandle(h);
commLine = tempFile;
}
else
{
TCHAR cmd[MAX_PATH+1];
GetEnvironmentVariable(_T("ComSpec"), cmd, MAX_PATH);
commLine = (CString)cmd + (isClose ? _T(" /c start /wait ") : _T(" /k ")) + commLine;
}
lstrcpy(commandLine, commLine);
SetLastError(0);
success=CreateProcess( NULL, // pointer to name of executable module
commandLine, // pointer to command line string
NULL, NULL, // default security rot
FALSE, // handle inheritance flag
dwCreationFlags | CREATE_NEW_CONSOLE, // creation flags
NULL, NULL, //default env and curdir
&startInfo, &procInfo);
}
else
{
SetLastError(0);
lstrcpy(commandLine, commLine);
success=CreateProcess( NULL, // pointer to name of executable module
commandLine, // pointer to command line string
NULL, NULL, // default security rot
FALSE, // handle inheritance flag
dwCreationFlags, // creation flags
NULL, // env
NULL, //default dir
&startInfo, &procInfo);
}
if(success)
{
if(mode == RA_WAIT)
{
CString oldtext;
CString newtext;
newtext.FormatMessage(IDS_WAITING_FOR_s_TO_FINISH, appName);
// Let the user know what we aren't responding
//
AfxGetMainWnd()->GetWindowText(oldtext);
AfxGetMainWnd()->SetWindowText(newtext);
// Disable the main window and any topmost dialog
//
BOOL bReEnableMain = app == MERGE_APP;
if (AfxGetMainWnd()->IsWindowEnabled())
{
EnableWindow( AfxGetMainWnd()->GetSafeHwnd(), FALSE );
bReEnableMain = TRUE;
}
BOOL bReEnable = FALSE;
// if we weren't given a topmost dialog, see if we can figure it out
if (!hWnd)
{
CWnd *pWnd= AfxGetMainWnd()->GetForegroundWindow(); // get the foreground window
if (pWnd->GetWindow(GW_OWNER) == AfxGetMainWnd()) // make sure it's ours!
hWnd = pWnd->GetSafeHwnd();
}
if (hWnd)
{
EnableWindow( hWnd, FALSE );
bReEnable = TRUE;
}
::ShowWindow(MainFrame()->m_hWnd, SW_SHOWMINNOACTIVE);
// Wait for the spawned app
//
while (WaitForSingleObject( procInfo.hProcess, 1000 ) == WAIT_TIMEOUT)
{
MSG msg;
while ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
{
if ( msg.message == WM_COMMAND ) // ignore all commands
continue;
if ( msg.message == WM_TIMER ) // Don't poll while waiting
MainFrame()->WaitAWhileToPoll( );
TranslateMessage(&msg);
DispatchMessage(&msg);
if ( msg.message == WM_QUIT ) // get out if app is terminating
break;
}
}
CloseHandle(procInfo.hProcess);
// Re-enable the windows
//
if (bReEnable)
::ShowWindow(hWnd, SW_RESTORE);
if (bReEnableMain)
{
::EnableWindow( AfxGetMainWnd()->GetSafeHwnd(), TRUE );
::SetForegroundWindow( AfxGetMainWnd()->GetSafeHwnd() );
::SetFocus( AfxGetMainWnd()->GetSafeHwnd() );
}
if (bReEnable)
{
::EnableWindow( hWnd, TRUE );
::SetForegroundWindow( hWnd );
::SetFocus( hWnd );
}
AfxGetMainWnd()->SetWindowText(oldtext);
::ShowWindow(MainFrame()->m_hWnd, SW_RESTORE);
::SendMessage(MainFrame()->m_hWnd, m_WM_ACTIVATE, 0, 0);
}
else if (mode == RA_THREAD || mode == RA_THREADWAIT)
{
// Give the spawned program time to get initalized
WaitForInputIdle(procInfo.hProcess, 1000);
Sleep(1000); // And since WaitForInputIdle() is not reliable, wait some more
// Now fire up the thread which will delete the temp file(s);
// this thread does WaitForSingleObject(procInfo.hProcess, INFINITE)
// before deleting any files. It also calls CloseHandle(procInfo.hProcess)
lprati->hProcess = procInfo.hProcess;
CWinThread *pTaskThread=AfxBeginThread(lprati->pfnThreadProc,
(LPVOID) lprati, THREAD_PRIORITY_NORMAL,
0, CREATE_SUSPENDED, NULL);
pTaskThread->m_bAutoDelete=TRUE; // Tinker w/ priority here if reqd
pTaskThread->ResumeThread();
// If the mode is RA_THREADWAIT, wait until the spawned process exits
if (mode == RA_THREADWAIT)
{
Sleep(333);
ShowWindow(m_pMainWnd->m_hWnd, SW_HIDE);
WaitForSingleObject( procInfo.hProcess, INFINITE );
// Window is NOT re-shown because RA_THREADWAIT is only used
// when P4Win is run with the -D [filename] flag.
// P4Win will now exit since the Diff program has exited.
}
}
else
CloseHandle(procInfo.hProcess);
// procInfo.hProcess was close by each of the 3 cases above,
// but we still must close procInfo.hThread.
CloseHandle(procInfo.hThread);
// Note: checking exit codes is futile.
// CMD and COMMAND return random numbers, no matter what happens
}
else
{
CString errTxt;
DWORD error=GetLastError();
if(error)
{
LPVOID lpMsgBuf;
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
error,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
(LPTSTR) &lpMsgBuf,
0,
NULL
);
errTxt = (TCHAR *)lpMsgBuf;
errTxt.TrimRight();
}
else
errTxt=LoadStringResource(IDS_UNKNOWN_ERROR);
errorText.FormatMessage(IDS_FAILED_TO_EXECUTE_s_s_s_n, appText, appName, errTxt, error);
if (commLine.GetLength() > 127)
{
// Find out if we're running NT or win95
OSVERSIONINFO osVer;
osVer.dwOSVersionInfoSize= sizeof(OSVERSIONINFO);
GetVersionEx(&osVer);
BOOL brittleWare= (osVer.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS);
if(brittleWare)
errTxt.FormatMessage(IDS_s_COMMAND_LINE_TOO_LONG_FOR_WIN9X_s_n,
appText, commLine, commLine.GetLength());
else
errTxt.FormatMessage(IDS_CHECK_PERFORCE_OPTIONS_s, appText);
}
else
errTxt.FormatMessage(IDS_CHECK_PERFORCE_OPTIONS_s, appText);
errorText += errTxt;
}
// restore previous system setting (see comment above,
// at 1st call to SystemParametersInfo(), for details)
if (dwLockTimeout && (mode == RA_WAIT))
SystemParametersInfo(0x2001 /*==SPI_SETFOREGROUNDLOCKTIMEOUT*/, 0, (LPVOID)dwLockTimeout, SPIF_SENDWININICHANGE | SPIF_UPDATEINIFILE);
if(isConsole && !tempFile.IsEmpty())
_tunlink(tempFile);
return success;
}
// Spawn a viewer. App is referenced by name, and console apps will not be catered to.
// This is a stripped down version of CP4WinApp::RunApp()
BOOL CP4winApp::RunViewerApp(LPCTSTR app, LPCTSTR fileName)
{
if( app==NULL || lstrlen(app) == 0 ||
fileName==NULL || lstrlen(fileName) == 0)
{
// Dont ASSERT(0); since this error occurrs for any binary file w/ no associated app
return FALSE;
}
// Set up the spawn operation
PROCESS_INFORMATION procInfo;
STARTUPINFO startInfo;
GetStartupInfo(&startInfo);
startInfo.lpReserved= startInfo.lpDesktop= NULL;
startInfo.dwFlags |= STARTF_USESHOWWINDOW;
startInfo.wShowWindow = SW_SHOWNORMAL;
CString arg=fileName;
arg.TrimRight();
arg.TrimLeft();
if(arg.Find(_T(' ')) != -1 && arg[0] != _T('\"'))
{
TCHAR buf[1024];
lstrcpy(buf, arg);
arg.Format(_T("\"%s\""), buf);
}
CString appName=app;
appName.TrimRight();
appName.TrimLeft();
if(appName.Find(_T(' ')) != -1 && appName[0] != _T('\"'))
{
TCHAR buf[1024];
lstrcpy(buf, appName);
appName.Format(_T("\"%s\""), buf);
}
// Set up the command line
CString commLine=appName;
commLine+=_T(" ")+arg;
BOOL success=CreateProcess( NULL, // pointer to name of executable module
const_cast<LPTSTR>((LPCTSTR)commLine), // pointer to command line string
NULL, NULL, // default security rot
FALSE, // handle inheritance flag
#ifdef UNICODE
NORMAL_PRIORITY_CLASS | CREATE_UNICODE_ENVIRONMENT,
#else
NORMAL_PRIORITY_CLASS, // creation flags
#endif
NULL, NULL, //default env and curdir
&startInfo, &procInfo);
if(success)
{
// Note: checking exit codes is futile. CMD and COMMAND return random numbers, no
// matter what happens
CloseHandle(procInfo.hProcess);
CloseHandle(procInfo.hThread);
}
return success;
}
/////////////////////////////////////////////////////////////////////////////////
// Minor text formatting functions used throughout app, so multiline edit boxes
// can translate text with embedded tabs, as generated by command line clients
// Utility function to remove tabs and replace all LF's with CR-LFs
CString RemoveTabs(LPCTSTR text)
{
SET_BUSYCURSOR();
CString out=text; // avoid billions of re-allocs by setting approx length
out+=text; // then double the length of the buffer
out=""; // and empty the buffer without freeing it
int i=0;
while(text[i] != _T('\0'))
{
if(text[i]!=_T('\t'))
{
if(text[i]==_T('\n') && text[max(0,i-1)]!=_T('\r'))
out += _T("\r\n");
else
out += text[i];
}
i++;
}
// Strip off a trailing newline char
if(out.GetLength() > 0 && out[out.GetLength()-1] == _T('\n'))
out=out.Left(out.GetLength()-2);
return out;
}
CString MakeCRs(LPCTSTR text)
{
// replace LF with CR-LF
// then strip any trailing CR-LFs
int size = lstrlen(text) + 1;
CString out;
LPTSTR pOutBuf = out.GetBufferSetLength(size);
LPTSTR pOut = pOutBuf;
// keep track of where any trailing CRs are located so they can be chopped
// without repeatedly scanning the string (which may be very long)
// this pointer points to the char following the last non-CR character
LPTSTR pLastNonCR = pOut;
// there will be probably be a final realloc, and this is probably a temp
// string anyway, so minimize the number of reallocs rather than the size
const int growBy = 4096;
#ifdef UNICODE
for(LPCTSTR pIn = text; *pIn != _T('\0'); pIn++)
#else
for(LPCTSTR pIn = text; *pIn != _T('\0'); pIn = CharNext(pIn))
#endif
{
// make sure there will be enough room for a character
// even if it is a double byte char, or an expanded CR
if(pOut - pOutBuf + 2 > size - 1)
{
int oldSize = pOut - pOutBuf;
int nLastNonCR = pLastNonCR - pOutBuf;
out.ReleaseBuffer(oldSize);
size += growBy;
pOutBuf = out.GetBufferSetLength(size);
pOut = pOutBuf + oldSize;
pLastNonCR = pOutBuf + nLastNonCR;
}
if(*pIn==_T('\r'))
{
*pOut++ = *pIn;
if(pIn[1] == _T('\n'))
*pOut++ = *++pIn;
else
pLastNonCR = pOut;
}
else if(*pIn==_T('\n'))
{
// a LF with no preceding CR, so insert a CR
*pOut++ = _T('\r');
*pOut++ = _T('\n');
}
else
{
#ifdef UNICODE
*pOut++ = *pIn;
#else
_tccpy(pOut, pIn);
pOut = CharNext(pOut);
#endif
pLastNonCR = pOut;
}
}
// chop off any trailing newline chars
*pLastNonCR = 0;
out.ReleaseBuffer();
return out;
}
CString MakeLFs(LPCTSTR text)
{
// replace CR with CR-LF
// then strip any trailing CR-LFs
int size = lstrlen(text) + 1;
CString out;
LPTSTR pOutBuf = out.GetBufferSetLength(size);
LPTSTR pOut = pOutBuf;
// keep track of where any trailing CRs are located so they can be chopped
// without repeatedly scanning the string (which may be very long)
// this pointer points to the char following the last non-CR character
LPTSTR pLastNonCR = pOut;
// there will be probably be a final realloc, and this is probably a temp
// string anyway, so minimize the number of reallocs rather than the size
const int growBy = 4096;
#ifdef UNICODE
for(LPCTSTR pIn = text; *pIn != _T('\0'); pIn++)
#else
for(LPCTSTR pIn = text; *pIn != _T('\0'); pIn = CharNext(pIn))
#endif
{
// make sure there will be enough room for a character
// even if it is a double byte char, or an expanded CR
if(pOut - pOutBuf + 2 > size - 1)
{
int oldSize = pOut - pOutBuf;
int nLastNonCR = pLastNonCR - pOutBuf;
out.ReleaseBuffer(oldSize);
size += growBy;
pOutBuf = out.GetBufferSetLength(size);
pOut = pOutBuf + oldSize;
pLastNonCR = pOutBuf + nLastNonCR;
}
if(*pIn==_T('\r'))
{
*pOut++ = _T('\r');
*pOut++ = _T('\n');
}
else
{
#ifdef UNICODE
*pOut++ = *pIn;
#else
_tccpy(pOut, pIn);
pOut = CharNext(pOut);
#endif
pLastNonCR = pOut;
}
}
// chop off any trailing newline chars
*pLastNonCR = 0;
out.ReleaseBuffer();
return out;
}
CString UnMakeCRs(LPCTSTR text)
{
// remove any CR characters
// then strip any trailing LFs
int size = lstrlen(text) + 1;
CString out;
LPTSTR pOut = out.GetBufferSetLength(size);
// keep track of where any trailing LFs are located so they can be chopped
// without repeatedly scanning the string (which may be very long)
// this pointer points to the char following the last non-LF character
LPTSTR pLastNonLF = pOut;
#ifdef UNICODE
for(LPCTSTR pIn = text; *pIn != _T('\0'); pIn++)
#else
for(LPCTSTR pIn = text; *pIn != _T('\0'); pIn = CharNext(pIn))
#endif
{
if(*pIn != _T('\r'))
{
if(*pIn == _T('\n'))
*pOut++ = *pIn;
else
{
#ifdef UNICODE
*pOut++ = *pIn;
#else
_tccpy(pOut, pIn);
pOut = CharNext(pOut);
#endif
pLastNonLF = pOut;
}
}
}
// chop off any trailing newline chars
*pLastNonLF = 0;
out.ReleaseBuffer();
return out;
}
CString PadCRs(LPCTSTR text)
{
CString out;
// Replace CR and TABs with spaces. This allows multi-line descriptions
// to be displayed on a single line
int len=lstrlen(text);
LPCTSTR ptr=text;
LPTSTR ptrout=out.GetBuffer(len);
LPTSTR ptrstart = ptrout;
for(int i=0; i<len; i++)
{
if ((*ptr==_T('\r')) || (*ptr==_T('\n')) || (*ptr==_T('\t')))
{
if ((ptrout > ptrstart) && (*(ptrout-1) != _T(' ')))
*ptrout++ = _T(' ');
ptr++;
}
else
{
*ptrout++ = *ptr++;
}
}
*ptrout=_T('\0');
out.ReleaseBuffer();
return out;
}
CString WrapDesc(LPCTSTR text, int maxcol)
{
int count = 0;
int size = lstrlen(text) + 1;
CString out;
CString savestr;
LPTSTR pOut = out.GetBufferSetLength(size*2);
LPTSTR pLastWhite = pOut;
LPTSTR pLWnext = pOut;
LPTSTR pBgnLine = pOut;
LPTSTR p;
for(LPCTSTR pIn = text; *pIn != _T('\0'); )
{
if ((*pIn == _T('\r')) || (*pIn == _T('\n')))
{
count = 0;
pLastWhite = pBgnLine = pOut;
}
if (*pIn <= _T(' '))
pLWnext = pOut;
#ifdef UNICODE
*pOut++ = *pIn++;
#else
_tccpy(pOut, pIn);
pOut = CharNext(pOut);
pIn = CharNext(pIn);
#endif
if ((++count > maxcol) && (pLastWhite != pBgnLine)
&& (*pIn != _T('\r')) && (*pIn != _T('\n')))
{
*pOut = _T('\0');
#ifdef UNICODE
pLastWhite++;
#else
pLastWhite = CharNext(pLastWhite);
#endif
savestr = pLastWhite;
*pLastWhite++ = _T('\r');
*pLastWhite++ = _T('\n');
lstrcpy(pLastWhite, savestr);
pOut = pLastWhite + lstrlen(pLastWhite);
pLWnext = pBgnLine = pLastWhite;
for (count = 0, p = pBgnLine; p < pOut; )
{
#ifdef UNICODE
p++;
#else
p = CharNext(p);
#endif
if ((*p == _T('\r')) || (*p == _T('\n')))
{
count = 0;
pBgnLine = p;
}
else
count++;
if (*p <= _T(' ') && *p)
pLWnext = p;
}
}
pLastWhite = pLWnext;
}
*pOut = _T('\0');
out.ReleaseBuffer();
return out;
}
/////////////////////////////////////////////////
// Utility functions to perform string comparisons according
// to the case-sensitivity of the server
int Compare(LPCTSTR str1, LPCTSTR str2)
{
// If server level not set, we also dont know if server is nocase
ASSERT(GET_SERVERLEVEL());
if(IS_NOCASE())
return _tcsicmp(str1, str2);
else
return _tcscmp(str1, str2);
}
int nCompare(LPCTSTR str1, LPCTSTR str2, int n)
{
// If server level not set, we also dont know if server is nocase
ASSERT(GET_SERVERLEVEL());
if(IS_NOCASE())
return _tcsnicmp(str1, str2, n);
else
return _tcsncmp(str1, str2, n);
}
int nCommon(LPCTSTR str1, LPCTSTR str2)
{
// If server level not set, we also dont know if server is nocase
ASSERT(GET_SERVERLEVEL());
int commonLength=0;
LPCTSTR ptr1= str1;
LPCTSTR ptr2= str2;
if(IS_NOCASE())
while( (TBYTE)CharUpper((LPTSTR)(TBYTE)*ptr1) == (TBYTE)CharUpper((LPTSTR)(TBYTE)*ptr2) &&
*ptr1 != _T('\0') && *ptr2 != _T('\0'))
{
commonLength++;
ptr1++;
ptr2++;
}
else
while( *ptr1 == *ptr2 && *ptr1 != _T('\0') && *ptr2 != _T('\0'))
{
commonLength++;
ptr1++;
ptr2++;
}
return commonLength;
}
void TrimRightMBCS(CString &str, TCHAR *chars)
{
#ifdef UNICODE
str.TrimRight(chars);
#else
int len;
LPTSTR pBuf = str.GetBuffer(len = str.GetLength());
TCHAR *pchBgn = (TCHAR *)pBuf;
TCHAR *pchLst = _tcsdec(pchBgn, pchBgn + len);
BOOL b = TRUE;
while (b)
{
b = FALSE;
for (TCHAR *pchChk = chars; *pchChk; pchChk = _tcsinc(pchChk))
{
if (*pchChk == *pchLst)
{
*pchLst = _T('\0');
pchLst = _tcsdec(pchBgn, pchLst);
b = TRUE;
break;
}
}
}
str.ReleaseBuffer(-1);
#endif
}
// This functions assumes that oldchar and newchar are the same width!
// Since this is used to replace \ with /, this works fine.
void ReplaceMBCS(CString &str, TCHAR oldchar, TCHAR newchar)
{
#ifdef UNICODE
str.Replace(oldchar, newchar);
#else
#ifdef _DEBUG
TCHAR oldbuf[8];
TCHAR newbuf[8];
memset(oldbuf, _T('\0'), sizeof(oldbuf));
memset(newbuf, _T('\0'), sizeof(newbuf));
oldbuf[0] = oldchar;
newbuf[0] = newchar;
ASSERT(lstrlen(oldbuf) == lstrlen(newbuf));
#endif
LPTSTR pBuf = str.GetBuffer(str.GetLength());
for (TCHAR *pch = (TCHAR *)pBuf; *pch; pch = _tcsinc(pch))
{
if (*pch == oldchar)
*pch = newchar;
}
str.ReleaseBuffer(-1);
#endif
}
int FindMBCS(CString &str, TCHAR findchar, int skip /*=0*/)
{
#ifdef UNICODE
return str.Find(findchar, skip);
#else
ASSERT(skip >= 0);
int i;
LPTSTR pBuf = str.GetBuffer(str.GetLength());
TCHAR *pchBgn = (TCHAR *)pBuf;
TCHAR *pch;
for (i=-1, pch=pchBgn; *pch; pch = _tcsinc(pch))
{
if (skip)
{
skip--;
}
else if (*pch == findchar)
{
i = pch - pchBgn;
break;
}
}
str.ReleaseBuffer(-1);
return i;
#endif
}
int ReverseFindMBCS(CString &str, TCHAR findchar)
{
#ifdef UNICODE
return str.ReverseFind(findchar);
#else
int len;
LPTSTR pBuf = str.GetBuffer(len = str.GetLength());
TCHAR *pchBgn = (TCHAR *)pBuf;
TCHAR *pchLst = _tcsdec(pchBgn, pchBgn + len);
while (pchBgn < pchLst)
{
if (*pchLst == findchar)
break;
pchLst = _tcsdec(pchBgn, pchLst);
}
if (pchBgn < pchLst)
len = pchLst - pchBgn;
else
len = *pchBgn == findchar ? 0 : -1;
str.ReleaseBuffer(-1);
return len;
#endif
}
// Function to get a file's extension
CString GetFilesExtension(LPCTSTR filename)
{
CString extension = filename;
int slash= extension.ReverseFind(_T('\\'));
if(slash != -1)
extension=extension.Mid(slash+1);
int dot= extension.ReverseFind(_T('.'));
if(dot == -1)
extension.Empty();
else
extension=extension.Mid(dot+1);
return extension;
}
// Function to compare 2 path&filenames in MS
// TreeView order - which is definitely weird
// (see comment below). This means x.ext comes
// before x-y.ext even tho - comes before .
int fCompare(LPCTSTR str1, LPCTSTR str2, BOOL ext1st/*=FALSE*/)
{
CString bas1 = str1;
CString bas2 = str2;
// Since we do our own sorting when we are in "sort by extension"
// we don't have to do stupid win32 stuff
if (ext1st)
{
int rc;
CString ext1 = GetFilesExtension(str1);
CString ext2 = GetFilesExtension(str2);
if ((rc = ext1.CompareNoCase(ext2)) == 0)
rc = bas1.CompareNoCase(bas2);
return rc;
}
// In general, the Win32 sort order is this:
// Non-alpha-numeric (punctuation) characters in ASCII or ANSI order
// Numeric characters in numeric order
// Alphabetic characters in case-insensitive alphabetic order
// For Win32 it is the same, with two exceptions:
// the hyphen or minus (-) symbol and the single-quote or apostrophe ( ' ).
// These two characters are ignored when sorting strings because they are
// allowed to be embedded in English-language words. For example, "its" and
// "it's" and "co-op" and "coop." The presence of these characters embedded
// in words causes certain searches to break incorrectly, so they are changed
// to be treated just like other diacritical marks embedded in text strings;
// that is, they're ignored. These rather remarkable words are from
// ms-help://MS.VSCC/MS.MSDNVS/dnaskdr/html/drgui49.htm and
// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnaskdr/html/drgui49.asp
bas1.Remove(_T('\''));
bas1.Remove(_T('-'));
bas2.Remove(_T('\''));
bas2.Remove(_T('-'));
return bas1.CompareNoCase(bas2);
}
/**********************************************************************/
void CopyTextToClipboard(LPCTSTR txt)
{
if( lstrlen(txt) > 0 )
{
COleDataSource *pSource= new COleDataSource();
HGLOBAL hText= ::GlobalAlloc(GMEM_SHARE, (lstrlen(txt)+1)*sizeof(TCHAR));
LPTSTR pStr= (LPTSTR) ::GlobalLock( hText );
lstrcpy( pStr, txt );
::GlobalUnlock( hText );
#ifdef UNICODE
pSource->CacheGlobalData( CF_UNICODETEXT, hText );
#else
pSource->CacheGlobalData( CF_TEXT, hText );
#endif
pSource->SetClipboard();
}
}
/**********************************************************************/
void CP4winApp::OnUpdateNewWindow(CCmdUI* pCmdUI)
{
pCmdUI->Enable(MainFrame()->IsModlessUp() ? FALSE : !SERVER_BUSY());
}
void CP4winApp::OnNewWindow()
{
if (MainFrame()->IsModlessUp())
return;
CNewWindowDlg newWindowDlg;
newWindowDlg.DoModal();
}
void CP4winApp::GetFileType(const CString &itemStr, int &BaseType, int &StoreType,
BOOL &TypeK, BOOL &TypeW, BOOL &TypeX, BOOL &TypeO,
BOOL &TypeM, BOOL &TypeL, BOOL &TypeS, int &NbrRevs, BOOL &Unknown)
{
TypeS = FALSE;
// shortcut for file not in depot
if(itemStr.Find(_T(" <")) == -1)
{
BaseType = -1;
StoreType = -1;
Unknown = FALSE;
return;
}
int plus;
TCHAR c;
if (itemStr.Find(_T(" <text")) != -1)
BaseType = 0;
else if (itemStr.Find(_T(" <binary")) != -1)
BaseType = 1;
else if (itemStr.Find(_T(" <symlink")) != -1)
BaseType = 2;
else if (itemStr.Find(_T(" <resource")) != -1)
BaseType = 3;
else if (itemStr.Find(_T(" <apple")) != -1)
BaseType = 4;
else if (itemStr.Find(_T(" <unicode")) != -1)
BaseType = 5;
else if (itemStr.Find(_T(" <utf16")) != -1)
BaseType = 6;
StoreType = 0;
Unknown = FALSE;
if ((plus = itemStr.Find(_T("+"), itemStr.Find(_T(" <")))) != -1)
{
while (((c = itemStr.GetAt(++plus)) != _T('>')) && c)
{
switch (c)
{
case _T('x'):
TypeX = TRUE;
break;
case _T('w'):
TypeW = TRUE;
break;
case _T('k'):
TypeK = TRUE;
break;
case _T('o'):
TypeO = TRUE;
TypeK = TRUE;
break;
case _T('m'):
TypeM = TRUE;
break;
case _T('l'):
TypeL = TRUE;
break;
case _T('C'):
StoreType = 1;
break;
case _T('D'):
StoreType = 2;
break;
case _T('F'):
StoreType = 3;
break;
case _T('S'):
TypeS = TRUE;
if (_istdigit(itemStr.GetAt(plus+1)))
{
CString str = itemStr.Mid(plus+1);
NbrRevs = (int)_tstof(str);
if (NbrRevs < 1)
NbrRevs = 1;
while (_istdigit(itemStr.GetAt(++plus)))
;
plus--;
}
else
NbrRevs = 1;
break;
default:
Unknown = TRUE;
break;
}
}
}
else if (itemStr.Find(_T(" <xtext>")) != -1)
{
BaseType = 0;
TypeX = TRUE;
}
else if (itemStr.Find(_T(" <ktext>")) != -1)
{
BaseType = 0;
TypeK = TRUE;
}
else if (itemStr.Find(_T(" <kxtext>")) != -1)
{
BaseType = 0;
TypeX = TRUE;
TypeK = TRUE;
}
else if (itemStr.Find(_T(" <xbinary>")) != -1)
{
BaseType = 1;
TypeX = TRUE;
}
else if (itemStr.Find(_T(" <ctext>")) != -1)
{
BaseType = 0;
StoreType = 1;
}
else if (itemStr.Find(_T(" <cxtext>")) != -1)
{
BaseType = 0;
StoreType = 2;
TypeX = TRUE;
}
else if (itemStr.Find(_T(" <ltext>")) != -1)
{
BaseType = 0;
StoreType = 3;
}
else if (itemStr.Find(_T(" <lxtext>")) != -1)
{
BaseType = 0;
TypeS = TypeX = TRUE;
}
else if (itemStr.Find(_T(" <ubinary>")) != -1)
{
BaseType = 1;
StoreType = 3;
}
else if (itemStr.Find(_T(" <tempobj>")) != -1)
{
BaseType = 1;
TypeS = TypeW = TRUE;
}
else if ((itemStr.Find(_T(" <xtempobj>")) != -1)
|| (itemStr.Find(_T(" <tempxobj>")) != -1))
{
BaseType = 1;
TypeS = TypeW = TypeX = TRUE;
}
else if (itemStr.Find(_T(" <xunicode>")) != -1)
{
BaseType = 5;
TypeX = TRUE;
}
}
/*
_________________________________________________________________
*/
LPCTSTR CP4winApp::GetClientSpecField( LPCTSTR fieldname, LPCTSTR spectext )
{
static CString field;
int start, end;
field.Empty();
CString spec= spectext;
int lgth = spec.GetLength();
for( start=end=0; spec[end] && end < lgth; end++)
{
if( spec[end] == _T('\n') )
{
CString line= spec.Mid( start, end-start+1 );
start= end+1;
if( line.Find(fieldname) == 0 )
{
int i;
if ((i = line.Find(_T('\t'))) != -1)
{
field = line.Mid( line.Find(_T('\t')) + 1 );
}
else if ((i = spec.Find(_T("\n\n"), start)) != -1)
{
field = spec.Mid(start, i-start);
field.TrimLeft();
}
field.TrimRight();
break;
}
}
}
return field;
}
void AddToStatus(LPCTSTR txt, StatusView level, bool showDialog)
{
if(AfxGetThread() == (CWinThread*) AfxGetApp())
MainFrame()->AddToStatusLog(txt, level, showDialog);
else
TheApp()->StatusAdd(txt, level, showDialog);
}
BOOL CP4winApp::OnIdle(LONG lCount)
{
// if lCount is 0, this is the first call since going idle
// therefore set a new idle flag so that the toolbar button
// activate-or-not functions will process the selection list again
//
// We use += 2 to keep m_IdleCounter odd so that it will never
// roll over and become 0 - which is our flag to indicate that
// we are Not in the idle loop.
//
if (!lCount)
m_IdleCounter += 2;
m_IdleFlag = m_IdleCounter;
BOOL rc = CP4GuiApp::OnIdle(lCount);
m_IdleFlag = 0;
return rc;
}
BOOL CP4winApp::CallP4RevisionTree(CString filepath)
{
CString errorText;
CString client = GET_P4REGPTR()->GetP4Client();
CString port = GET_P4REGPTR()->GetP4Port();
CString user = GET_P4REGPTR()->GetP4User();
CString password= GET_P4REGPTR()->GetP4UserPassword();
CString charset = GET_P4REGPTR()->GetP4Charset();
CString winhandle;
winhandle.Format(_T("%d"), MainFrame()->m_hWnd);
CString cmd;
cmd.Format(_T("\"tree %s\""), filepath);
int i = 0;
LPCTSTR argptr[10];
if (password.GetLength() > 0)
{
argptr[i++] = _T("-P");
argptr[i++] = password;
}
if (charset.GetLength() > 0)
{
argptr[i++] = _T("-C");
argptr[i++] = charset;
}
if(MainFrame()->HaveP4QTree())
{
argptr[i++] = _T("-win");
argptr[i++] = winhandle;
argptr[i++] = _T("-cmd");
argptr[i++] = cmd;
}
else
{
argptr[i++] = _T("-j");
argptr[i++] = filepath;
}
while (i < 10)
argptr[i++] = NULL;
if (!TheApp()->RunApp(TREE_APP, RA_NOWAIT, AfxGetApp( )->m_pMainWnd->m_hWnd,
FALSE, NULL, errorText,
_T("-p"), port, _T("-c"), client, _T("-u"), user,
argptr[0], argptr[1], argptr[2], argptr[3],
argptr[4], argptr[5], argptr[6], argptr[7], argptr[8]))
{
AddToStatus( LoadStringResource(IDS_UNABLETORUNREVTREE), SV_WARNING );
return FALSE;
}
return TRUE;
}
BOOL CP4winApp::CallP4A(CString annpath, CString logpath, int revnbr)
{
CString errorText;
CString rev;
CString client = GET_P4REGPTR()->GetP4Client();
CString port = GET_P4REGPTR()->GetP4Port();
CString user = GET_P4REGPTR()->GetP4User();
CString password= GET_P4REGPTR()->GetP4UserPassword();
CString charset = GET_P4REGPTR()->GetP4Charset();
CString winhandle;
winhandle.Format(_T("%d"), MainFrame()->m_hWnd);
int i = 0;
LPCTSTR argptr[10];
if (password.GetLength() > 0)
{
argptr[i++] = _T("-P");
argptr[i++] = password;
}
if (charset.GetLength() > 0)
{
argptr[i++] = _T("-C");
argptr[i++] = charset;
}
if (MainFrame()->HaveTLV())
{
argptr[i++] = _T("-win");
argptr[i++] = winhandle;
argptr[i++] = _T("-cmd");
CString cmd;
cmd.Format(_T("\"%s %s\""), (GET_P4REGPTR()->GetTLVIncInteg()
&& MainFrame()->GetP4Vver() >= 20052)
? _T("annotate -i") : _T("annotate"), annpath); // command passed to V
argptr[i++] = cmd;
while (i < 10)
argptr[i++] = NULL;
if (!TheApp()->RunApp(ANNOTATE_APP, RA_NOWAIT,
AfxGetApp( )->m_pMainWnd->m_hWnd, FALSE, NULL, errorText,
_T("-p"), port, _T("-c"), client, _T("-u"), user,
argptr[0], argptr[1], argptr[2], argptr[3],
argptr[4], argptr[5], argptr[6], argptr[7], argptr[8]))
{
AddToStatus( LoadStringResource(IDS_UNABLETORUNP4A), SV_WARNING );
return FALSE;
}
}
return TRUE;
}
// Since client roots are entered by the user,
// they can appear in all sorts of weird shapes and forms.
// So always use this routune to set m_ClientRoot
// and clean up any messes afterwards.
BOOL CP4winApp::Set_m_ClientRoot(LPCTSTR clientroot)
{
m_ClientRoot = clientroot;
// handle client with multiple roots
// by running p4 info to get the real root
int i;
if ((i = m_ClientRoot.FindOneOf(_T("\r\n\t"))) != -1)
{
BOOL b = FALSE;
CCmd_Info cmd;
cmd.Init( NULL, RUN_SYNC );
if( cmd.Run( ) && !cmd.GetError() )
{
CP4Info const &info = cmd.GetInfo();
if (!info.m_ClientRoot.IsEmpty( ))
{
m_ClientRoot = info.m_ClientRoot;
b = TRUE;
}
}
if (!b)
m_ClientRoot = m_ClientRoot.Left(i);
}
m_ClientRoot.Replace(_T('/'), _T('\\'));
m_ClientRoot.TrimLeft(_T('\"'));
m_ClientRoot.TrimRight(_T("\"\\"));
switch(m_ClientRoot.GetLength())
{
case 0:
m_ClientRoot = _T("\\");
break;
case 1:
ASSERT(0);
return FALSE;
case 2:
if (m_ClientRoot.GetAt(1) == _T(':'))
m_ClientRoot += _T('\\');
break;
}
return TRUE;
}
BOOL CP4winApp::Set_m_ClientSubOpts(LPCTSTR clientSubOpts)
{
m_ClientSubOpts = 0;
if (clientSubOpts)
{
if (_tcsstr(clientSubOpts, _T("revert")))
m_ClientSubOpts = REVERTUNCHANGED;
else if (_tcsstr(clientSubOpts, _T("leave")))
m_ClientSubOpts = LEAVEUNCHANGED;
else if (_tcsstr(clientSubOpts, _T("submit")))
m_ClientSubOpts = SUBMITUNCHANGED;
if (m_ClientSubOpts && _tcsstr(clientSubOpts, _T("reopen")))
m_ClientSubOpts += REOPEN_MASK;
}
return m_ClientSubOpts > 0;
}
BOOL CP4winApp::digestIsSame(CP4FileStats *fs, BOOL retIfNotExist/*=FALSE*/,
void *clientPtr/*=NULL*/)
{
if (fs->GetDigest().IsEmpty()) // prior to 2005.1, we don't have the digest;
return TRUE; // so revert to old behavior
Error e;
CP4Command *pcmd = NULL;
CGuiClient *client = (CGuiClient *)clientPtr;
if (!client)
{
pcmd = new CP4Command;
client = pcmd->GetClient();
client->SetTrans();
client->Init(&e);
if( e.Test() )
{
delete pcmd;
return FALSE;
}
}
FileSysType ft;
if (fs->IsTextFile())
ft = (fs->GetHeadType().Find(_T("unicode")) != -1) ? FST_UNICODE
: (fs->GetHeadType().Find(_T("utf16")) != -1) ? FST_UTF16 : FST_TEXT;
else if (fs->GetHeadType().Find(_T("apple")) != -1)
ft = FST_APPLETEXT;
else if (fs->GetHeadType().Find(_T("resource")) != -1)
ft = FST_RESOURCE;
else if (fs->GetHeadType().Find(_T("symlink")) != -1)
ft = FST_SYMLINK;
else
ft = FST_BINARY;
FileSys *f = FileSys::Create( ft );
if( e.Test() )
{
if (pcmd) delete pcmd;
return FALSE;
}
StrBuf clientPath;
clientPath << CharFromCString(fs->GetFullClientPath());
f->Set(clientPath);
StrBuf md5;
f->Digest(&md5, &e);
delete f;
if (pcmd) delete pcmd;
if( e.Test() )
return retIfNotExist;
return CharToCString(md5.Value()) == fs->GetDigest();
}
BOOL CP4winApp::localDigest(CP4FileStats *fs, CString *digest, BOOL retIfNotExist/*=FALSE*/,
void *clientPtr/*=NULL*/)
{
Error e;
CP4Command *pcmd = NULL;
CGuiClient *client = (CGuiClient *)clientPtr;
*digest = _T("");
if (!client)
{
pcmd = new CP4Command;
client = pcmd->GetClient();
client->SetTrans();
client->Init(&e);
if( e.Test() )
{
delete pcmd;
return FALSE;
}
}
FileSysType ft;
if (fs->IsTextFile())
ft = (fs->GetHeadType().Find(_T("unicode")) != -1) ? FST_UNICODE
: (fs->GetHeadType().Find(_T("utf16")) != -1) ? FST_UTF16 : FST_TEXT;
else if (fs->GetHeadType().Find(_T("apple")) != -1)
ft = FST_APPLETEXT;
else if (fs->GetHeadType().Find(_T("resource")) != -1)
ft = FST_RESOURCE;
else if (fs->GetHeadType().Find(_T("symlink")) != -1)
ft = FST_SYMLINK;
else
ft = FST_BINARY;
FileSys *f = FileSys::Create( ft );
if( e.Test() )
{
if (pcmd) delete pcmd;
return FALSE;
}
StrBuf clientPath;
clientPath << CharFromCString(fs->GetFullClientPath());
f->Set(clientPath);
StrBuf md5;
f->Digest(&md5, &e);
delete f;
if (pcmd) delete pcmd;
if( e.Test() )
return retIfNotExist;
*digest = CharToCString(md5.Value());
return TRUE;
}
/********************************************************************/
int GetNbrNL(const CString *str)
{
int i = 0;
int n = 0;
while ((i = str->Find(_T('\n'), i)) != -1)
{
n++;
i++;
}
return n;
}
CImageList * CP4winApp::GetImageList()
{
return m_viewImageList;
}
void CP4winApp::OnSysColorChange()
{
// Make sure image lists gets a new background color
m_viewImageList->OnSysColorChange(::GetSysColor(COLOR_WINDOW));
m_toolBarImageList->OnSysColorChange(::GetSysColor(COLOR_3DFACE));
}
// Use the shell to display a "Choose Directory" dialog box for the user.
CString CP4winApp::BrowseForFolder(HWND hWnd, LPCTSTR startat, LPCTSTR lpszTitle, UINT nFlags)
{
startingfolder = startat;
CString strResult = _T("");
LPMALLOC lpMalloc; // pointer to IMalloc
if (::SHGetMalloc(&lpMalloc) != NOERROR)
return strResult; // failed to get allocator
TCHAR szDisplayName[_MAX_PATH];
TCHAR szBuffer[_MAX_PATH];
BROWSEINFO browseInfo;
browseInfo.hwndOwner = hWnd;
browseInfo.pidlRoot = NULL; // set root at Desktop
browseInfo.pszDisplayName = szDisplayName;
browseInfo.lpszTitle = lpszTitle; // passed in
browseInfo.ulFlags = nFlags; // also passed in
browseInfo.lpfn = BrowseCallbackProc; // callback func
browseInfo.lParam = 0; // not used
LPITEMIDLIST lpItemIDList;
if ((lpItemIDList = ::SHBrowseForFolder(&browseInfo)) != NULL)
{
// Get the path of the selected folder from the item ID list.
if (::SHGetPathFromIDList(lpItemIDList, szBuffer))
{
// At this point, szBuffer contains the path the user chose.
if (szBuffer[0] == '\0')
{
// SHGetPathFromIDList failed, or
// SHBrowseForFolder failed.
AfxMessageBox(IDS_FAILED_GET_DIRECTORY, MB_ICONSTOP|MB_OK);
}
else
{
// We have a path in szBuffer - Prepare to return it.
strResult = szBuffer;
}
}
else
{
// The thing referred to by lpItemIDList
// might not have been a file system object.
// For whatever reason, SHGetPathFromIDList
// didn't work!
AfxMessageBox(IDS_FAILED_GET_DIRECTORY, MB_ICONSTOP|MB_OK);
}
}
// cleanup
lpMalloc->Free(lpItemIDList);
lpMalloc->Release();
return strResult;
}
INT CALLBACK BrowseCallbackProc(HWND hwnd, UINT uMsg, LPARAM lp, LPARAM pData)
{
switch(uMsg)
{
case BFFM_INITIALIZED:
// WParam is TRUE since we are passing a path.
// It would be FALSE if we were passing a pidl.
SendMessage(hwnd, BFFM_SETSELECTION, TRUE, (LPARAM)startingfolder.GetBuffer());
break;
}
return 0;
}
CString DemanglePath(LPCTSTR path)
{
// expand short filenames to long filenames
StrBuf demangled;
NtDemanglePath(const_cast<char*>((const char *)CharFromCString(path)), &demangled);
return CharToCString(demangled.Text());
}
CString FormatError(Error *e, int flags)
{
StrBuf buf;
e->Fmt( &buf, flags ) ;
return CharToCString(buf.Text());
}
int FindNoCase(CString str, CString substr, int offset/*=0*/)
{
str.MakeLower();
substr.MakeLower();
return str.Find(substr, offset);
}