LRESULT CForceSyncDlg::OnP4Diff(WPARAM wParam, LPARAM lParam)
{
CCmd_Diff *pCmd= (CCmd_Diff *) wParam;
if(!pCmd->GetError())
{
int cnt;
if ((cnt = pCmd->GetDiffRunCount()) == 0)
{
if (pCmd->GetDiffNbrFiles() == 1)
{
CString msg;
msg.FormatMessage(IDS_CLIENT_FILE_s_DOES_NOT_DIFFER_FROM_DEPOT_FILE,
pCmd->GetDiffFileName());
AddToStatus(msg, SV_COMPLETION);
}
else if (pCmd->GetDiffErrCount() == 0)
AddToStatus(LoadStringResource(IDS_NONE_OF_THE_SELECTED_CLIENT_FILES_DIFFER), SV_COMPLETION);
}
else if (cnt < pCmd->GetDiffNbrFiles())
{
CString txt;
int i = pCmd->GetDiffNbrFiles() - cnt;
if(i == 1)
txt.FormatMessage(IDS_ONECLIENTFILEDOESNOTDIFFER);
else
txt.FormatMessage(IDS_SEVERALCLIENTFILESDONOTDIFFER_n, i);
AddToStatus(txt, SV_COMPLETION);
}
}
delete pCmd;
MainFrame()->ClearStatus();
return 0;
}
int WorkAggressive(int firstTime)
{
int blockBytes,i;
BYTE *buf;
if(firstTime) {
if(!opts.bAggressive) return ERROR_NO_MORE_ITEMS;
AddToStatus(STATUS_MESSAGE,TranslateT("Performing aggressive pass"));
ofsCurrent=0;
spaceProcessed=0;
sp=0;
}
blockBytes=min(BLOCKSIZE+3,(int)(sourceFileSize-ofsCurrent));
if(blockBytes<=0) return ERROR_NO_MORE_ITEMS;
buf = opts.pFile+ofsCurrent;
blockBytes-=3;
for(i=0;i<blockBytes;i++) {
if(buf[i]) {
if((*(PDWORD)&buf[i]&0x00FFFFFF)!=0xDECADE)
AddToStatus(STATUS_WARNING,TranslateT("Aggressive: random junk at %08X: skipping"),ofsCurrent+i);
else {
//TODO: give user the option of placing manually
AddToStatus(STATUS_ERROR,TranslateT("Aggressive: unlinked data at %08X: can't automatically place"),ofsCurrent+i);
}
for(;i<blockBytes;i++)
if(buf[i]==0) {i--; break;}
}
}
ofsCurrent+=BLOCKSIZE;
spaceProcessed=ofsCurrent;
return ERROR_SUCCESS;
}
int WorkSettingsChain(DWORD ofsContact,DBContact *dbc,int firstTime)
{
DBContactSettings *dbcsNew,dbcsOld;
DWORD ofsDestThis;
int ret;
if(firstTime) {
ofsDestPrevSettings=0;
ofsThisSettings=dbc->ofsFirstSettings;
dbc->ofsFirstSettings=0;
}
if(ofsThisSettings==0)
return ERROR_NO_MORE_ITEMS;
if(!SignatureValid(ofsThisSettings,DBCONTACTSETTINGS_SIGNATURE)) {
AddToStatus(STATUS_ERROR,TranslateT("Settings chain corrupted, further entries ignored"));
return ERROR_NO_MORE_ITEMS;
}
if(PeekSegment(ofsThisSettings,&dbcsOld,sizeof(dbcsOld))!=ERROR_SUCCESS)
return ERROR_NO_MORE_ITEMS;
if(dbcsOld.cbBlob>256*1024 || dbcsOld.cbBlob==0) {
AddToStatus(STATUS_ERROR,TranslateT("Infeasibly large settings blob: skipping"));
ofsThisSettings=dbcsOld.ofsNext;
return ERROR_SUCCESS;
}
dbcsNew=(DBContactSettings*)_malloca(offsetof(DBContactSettings,blob)+dbcsOld.cbBlob);
if((ret=ReadSegment(ofsThisSettings,dbcsNew,offsetof(DBContactSettings,blob)+dbcsOld.cbBlob))!=ERROR_SUCCESS) {
if(ret!=ERROR_HANDLE_EOF) { //eof is OK because blank space at the end doesn't matter
return ERROR_NO_MORE_ITEMS;
}
}
if((dbcsNew->ofsModuleName=ConvertModuleNameOfs(dbcsOld.ofsModuleName))==0) {
ofsThisSettings=dbcsOld.ofsNext;
return ERROR_SUCCESS;
}
if(dbcsNew->blob[0]==0) {
AddToStatus(STATUS_MESSAGE,TranslateT("Empty settings group at %08X: deleting"),ofsThisSettings);
ofsThisSettings=dbcsOld.ofsNext;
return ERROR_SUCCESS;
}
dbcsNew->ofsNext=0;
//TODO? validate all settings in blob/compact if necessary
if((ofsDestThis=WriteSegment(WSOFS_END,dbcsNew,offsetof(DBContactSettings,blob)+dbcsNew->cbBlob))==WS_ERROR) {
return ERROR_HANDLE_DISK_FULL;
}
if(ofsDestPrevSettings) WriteSegment(ofsDestPrevSettings+offsetof(DBContactSettings,ofsNext),&ofsDestThis,sizeof(DWORD));
else dbc->ofsFirstSettings=ofsDestThis;
ofsDestPrevSettings=ofsDestThis;
ofsThisSettings=dbcsOld.ofsNext;
return ERROR_SUCCESS;
}
int WorkInitialChecks(int firstTime)
{
DWORD bytesRead;
sourceFileSize=GetFileSize(opts.hFile,NULL);
if(sourceFileSize==0) {
AddToStatus(STATUS_WARNING,TranslateT("Database is newly created and has no data to process"));
AddToStatus(STATUS_SUCCESS,TranslateT("Processing completed successfully"));
return ERROR_INVALID_DATA;
}
ReadFile(opts.hFile,&dbhdr,sizeof(dbhdr),&bytesRead,NULL);
if(bytesRead<sizeof(dbhdr)) {
AddToStatus(STATUS_FATAL,TranslateT("Database is corrupted and too small to contain any recoverable data"));
return ERROR_BAD_FORMAT;
}
if(memcmp(dbhdr.signature,&dbSignature,sizeof(dbhdr.signature))) {
AddToStatus(STATUS_FATAL,TranslateT("Database signature is corrupted, automatic repair is impossible"));
return ERROR_BAD_FORMAT;
}
if(dbhdr.version!=0x00000700) {
AddToStatus(STATUS_FATAL,TranslateT("Database is marked as belonging to an unknown version of Miranda"));
return ERROR_BAD_FORMAT;
}
_tcscpy(opts.workingFilename,opts.filename);
if(opts.bCheckOnly) {
_tcscpy( opts.outputFilename, TranslateT("<check only>"));
opts.hOutFile=INVALID_HANDLE_VALUE;
}
else {
_tcscpy(opts.outputFilename,opts.filename);
*_tcsrchr(opts.outputFilename,'.')=0;
_tcscat(opts.outputFilename,TranslateT(" (Output).dat"));
opts.hOutFile = CreateFile(opts.outputFilename,GENERIC_WRITE,FILE_SHARE_READ,NULL,CREATE_ALWAYS,FILE_FLAG_SEQUENTIAL_SCAN,NULL);
if ( opts.hOutFile == INVALID_HANDLE_VALUE ) {
AddToStatus(STATUS_FATAL,TranslateT("Can't create output file (%u)"),GetLastError());
return ERROR_ACCESS_DENIED;
}
}
opts.hMap = CreateFileMapping(opts.hFile, NULL, opts.bAggressive?PAGE_WRITECOPY:PAGE_READONLY, 0, 0, NULL);
if (opts.hMap)
opts.pFile = (BYTE*)MapViewOfFile(opts.hMap, opts.bAggressive?FILE_MAP_COPY:FILE_MAP_READ, 0, 0 ,0);
else {
AddToStatus(STATUS_FATAL,TranslateT("Can't create file mapping (%u)"),GetLastError());
return ERROR_ACCESS_DENIED;
}
if (!opts.pFile) {
AddToStatus(STATUS_FATAL,TranslateT("Can't create map view of file (%u)"),GetLastError());
return ERROR_ACCESS_DENIED;
}
if(ReadSegment(0,&dbhdr,sizeof(dbhdr))!=ERROR_SUCCESS) return ERROR_READ_FAULT;
if(WriteSegment(0,&dbhdr,sizeof(dbhdr))==WS_ERROR) return ERROR_HANDLE_DISK_FULL;
spaceUsed=dbhdr.ofsFileEnd-dbhdr.slackSpace;
dbhdr.ofsFileEnd=sizeof(dbhdr);
return ERROR_NO_MORE_ITEMS;
}
BOOL CClientListCtrl::ClientSpecSwitch(CString switchTo, BOOL bAlways /*=FALSE*/, BOOL portWasChanged /*= FALSE*/)
{
CCmd_Describe *pCmd = new CCmd_Describe;
pCmd->Init( NULL, RUN_SYNC );
BOOL cmdStarted= pCmd->Run( P4CLIENT_SPEC, switchTo );
if(cmdStarted && !pCmd->GetError())
{
CString options= TheApp()->GetClientSpecField( _T("Options"), pCmd->GetDescription() );
if (( options.Find(_T("unlocked")) == -1 ) && ( options.Find(_T("locked")) != -1 ))
{
CString lockedby= TheApp()->GetClientSpecField( _T("Owner"), pCmd->GetDescription() );
if ( lockedby.Compare( GET_P4REGPTR()->GetP4User() ) != 0 )
{
CString errmsg;
errmsg.FormatMessage(IDS_CLIENT_s_IS_LOCKED_BY_USER_s_AND_CANT_BE_USED_BY_s,
switchTo, lockedby, GET_P4REGPTR()->GetP4User());
AddToStatus( errmsg, SV_WARNING );
AfxMessageBox( errmsg, MB_ICONEXCLAMATION );
delete pCmd;
return FALSE;
}
}
}
delete pCmd;
m_Active = switchTo;
if ( SetP4Client( bAlways ) )
MainFrame()->OnPerforceOptions( FALSE, portWasChanged ) ;
return TRUE;
}
LRESULT CLabelListCtrl::OnDoLabelSync(WPARAM wParam, LPARAM lParam)
{
BOOL preview = FALSE;
if (wParam == IDOK)
{
preview = lParam;
if (!preview)
GET_P4REGPTR()->SetLabelAddRplDefault(m_AddReplaceDlg->m_DefaultFlag);
if (m_AddReplaceList.GetCount())
{
CCmd_LabelSynch *pCmd= new CCmd_LabelSynch;
pCmd->Init( m_hWnd, RUN_ASYNC);
if( pCmd->Run( m_AddReplaceName, &m_AddReplaceList, preview, FALSE,
m_AddReplaceDlg->m_FilesFlag==2 ) )
MainFrame()->UpdateStatus( LoadStringResource(IDS_SYNCING_LABEL) );
else
delete pCmd;
}
else AddToStatus(LoadStringResource(IDS_NOTHING_SELECTED_NOTHING_TO_DO));
}
if (m_AddReplaceDlg && !preview)
{
m_AddReplaceDlg->DestroyWindow(); // deletes m_AddReplaceDlg
m_AddReplaceDlg = 0;
MainFrame()->SetModelessUp(FALSE);
}
return 0;
}
LRESULT CClientListCtrl::OnP4ClientList(WPARAM wParam, LPARAM lParam)
{
CCmd_Clients *pCmd= (CCmd_Clients *) wParam;
if(!pCmd->GetError())
{
CString msg;
CObList const *clients= pCmd->GetList();
int count = clients->GetCount();
SetRedraw(FALSE);
int index = 0;
CString curclient = GET_P4REGPTR()->GetP4Client();
CString defclient = GET_P4REGPTR()->GetP4Client(TRUE);
CString user = GET_P4REGPTR()->GetP4User();
for(int subItem=0; subItem < CLIENT_MAXCOL; subItem++)
m_ListAll.column[subItem].SetSize(clients->GetCount(), 100);
for(POSITION pos= clients->GetHeadPosition(); pos != NULL; index++)
{
CP4Client *client=(CP4Client *) clients->GetNext(pos);
InsertClient(client, index, &curclient, &defclient, &user);
if ((index & 0x1FFF) == 0)
{
msg.FormatMessage(IDS_INSERTING_CLIENTS, count - index);
MainFrame()->UpdateStatus(msg);
}
}
SetRedraw(TRUE);
msg.FormatMessage( IDS_NUMBER_OF_CLIENTS_n, index );
AddToStatus( msg, SV_COMPLETION );
ReSort();
// Make sure previous item is re-selected
if(clients->GetCount() > 0)
{
int i = FindInList(m_Active.IsEmpty() ? GET_P4REGPTR()->GetP4Client() : m_Active);
if (i < 0) i=0;
SetItemState(i, LVIS_SELECTED|LVIS_FOCUSED, LVIS_SELECTED|LVIS_FOCUSED);
EnsureVisible(i, FALSE);
}
CP4ListCtrl::SetUpdateDone();
// Notify the mainframe that we have finished getting the clients,
// hence the entire set of async command have finished.
MainFrame()->ExpandDepotIfNeedBe();
if (m_PostViewUpdateMsg)
PostMessage(m_PostViewUpdateMsg, m_PostViewUpdateWParam, m_PostViewUpdateLParam);
}
else
CP4ListCtrl::SetUpdateFailed();
delete pCmd;
m_PostViewUpdateMsg = 0;
MainFrame()->ClearStatus();
return 0;
}
int WorkUser(int firstTime)
{
int first=0;
if(firstTime) {
AddToStatus(STATUS_MESSAGE,TranslateT("Processing user data"));
if(!SignatureValid(dbhdr.ofsUser,DBCONTACT_SIGNATURE)) {
AddToStatus(STATUS_ERROR,TranslateT("User corrupted, this could cause major problems"));
return ERROR_NO_MORE_ITEMS;
}
if(ReadSegment(dbhdr.ofsUser,&user,sizeof(DBContact))!=ERROR_SUCCESS)
return ERROR_NO_MORE_ITEMS;
if(user.ofsNext) {
AddToStatus(STATUS_WARNING,TranslateT("More than one user contact: keeping only first"));
user.ofsNext=0;
}
if((ofsUser=WriteSegment(WSOFS_END,&user,sizeof(DBContact)))==WS_ERROR)
return ERROR_HANDLE_DISK_FULL;
dbhdr.ofsUser=ofsUser;
phase=0;
first=1;
}
switch(phase) {
int ret;
case 0:
ret=WorkSettingsChain(ofsUser,&user,first);
if(ret==ERROR_NO_MORE_ITEMS) {
phase++; first=1;
}
else if(ret) return ret;
else break;
case 1:
ret=WorkEventChain(ofsUser,&user,first);
if(ret==ERROR_NO_MORE_ITEMS) {
if(WriteSegment(ofsUser,&user,sizeof(DBContact))==WS_ERROR)
return ERROR_HANDLE_DISK_FULL;
return ERROR_NO_MORE_ITEMS;
}
else if(ret) return ret;
break;
}
return ERROR_SUCCESS;
}
LRESULT CUserListCtrl::OnP4UserList(WPARAM wParam, LPARAM lParam)
{
CCmd_Users *pCmd= (CCmd_Users *) wParam;
if(!pCmd->GetError())
{
CObList const *users = pCmd->GetList();
SetRedraw(FALSE);
int index = 0;
for(POSITION pos= users->GetHeadPosition(); pos != NULL; index++)
{
CP4User *user = (CP4User *) users->GetNext(pos);
InsertUser(user, index);
}
SetRedraw(TRUE);
CString msg;
msg.FormatMessage( IDS_NUMBER_OF_USERS_n, index );
AddToStatus( msg, SV_COMPLETION );
ReSort();
// Make sure previous item is re-selected
if(users->GetCount() > 0)
{
int i = FindInList(m_Active.IsEmpty()
? GET_P4REGPTR()->GetP4User() : m_Active);
if (i < 0)
i=0;
SetItemState(i, LVIS_SELECTED|LVIS_FOCUSED,
LVIS_SELECTED|LVIS_FOCUSED);
EnsureVisible(i, FALSE);
// If m_Active is empty but we found the current user in the list,
// then set m_Active to the correct value
if (m_Active.IsEmpty() && i >= 0)
m_Active = GET_P4REGPTR()->GetP4User();
}
CP4ListCtrl::SetUpdateDone();
// Notify the mainframe that we have finished getting the users,
// hence the entire set of async command have finished.
MainFrame()->ExpandDepotIfNeedBe();
if (m_PostViewUpdateMsg)
PostMessage(m_PostViewUpdateMsg, m_PostViewUpdateWParam, m_PostViewUpdateLParam);
}
else
CP4ListCtrl::SetUpdateFailed();
delete pCmd;
m_PostViewUpdateMsg = 0;
MainFrame()->ClearStatus();
return 0;
}
int SignatureValid(DWORD ofs,DWORD signature)
{
DWORD sig;
if(ofs+sizeof(sig)>=sourceFileSize) {
AddToStatus(STATUS_ERROR,TranslateT("Invalid offset found (database truncated?)"));
return 0;
}
sig = *(DWORD*)(opts.pFile+ofs);
return sig==signature;
}
void __cdecl WorkerThread(void *unused)
{
int task,ret,firstTime;
ts=time(NULL);
AddToStatus(STATUS_MESSAGE,TranslateT("Database worker thread activated"));
SetFilePointer(opts.hFile,0,NULL,FILE_BEGIN);
spaceUsed=1; spaceProcessed=0; sp=0;
firstTime=0;
for(task=0;;) {
if (spaceProcessed/(spaceUsed/1000+1) > sp) {
sp = spaceProcessed/(spaceUsed/1000+1);
SetProgressBar(sp);
}
WaitForSingleObject(hEventRun,INFINITE);
if(WaitForSingleObject(hEventAbort,0)==WAIT_OBJECT_0) {
AddToStatus(STATUS_FATAL,TranslateT("Processing aborted by user"));
break;
}
ret=Workers[task](firstTime);
firstTime=0;
if(ret==ERROR_NO_MORE_ITEMS) {
if(++task==sizeof(Workers)/sizeof(Workers[0])) {
AddToStatus(STATUS_MESSAGE,TranslateT("Elapsed time: %d sec"), time(NULL)-ts);
if(errorCount)
AddToStatus(STATUS_SUCCESS,TranslateT("All tasks completed but with errors (%d)"),errorCount);
else
AddToStatus(STATUS_SUCCESS,TranslateT("All tasks completed successfully"));
break;
}
firstTime=1;
}
else if(ret!=ERROR_SUCCESS)
break;
}
ProcessingDone();
}
LRESULT CLabelListCtrl::OnP4LabelSync(WPARAM wParam, LPARAM lParam)
{
CCmd_LabelSynch *pCmd= (CCmd_LabelSynch *) wParam;
CStringList *list= pCmd->GetList();
ASSERT_KINDOF(CStringList, list);
int numFiles=list->GetCount();
if (numFiles && GET_P4REGPTR()->LabelShowPreviewDetail() && pCmd->GetPreview())
{
POSITION pos=list->GetHeadPosition();
while(pos != NULL)
AddToStatus( list->GetNext(pos), SV_MSG);
}
CString txt;
txt.FormatMessage(pCmd->GetPreview()
? IDS_LABEL_SYNCHRONIZED_n_FILE_REFS_WOULD_BE_UPDATED
: IDS_LABEL_SYNCHRONIZED_n_FILE_REFERENCES_UPDATED, numFiles);
AddToStatus( txt, SV_COMPLETION);
MainFrame()->ClearStatus();
delete pCmd;
return 0;
}
int PeekSegment(DWORD ofs,PVOID buf,int cbBytes)
{
DWORD bytesRead;
if(ofs>=sourceFileSize) {
AddToStatus(STATUS_ERROR,TranslateT("Invalid offset found"));
return ERROR_SEEK;
}
if (ofs+cbBytes>sourceFileSize)
bytesRead = sourceFileSize - ofs;
else
bytesRead = cbBytes;
if(bytesRead==0) {
AddToStatus(STATUS_ERROR,TranslateT("Error reading, database truncated? (%u)"),GetLastError());
return ERROR_READ_FAULT;
}
CopyMemory(buf, opts.pFile+ofs, bytesRead);
if((int)bytesRead<cbBytes) return ERROR_HANDLE_EOF;
return ERROR_SUCCESS;
}
DWORD ConvertModuleNameOfs(DWORD ofsOld)
{
static int i = 0;
if (modChain[i].ofsOld==ofsOld)
return modChain[i].ofsNew;
for(i=0;i<modChainCount;i++)
if(modChain[i].ofsOld==ofsOld)
return modChain[i].ofsNew;
i = 0;
AddToStatus(STATUS_ERROR,TranslateT("Invalid module name offset, skipping data"));
return 0;
}
DWORD WriteSegment(DWORD ofs,PVOID buf,int cbBytes)
{
DWORD bytesWritten;
if(opts.bCheckOnly) return 0xbfbfbfbf;
if(ofs==WSOFS_END) {
ofs=dbhdr.ofsFileEnd;
dbhdr.ofsFileEnd+=cbBytes;
}
SetFilePointer(opts.hOutFile,ofs,NULL,FILE_BEGIN);
WriteFile(opts.hOutFile,buf,cbBytes,&bytesWritten,NULL);
if((int)bytesWritten<cbBytes) {
AddToStatus(STATUS_FATAL,TranslateT("Can't write to output file - disk full? (%u)"),GetLastError());
return WS_ERROR;
}
return ofs;
}
int ReadSegment(DWORD ofs,PVOID buf,int cbBytes)
{
int ret;
ret=PeekSegment(ofs,buf,cbBytes);
if(ret!=ERROR_SUCCESS && ret!=ERROR_HANDLE_EOF) return ret;
if(opts.bAggressive) {
if (ofs+cbBytes>sourceFileSize) {
AddToStatus(STATUS_WARNING,TranslateT("Can't write to working file, aggressive mode may be too aggressive now"));
ZeroMemory(opts.pFile+ofs,sourceFileSize-ofs);
}
else
ZeroMemory(opts.pFile+ofs,cbBytes);
}
spaceProcessed+=cbBytes;
return ERROR_SUCCESS;
}
LRESULT CClientListCtrl::OnP4UseAsLocalTemplate(WPARAM wParam, LPARAM lParam)
{
CCmd_Describe *pCmd = (CCmd_Describe *) wParam;
CString ref = pCmd->GetReference();
CString tmplate = pCmd->GetDescription();
int i;
if ((i = tmplate.Find(_T("\n\nClient:\t"))) != -1)
{
tmplate = tmplate.Mid(i);
tmplate.Replace(ref, LOCALDEFTEMPLATE);
if (GET_P4REGPTR()->SetLocalCliTemplate(tmplate))
{
CString msg;
msg.FormatMessage(IDS_LOCALDEFTEMPLATESET_s, ref);
AddToStatus(msg, SV_COMPLETION);
}
}
delete pCmd;
MainFrame()->ClearStatus();
return 0;
}
void CUserListCtrl::OnSetDefUser()
{
if (m_Active != GetSelectedItemText())
{
ASSERT(0);
return;
}
if (GET_P4REGPTR()->GetExpandFlag() == 1)
GET_P4REGPTR()->AddMRUPcuPath(MainFrame()->GetCurrentItemPath());
if( !GET_P4REGPTR()->SetP4User( m_Active, TRUE, TRUE, TRUE ) )
{
AfxMessageBox( IDS_UNABLE_TO_WRITE_P4USER_TO_THE_REGISTRY, MB_ICONEXCLAMATION);
m_Active = GetSelectedItemText();
}
else
{
CString txt;
txt.FormatMessage(IDS_DEFAULT_USER_SET_TO_s, m_Active);
AddToStatus( txt );
}
}
LRESULT CLabelListCtrl::OnDoLabelSyncCli(WPARAM wParam, LPARAM lParam)
{
BOOL preview = FALSE;
if (wParam == IDOK)
{
preview = lParam;
if (m_DelSyncList.GetCount())
{
CCmd_Get *pCmd= new CCmd_Get;
pCmd->Init( m_depotWnd, RUN_ASYNC );
if( !pCmd->Run( &m_DelSyncList, preview ) )
delete pCmd;
}
else
AddToStatus(LoadStringResource(IDS_NOTHING_SELECTED_NOTHING_TO_DO));
}
if (m_DelSyncDlg && !preview)
{
m_DelSyncDlg->DestroyWindow(); // deletes m_DelSyncDlg
m_DelSyncDlg = 0;
MainFrame()->SetModelessUp(FALSE);
}
return 0;
}
LRESULT CLabelListCtrl::OnDoLabelDelFiles(WPARAM wParam, LPARAM lParam)
{
BOOL preview = FALSE;
if (wParam == IDOK)
{
preview = lParam;
if (m_DelSyncList.GetCount())
{
POSITION pos2;
for (POSITION pos1 = m_DelSyncList.GetHeadPosition(); ( pos2 = pos1 ) != NULL; )
{
CString str = m_DelSyncList.GetNext(pos1);
int i = str.ReverseFind(_T('#'));
if (i != -1)
str = str.Left(i);
str += _T("#none");
m_DelSyncList.SetAt(pos2, str);
}
CCmd_LabelSynch *pCmd= new CCmd_LabelSynch;
pCmd->Init( m_hWnd, RUN_ASYNC);
if( pCmd->Run( m_DelSyncName, &m_DelSyncList, preview, FALSE, FALSE ) )
MainFrame()->UpdateStatus( LoadStringResource(IDS_SYNCING_LABEL) );
else
delete pCmd;
}
else
AddToStatus(LoadStringResource(IDS_NOTHING_SELECTED_NOTHING_TO_DO));
}
if (m_DelSyncDlg && !preview)
{
m_DelSyncDlg->DestroyWindow(); // deletes m_DelSyncDlg
m_DelSyncDlg = 0;
MainFrame()->SetModelessUp(FALSE);
}
return 0;
}
INT_PTR CALLBACK ProgressDlgProc(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam)
{
static int fontHeight, listWidth;
static int manualAbort;
static HFONT hBoldFont = NULL;
INT_PTR bReturn;
if (DoMyControlProcessing(hdlg, message, wParam, lParam, &bReturn))
return bReturn;
switch (message) {
case WM_INITDIALOG:
EnableWindow(GetDlgItem(GetParent(hdlg), IDOK), FALSE);
hdlgProgress = hdlg;
hwndStatus = GetDlgItem(hdlg, IDC_STATUS);
errorCount = 0;
bShortModeDone = false;
hwndBar = GetDlgItem(hdlg, IDC_PROGRESS);
SendMessage(hwndBar, PBM_SETRANGE, 0, MAKELPARAM(0, 1000));
{
HDC hdc;
HFONT hFont, hoFont;
SIZE s;
hdc = GetDC(NULL);
hFont = (HFONT)SendMessage(hdlg, WM_GETFONT, 0, 0);
hoFont = (HFONT)SelectObject(hdc, hFont);
GetTextExtentPoint32(hdc, _T("x"), 1, &s);
SelectObject(hdc, hoFont);
ReleaseDC(NULL, hdc);
fontHeight = s.cy;
RECT rc;
GetClientRect(GetDlgItem(hdlg, IDC_STATUS), &rc);
listWidth = rc.right;
LOGFONT lf;
GetObject((HFONT)SendDlgItemMessage(hdlg, IDC_STATUS, WM_GETFONT, 0, 0), sizeof(lf), &lf);
lf.lfWeight = FW_BOLD;
hBoldFont = CreateFontIndirect(&lf);
}
manualAbort = 0;
hEventRun = CreateEvent(NULL, TRUE, TRUE, NULL);
hEventAbort = CreateEvent(NULL, TRUE, FALSE, NULL);
TranslateDialogDefault(hdlg);
_beginthread(WorkerThread, 0, NULL);
return TRUE;
case WM_MEASUREITEM:
{
LPMEASUREITEMSTRUCT mis = (LPMEASUREITEMSTRUCT)lParam;
mis->itemWidth = listWidth;
mis->itemHeight = fontHeight;
}
return TRUE;
case WM_DRAWITEM:
TCHAR str[256];
{
LPDRAWITEMSTRUCT dis = (LPDRAWITEMSTRUCT)lParam;
int bold = 0;
HFONT hoFont = NULL;
if ((int)dis->itemID == -1) break;
SendMessage(dis->hwndItem, LB_GETTEXT, dis->itemID, (LPARAM)str);
switch (dis->itemData & STATUS_CLASSMASK) {
case STATUS_MESSAGE:
SetTextColor(dis->hDC, RGB(0, 0, 0));
break;
case STATUS_WARNING:
SetTextColor(dis->hDC, RGB(192, 128, 0));
break;
case STATUS_ERROR:
SetTextColor(dis->hDC, RGB(192, 0, 0));
break;
case STATUS_FATAL:
bold = 1;
SetTextColor(dis->hDC, RGB(192, 0, 0));
break;
case STATUS_SUCCESS:
bold = 1;
SetTextColor(dis->hDC, RGB(0, 192, 0));
break;
}
if (bold) hoFont = (HFONT)SelectObject(dis->hDC, hBoldFont);
ExtTextOut(dis->hDC, dis->rcItem.left, dis->rcItem.top, ETO_CLIPPED | ETO_OPAQUE, &dis->rcItem, str, (UINT)mir_tstrlen(str), NULL);
if (bold) SelectObject(dis->hDC, hoFont);
}
return TRUE;
case WM_PROCESSINGDONE:
SetProgressBar(1000);
if (bShortMode) {
EnableWindow(GetDlgItem(GetParent(hdlg), IDC_BACK), FALSE);
EnableWindow(GetDlgItem(GetParent(hdlg), IDOK), FALSE);
SetDlgItemText(GetParent(hdlg), IDCANCEL, TranslateT("&Finish"));
bShortModeDone = true;
if (bAutoExit)
PostMessage(GetParent(hdlg), WM_COMMAND, IDCANCEL, 0);
}
else {
AddToStatus(STATUS_SUCCESS, TranslateT("Click Next to continue"));
EnableWindow(GetDlgItem(GetParent(hdlg), IDOK), TRUE);
}
if (manualAbort == 1)
EndDialog(GetParent(hdlg), 0);
else if (manualAbort == 2) {
if (opts.bCheckOnly)
PostMessage(GetParent(hdlg), WZM_GOTOPAGE, IDD_FILEACCESS, (LPARAM)FileAccessDlgProc);
else {
PostMessage(GetParent(hdlg), WZM_GOTOPAGE, IDD_CLEANING, (LPARAM)CleaningDlgProc);
CloseHandle(opts.hOutFile);
opts.hOutFile = NULL;
}
break;
}
break;
case WZN_CANCELCLICKED:
if (bShortModeDone) {
if (!errorCount) {
if (bLaunchMiranda)
CallService(MS_DB_SETDEFAULTPROFILE, (WPARAM)opts.filename, 0);
wizardResult = 1;
}
return TRUE;
}
ResetEvent(hEventRun);
if (IsWindowEnabled(GetDlgItem(GetParent(hdlg), IDOK)))
break;
if (MessageBox(hdlg, TranslateT("Processing has not yet completed, if you cancel now then the changes that have currently been made will be rolled back and the original database will be restored. Do you still want to cancel?"), TranslateT("Miranda Database Tool"), MB_YESNO) == IDYES) {
manualAbort = 1;
SetEvent(hEventAbort);
}
SetEvent(hEventRun);
SetWindowLongPtr(hdlg, DWLP_MSGRESULT, TRUE);
return TRUE;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDC_BACK:
ResetEvent(hEventRun);
if (!IsWindowEnabled(GetDlgItem(GetParent(hdlg), IDOK))) {
if (MessageBox(hdlg, TranslateT("Processing has not yet completed, if you go back now then the changes that have currently been made will be rolled back and the original database will be restored. Do you still want to go back?"), TranslateT("Miranda Database Tool"), MB_YESNO) == IDYES) {
manualAbort = 2;
SetEvent(hEventAbort);
}
SetEvent(hEventRun);
break;
}
SetEvent(hEventRun);
if (opts.bCheckOnly)
PostMessage(GetParent(hdlg), WZM_GOTOPAGE, IDD_FILEACCESS, (LPARAM)FileAccessDlgProc);
else
PostMessage(GetParent(hdlg), WZM_GOTOPAGE, IDD_CLEANING, (LPARAM)CleaningDlgProc);
break;
case IDOK:
PostMessage(GetParent(hdlg), WZM_GOTOPAGE, IDD_FINISHED, (LPARAM)FinishedDlgProc);
break;
}
break;
case WM_DESTROY:
if (hEventAbort) {
CloseHandle(hEventAbort);
hEventAbort = NULL;
}
if (hEventRun) {
CloseHandle(hEventRun);
hEventRun = NULL;
}
if (hBoldFont) {
DeleteObject(hBoldFont);
hBoldFont = NULL;
}
break;
}
return FALSE;
}
BOOL CJobListDlg::OnInitDialog()
{
CDialog::OnInitDialog();
CP4Job *job;
CString str;
SetFont(m_Font);
// Modify the list control style so that the entire selected row is highlighted
DWORD dwStyle = ::SendMessage(m_JobListCtrl.m_hWnd,LVM_GETEXTENDEDLISTVIEWSTYLE,0,0);
dwStyle |= LVS_EX_FULLROWSELECT;
::SendMessage(m_JobListCtrl.m_hWnd,LVM_SETEXTENDEDLISTVIEWSTYLE,0,dwStyle);
// Make sure list control shows selection when not the focused control
m_JobListCtrl.ModifyStyle(0, LVS_SHOWSELALWAYS, 0);
// Set the imagelist
m_JobListCtrl.SetImageList(TheApp()->GetImageList(), LVSIL_SMALL);
// Get original size of control
CRect rect;
m_JobListCtrl.GetWindowRect(&rect);
int colwidth[MAX_JOBS_COLUMNS]={90,80,60,90,200};
// Record the initial window size, and then see if there is a registry preference
GetWindowRect(&m_InitRect);
m_WinPos.RestoreWindowPosition();
// make sure OnSize gets called to reposition controls
// if restored position is default, this won't happen unless
// we force it
GetClientRect(&rect);
SendMessage(WM_SIZE, 0, MAKELONG(rect.Width(), rect.Height()));
// Get new size of control after resized as specified in the registry
m_JobListCtrl.GetWindowRect(&rect);
// Get any saved column widths from registry
RestoreSavedWidths(colwidth, MAX_JOBS_COLUMNS);
// Make sure no column completely disappeared (because you can't get it back then)
for (int i=-1; ++i < MAX_JOBS_COLUMNS; )
{
if (colwidth[i] < 5)
colwidth[i] = 5;
}
// Show the current job filter
CString txt;
m_sFilter = PersistentJobFilter(KEY_READ);
if(m_sFilter.GetLength() > 0)
{
txt.FormatMessage(IDS_JOBFILTERSTR, m_sFilter);
}
else
{
txt = LoadStringResource(IDS_ALLJOBS);
GetDlgItem(ID_CLEARFILTER)->EnableWindow(FALSE);
}
GetDlgItem(IDC_FILTER_TEXT)->SetWindowText(txt);
// Use the same font as the calling window
m_JobListCtrl.SetFont(m_Font);
// Insert the columns
int maxcols = m_ColNames->GetSize();
int width=GetSystemMetrics(SM_CXVSCROLL);;
int retval;
LV_COLUMN lvCol;
int subItem;
for(subItem=0; subItem < maxcols; subItem++)
{
lvCol.mask= LVCF_FMT | LVCF_SUBITEM | LVCF_TEXT |LVCF_WIDTH;
lvCol.fmt=LVCFMT_LEFT;
lvCol.pszText=( LPTSTR )( LPCTSTR ) m_ColNames->GetAt( subItem );
lvCol.iSubItem=subItem;
if(subItem < maxcols-1)
{
lvCol.cx=colwidth[subItem];
width+=lvCol.cx;
}
else
lvCol.cx=rect.Width() - width - 4; // expand last column to fill window
retval=m_JobListCtrl.InsertColumn(subItem, &lvCol);
}
// Add the data
LV_ITEM lvItem;
int iActualItem = -1;
POSITION pos= m_pJobList->GetHeadPosition();
int iItem;
for(iItem=0; iItem < m_pJobList->GetCount(); iItem++)
{
job= (CP4Job *) m_pJobList->GetNext(pos);
for(subItem=0; subItem < maxcols; subItem++)
{
lvItem.mask=LVIF_TEXT |
((subItem==0) ? LVIF_IMAGE : 0) |
((subItem==0) ? LVIF_PARAM : 0);
lvItem.iItem= (subItem==0) ? iItem : iActualItem;
ASSERT(lvItem.iItem != -1);
lvItem.iSubItem= subItem;
lvItem.iImage = CP4ViewImageList::VI_JOB;
lvItem.lParam=(LPARAM) job;
txt=PadCRs(job->GetJobField(subItem));
lvItem.pszText = const_cast<LPTSTR>( (LPCTSTR ) txt);
if(subItem==0)
iActualItem=m_JobListCtrl.InsertItem(&lvItem);
else
m_JobListCtrl.SetItem(&lvItem);
}
}
if(m_pJobList->GetCount())
{
// Sort the jobs list the same way the JobView is sorted
m_JobListCtrl.SortItems( JobListDlgSort, m_LastSortColumn );
// Find the job currently selected in the jobs pane
iItem=0;
if (!m_CurrJob->IsEmpty())
{
TCHAR cur[ LISTVIEWNAMEBUFSIZE + 1 ];
TCHAR str[ LISTVIEWNAMEBUFSIZE + 1 ];
lstrcpy(cur, m_CurrJob->GetBuffer(m_CurrJob->GetLength()+1));
m_CurrJob->ReleaseBuffer(-1);
for( ; iItem < ListView_GetItemCount( m_JobListCtrl.m_hWnd ); iItem++ )
{
ListView_GetItemText( m_JobListCtrl.m_hWnd, iItem, 0, str, LISTVIEWNAMEBUFSIZE );
if( !Compare(cur, str) )
break;
}
if (iItem >= ListView_GetItemCount( m_JobListCtrl.m_hWnd ))
iItem = 0;
}
// Make sure the same job is selected and visible
m_JobListCtrl.SetItemState(iItem, LVIS_SELECTED|LVIS_FOCUSED, LVIS_SELECTED|LVIS_FOCUSED);
m_JobListCtrl.EnsureVisible( iItem, FALSE );
// Set change description to match selected item in list
job= (CP4Job *) m_JobListCtrl.GetItemData(iItem);
str= job->GetDescription();
str.Replace(_T("\n"), _T("\r\n"));
m_JobDesc.SetWindowText(str);
}
else if( m_sFilter.IsEmpty() )
{
AfxMessageBox(IDS_NO_JOBS_AVAILABLE_FOR_FIXING, MB_ICONEXCLAMATION);
EndDialog(IDCANCEL);
}
else
AddToStatus(LoadStringResource(IDS_USEJOBFILTERBUTTON), SV_MSG);
if (!LoadJobStatusComboBox())
{
GetDlgItem(IDC_JOBSTATUSPROMPT)->ShowWindow( SW_HIDE );
GetDlgItem(IDC_JOBSTATUS)->ShowWindow( SW_HIDE );
}
// And finally, set focus to the list control so that the first 'down'
// keystroke can be used to scroll down
m_JobListCtrl.SetFocus();
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
LRESULT CLabelListCtrl::OnP4LabelContents(WPARAM wParam, LPARAM lParam)
{
CString tmp;
CCmd_Fstat *pCmd;
if(lParam == 0) // completion
{
pCmd= (CCmd_Fstat *) wParam;
ASSERT_KINDOF(CCmd_Fstat,pCmd);
if(!pCmd->GetError())
{
tmp.FormatMessage(IDS_LABEL_s_POINTS_TO_n_FILES, m_Active, m_LabelFileCount);
AddToStatus(tmp, SV_COMPLETION);
MainFrame()->ClearStatus();
delete pCmd;
if (m_LabelFilesInDialog && m_LabelFileCount)
{
m_LabelFiles += _T('\n') + tmp;
int key;
CSpecDescDlg *dlg = new CSpecDescDlg(this);
dlg->SetIsModeless(TRUE);
dlg->SetKey(key = pCmd->HaveServerLock()? pCmd->GetServerKey() : 0);
dlg->SetDescription( m_LabelFiles );
dlg->SetItemName( m_Active );
CString caption;
caption.FormatMessage(IDS_FILE_LIST_FOR_LABEL_s, m_Active);
dlg->SetCaption( caption );
dlg->SetViewType(P4LABEL_SPEC);
if (!dlg->Create(IDD_SPECDESC, this)) // display the description dialog box
{
dlg->DestroyWindow(); // some error! clean up
delete dlg;
}
m_LabelFiles.Empty();
}
}
return 0;
}
else
{
// Pull a ptr to the command, as well as a batch of CP4FileStats
// out of the wrapper
CFstatWrapper *pWrap= (CFstatWrapper *) wParam;
pCmd= (CCmd_Fstat *) pWrap->pCmd;
ASSERT_KINDOF(CCmd_Fstat, pCmd);
CObList *list= (CObList *) pWrap->pList;
ASSERT_KINDOF(CObList, list);
POSITION pos= list->GetHeadPosition();
while(pos != NULL)
{
// Get the filestats
CP4FileStats *stats= (CP4FileStats *) list->GetNext(pos);
ASSERT_KINDOF(CP4FileStats, stats);
// Increment the counter
m_LabelFileCount++;
if (m_LabelFilesInDialog)
{
// Format the file, rev and type
tmp.FormatMessage(IDS_s_n_s_CHANGELIST_n_s,
stats->GetFullDepotPath(),
stats->GetHeadRev(),
stats->GetHeadType(),
stats->GetHeadChangeNum(),
stats->GetActionStr(stats->GetHeadAction()));
// And add to Description
m_LabelFiles += tmp;
}
else
{
// Format the file, rev and type
tmp.FormatMessage(IDS_LABEL_s_TO_s_n_s_CHANGELIST_n_s,
m_Active,
stats->GetFullDepotPath(),
stats->GetHeadRev(),
stats->GetHeadType(),
stats->GetHeadChangeNum(),
stats->GetActionStr(stats->GetHeadAction()));
// And add to the status window
AddToStatus( tmp);
}
delete stats;
} // while row batch not done
delete list;
delete pWrap;
return 0;
} // a batch of rows, we'll be called again so dont delete pCmd
}
LRESULT CLabelListCtrl::OnP4LabelList(WPARAM wParam, LPARAM lParam)
{
CCmd_Labels *pCmd= (CCmd_Labels *) wParam;
m_AnyBlankOwner = FALSE;
if(!pCmd->GetError())
{
CString msg;
CString filterowner;
CObList const *labels = pCmd->GetList();
int count = labels->GetCount();
SetRedraw(FALSE);
int index = 0;
if (m_FilterOwnerFlag) // are we filtering by owner?
filterowner = m_FilterOwnerFlag & 0x10 ? m_User : m_FilterOwner;
for(POSITION pos= labels->GetHeadPosition(); pos != NULL; index++)
{
CP4Label *label = (CP4Label *) labels->GetNext(pos);
CString owner = label->GetOwner();
if (owner.IsEmpty())
m_AnyBlankOwner = TRUE;
if (m_FilterOwnerFlag) // are we filtering by owner?
{
if (owner.IsEmpty() && m_FilterIncBlank)
;
else if (filterowner != owner)
{
delete label;
continue;
}
}
InsertLabel(label, index);
if ((index & 0x1FFF) == 0)
{
msg.FormatMessage(IDS_INSERTING_LABELS, count - index);
MainFrame()->UpdateStatus(msg);
}
}
SetRedraw(TRUE);
msg.FormatMessage(IDS_NUMBER_OF_LABELS_n, index );
AddToStatus( msg, SV_COMPLETION );
// Make sure first item selected
ReSort();
if(labels->GetCount() > 0)
{
int i = FindInList(m_Active.IsEmpty() ? GET_P4REGPTR()->GetLastLabel() : m_Active);
if (i < 0) i=0;
SetItemState(i, LVIS_SELECTED|LVIS_FOCUSED, LVIS_DROPHILITED|LVIS_SELECTED|LVIS_FOCUSED);
EnsureVisible(i, FALSE);
m_Active=GetSelectedItemText();
}
CP4ListCtrl::SetUpdateDone();
if (m_Need2DoNew)
OnLabelNew();
else
{
// Notify the mainframe that we have finished getting the labels,
// hence the entire set of async command have finished.
MainFrame()->ExpandDepotIfNeedBe();
}
if (m_PostViewUpdateMsg)
PostMessage(m_PostViewUpdateMsg, m_PostViewUpdateWParam, m_PostViewUpdateLParam);
}
else
{
CP4ListCtrl::SetUpdateFailed();
m_Need2DoNew = FALSE;
}
delete pCmd;
m_PostViewUpdateMsg = 0;
MainFrame()->ClearStatus();
return 0;
}
int WorkContactChain(int firstTime)
{
int first=0;
if(firstTime) {
AddToStatus(STATUS_MESSAGE,TranslateT("Processing contact chain"));
ofsDestPrevContact=0;
ofsThisContact=dbhdr.ofsFirstContact;
contactCount=0;
dbhdr.ofsFirstContact=0;
phase=0;
}
switch(phase) {
int ret;
case 0:
if(ofsThisContact==0) {
FinishUp();
return ERROR_NO_MORE_ITEMS;
}
if(!SignatureValid(ofsThisContact,DBCONTACT_SIGNATURE)) {
AddToStatus(STATUS_ERROR,TranslateT("Contact chain corrupted, further entries ignored"));
FinishUp();
return ERROR_NO_MORE_ITEMS;
}
if(ReadSegment(ofsThisContact,&dbc,sizeof(dbc))!=ERROR_SUCCESS) {
FinishUp();
return ERROR_NO_MORE_ITEMS;
}
ofsNextContact=dbc.ofsNext;
dbc.ofsNext=0;
if (!opts.bCheckOnly) {
if((ofsDestThis=WriteSegment(WSOFS_END,&dbc,sizeof(dbc)))==WS_ERROR)
return ERROR_HANDLE_DISK_FULL;
if(ofsDestPrevContact)
WriteSegment(ofsDestPrevContact+offsetof(DBContact,ofsNext),&ofsDestThis,sizeof(DWORD));
else
dbhdr.ofsFirstContact=ofsDestThis;
} else
ofsDestThis = ofsThisContact; // needed in event chain worker
contactCount++;
phase++; first=1;
//fall thru
case 1:
ret=WorkSettingsChain(ofsDestThis,&dbc,first);
if(ret==ERROR_NO_MORE_ITEMS) {
phase++; first=1;
}
else if(ret) return ret;
else break;
//fall thru
case 2:
ret=WorkEventChain(ofsDestThis,&dbc,first);
if(ret==ERROR_NO_MORE_ITEMS) {
phase++; first=1;
}
else if(ret) return ret;
else break;
//fall thru
case 3:
if(WriteSegment(ofsDestThis,&dbc,sizeof(DBContact))==WS_ERROR)
return ERROR_HANDLE_DISK_FULL;
ofsDestPrevContact=ofsDestThis;
ofsThisContact=ofsNextContact;
phase=0;
break;
}
return ERROR_SUCCESS;
}
static void FinishUp(void)
{
if(contactCount!=dbhdr.contactCount)
AddToStatus(STATUS_WARNING,TranslateT("Contact count marked wrongly: correcting"));
dbhdr.contactCount=contactCount;
}
int WorkModuleChain(int firstTime)
{
DBModuleName moduleName,*newModName;
if(firstTime) {
AddToStatus(STATUS_MESSAGE,TranslateT("Processing module name chain"));
modChainCount=0;
last_mod = 0;
if(modChain!=NULL) free(modChain);
modChain = (ModChainEntry*)malloc(sizeof(ModChainEntry));
phase=0;
ofsCurrent=dbhdr.ofsFirstModuleName;
}
switch(phase) {
case 0:
if(ofsCurrent==0) {
phase++;
return ERROR_SUCCESS;
}
if(!SignatureValid(ofsCurrent,DBMODULENAME_SIGNATURE)) {
AddToStatus(STATUS_ERROR,TranslateT("Module chain corrupted, further entries ignored"));
phase++;
return ERROR_SUCCESS;
}
if(PeekSegment(ofsCurrent,&moduleName,offsetof(DBModuleName,name))!=ERROR_SUCCESS) {
phase++;
return ERROR_SUCCESS;
}
if(moduleName.cbName>256)
AddToStatus(STATUS_WARNING,TranslateT("Unreasonably long module name, skipping"));
else {
modChain=(ModChainEntry*)realloc(modChain,sizeof(ModChainEntry)*++modChainCount);
modChain[modChainCount-1].ofsOld=ofsCurrent;
modChain[modChainCount-1].size=offsetof(DBModuleName,name)+moduleName.cbName;
modChain[modChainCount-1].ofsNew=0;
if (moduleName.cbName)
PeekSegment(ofsCurrent+offsetof(DBModuleName,name),&modChain[modChainCount-1].name,moduleName.cbName);
modChain[modChainCount-1].name[moduleName.cbName]=0;
}
ofsCurrent=moduleName.ofsNext;
break;
case 1:
ofsLast = 0;
iCurrentModName=0;
dbhdr.ofsFirstModuleName=0;
phase++;
case 2:
if(iCurrentModName>=modChainCount) {
DWORD dw = 0;
if(ofsLast) WriteSegment(ofsLast+offsetof(DBModuleName,ofsNext),&dw,sizeof(DWORD));
return ERROR_NO_MORE_ITEMS;
}
if(modChain[iCurrentModName].ofsNew==0) {
newModName=(DBModuleName*)_malloca(modChain[iCurrentModName].size);
if(ReadSegment(modChain[iCurrentModName].ofsOld,newModName,modChain[iCurrentModName].size)!=ERROR_SUCCESS)
return ERROR_NO_MORE_ITEMS;
if((modChain[iCurrentModName].ofsNew=WriteSegment(WSOFS_END,newModName,modChain[iCurrentModName].size))==WS_ERROR)
return ERROR_HANDLE_DISK_FULL;
{ // check duplicated modulenames
int i, n=0;
for(i=iCurrentModName+1;i<modChainCount;i++)
if(!strcmp(modChain[i].name, modChain[iCurrentModName].name)) {
modChain[i].ofsNew = modChain[iCurrentModName].ofsNew;
n++;
}
if (n) AddToStatus(STATUS_WARNING,TranslateT("Module name '%s' is not unique: %d duplicates found)"), modChain[iCurrentModName].name,n);
}
if(iCurrentModName==0)
dbhdr.ofsFirstModuleName=modChain[iCurrentModName].ofsNew;
else
if(WriteSegment(ofsLast+offsetof(DBModuleName,ofsNext),&modChain[iCurrentModName].ofsNew,sizeof(DWORD))==WS_ERROR)
return ERROR_HANDLE_DISK_FULL;
ofsLast = modChain[iCurrentModName].ofsNew;
}
iCurrentModName++;
break;
}
return ERROR_SUCCESS;
}
void CForceSyncDlg::OnDiffFile(BOOL bHave)
{
CString filename;
m_StringList.RemoveAll();
for(int i=m_List.GetCount()-1; i>=0; i--)
{
if(!m_List.GetSel(i))
continue;
m_List.GetText(i, filename);
if (filename.FindOneOf(_T("@#%")) != -1)
{
StrBuf b;
StrBuf f;
f << CharFromCString(filename);
StrPtr *p = &f;
StrOps::WildToStr(*p, b);
filename = CharToCString(b.Value());
}
BOOL b = TRUE;
for(POSITION pos = m_lpCstrListD->GetHeadPosition(); pos != NULL; )
{
if (filename == m_lpCstrListD->GetNext(pos))
{
CString txt;
txt.FormatMessage(IDS_s_IS_MISSING, filename);
AddToStatus(txt, SV_MSG);
b = FALSE;
break;
}
}
if (b)
m_StringList.AddTail(filename);
}
if (!m_StringList.GetCount())
{
if (m_List.GetSelCount() > 1)
AddToStatus(LoadStringResource(IDS_ALLSELFILESAREMISSING_NODIFFRUN), SV_COMPLETION);
return;
}
if (bHave)
{
int cnt = m_StringList.GetCount();
CCmd_Fstat *pCmd2= new CCmd_Fstat;
pCmd2->Init(NULL, RUN_SYNC);
if( pCmd2->Run( FALSE, &m_StringList, TRUE, 0 ) && !pCmd2->GetError() )
{
m_StringList.RemoveAll();
CObList *coblist2 = pCmd2->GetFileList( );
ASSERT_KINDOF( CObList, coblist2 );
ASSERT( coblist2->GetCount() == cnt );
for (POSITION pos = coblist2->GetHeadPosition( ); pos != NULL; )
{
CP4FileStats *stats = ( CP4FileStats * )coblist2->GetNext( pos );
ASSERT_KINDOF( CP4FileStats, stats );
long headRev = stats->GetHeadRev();
long haveRev = stats->GetHaveRev();
CString filename = stats->GetFullDepotPath();
if (headRev != haveRev)
{
CString revnbr;
revnbr.Format(_T("#%ld"), haveRev);
filename += revnbr;
}
m_StringList.AddTail(filename);
delete stats;
}
}
delete pCmd2;
}
CCmd_Diff *pCmd= new CCmd_Diff;
pCmd->Init( m_hWnd, RUN_ASYNC);
if( pCmd->Run( &m_StringList, _T("-f") ) )
MainFrame()->UpdateStatus( LoadStringResource(IDS_DIFFING_FILE) );
else
delete pCmd;
}
