//
// Copyright 1997 Nicholas J. Irias.  All rights reserved.
//
//
 
// DeltaTreeCtrl.cpp : implementation file
//
 
#include "stdafx.h"
//#define TRACE_HERE
#include "p4win.h"
#include "DeltaTreeCtrl.h"
#include "resource.h"
#include "MainFrm.h"
#ifdef _ALPHA
#include <winnetwk.h>
#endif // _ALPHA
#include "AddListDlg.h"
#include "RevertListDlg.h"
#include <shlobj.h>
#include "P4change.h"
#include "P4Fix.h"
#include "JobListDlg.h"
#include "AutoResolveDlg.h"
#include "TokenString.h"
#include "merge\GuiClientMerge.h"
#include "merge\Merge2Dlg.h"
#include "merge\Merge3Dlg.h"
#include "SpecDescDlg.h"
#include "FileType.h"
#include "MoveFiles.h"
#include "RemoveViewer.h"
#include "ResolveFlagsDlg.h"
#include "FileInfoDlg.h"
#include "P4SpecDlg.h"
#include "MsgBox.h"
#include "ImageList.h"
#include "OldChgFilterDlg.h"
 
#include "cmd_add.h"
#include "cmd_autoresolve.h"
#include "cmd_changes.h"
#include "cmd_delete.h"
#include "cmd_editspec.h"
#include "cmd_fstat.h"
#include "cmd_diff.h"
#include "cmd_get.h"
#include "cmd_jobs.h"
#include "cmd_fix.h"
#include "cmd_fixes.h"
#include "cmd_history.h"
#include "cmd_listopstat.h"
#include "cmd_ostat.h"
#include "cmd_opened.h"
#include "cmd_prepbrowse.h"
#include "cmd_resolve.h"
#include "cmd_resolved.h"
#include "cmd_revert.h"
#include "cmd_unresolved.h"
#include "cmd_where.h"
#include "strops.h"
 
 
 
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
 
#define WM_GOTDROPLIST (WM_USER+500)
#define WM_GOTMOVELISTS (WM_USER+501)
#define WM_OLEADDFILES (WM_USER+502)
 
#define CHANGELISTS_MINE 0
#define CHANGELISTS_OTHERS 1
 
///////////////////////
//  Note on use of lParam for tree nodes:
//	If its a file, lParam is a CP4FileStats ptr
//	Otherwise, lParam is NULL
//	DeleteItem() takes care of deleting CP4FileStats as reqd
//////////////////////
 
 
/////////////////////////////////////////////////////////////////////////////
// CDeltaTreeCtrl
 
IMPLEMENT_DYNCREATE(CDeltaTreeCtrl, CMultiSelTreeCtrl)
 
BEGIN_MESSAGE_MAP(CDeltaTreeCtrl, CMultiSelTreeCtrl)
	ON_WM_CREATE()
	ON_WM_CONTEXTMENU()
	ON_WM_RBUTTONDOWN()
	ON_WM_RBUTTONUP()
	ON_WM_VSCROLL()
	ON_WM_SHOWWINDOW()
	ON_UPDATE_COMMAND_UI(ID_CHANGE_EDSPEC, OnUpdateChgEdspec)
	ON_UPDATE_COMMAND_UI(ID_CHANGE_DEL, OnUpdateChgDel)
	ON_UPDATE_COMMAND_UI(ID_CHANGE_NEW, OnUpdateChgNew)
	ON_UPDATE_COMMAND_UI(ID_CHANGE_REVORIG, OnUpdateChgRevorig)
	ON_UPDATE_COMMAND_UI(ID_CHANGE_SUBMIT, OnUpdateChgSubmit)
	ON_UPDATE_COMMAND_UI(ID_FILE_DIFFHEAD, OnUpdateFileDiffhead)
	ON_UPDATE_COMMAND_UI(ID_FILE_REVERT, OnUpdateFileRevert)
	ON_COMMAND(ID_CHANGE_DEL, OnChangeDel)
	ON_COMMAND(ID_CHANGE_EDSPEC, OnChangeEdspec)
	ON_COMMAND(ID_CHANGE_NEW, OnChangeNew)
	ON_COMMAND(ID_CHANGE_REVORIG, OnChangeRevorig)
	ON_COMMAND(ID_CHANGE_SUBMIT, OnChangeSubmit)
	ON_COMMAND(ID_FILE_DIFFHEAD, OnFileDiff)
	ON_COMMAND(ID_FILE_REVERT, OnFileRevert)
	ON_UPDATE_COMMAND_UI(ID_FILE_AUTORESOLVE, OnUpdateFileAutoresolve)
	ON_COMMAND(ID_FILE_AUTORESOLVE, OnFileAutoresolve)
	ON_UPDATE_COMMAND_UI(ID_FILE_RESOLVE, OnUpdateFileResolve)
	ON_COMMAND(ID_FILE_RESOLVE, OnFileResolve)
	ON_UPDATE_COMMAND_UI(ID_FILE_RUNMERGETOOL, OnUpdateFileResolve)
	ON_COMMAND(ID_FILE_RUNMERGETOOL, OnFileMerge)
	ON_UPDATE_COMMAND_UI(ID_THEIRFILE_FINDINDEPOT, OnUpdateTheirFile)
	ON_COMMAND(ID_THEIRFILE_FINDINDEPOT, OnTheirFindInDepot)
	ON_UPDATE_COMMAND_UI(ID_THEIRFILE_REVISIONHISTORY, OnUpdateTheirFile)
	ON_COMMAND(ID_THEIRFILE_REVISIONHISTORY, OnTheirHistory)
	ON_UPDATE_COMMAND_UI(ID_THEIRFILE_PROPERTIES, OnUpdateTheirFile)
	ON_COMMAND(ID_THEIRFILE_PROPERTIES, OnTheirProperties)
	ON_WM_DESTROY()
	ON_UPDATE_COMMAND_UI(ID_JOB_DESCRIBE, OnUpdateJobDescribe)
	ON_COMMAND(ID_JOB_DESCRIBE, OnJobDescribe)
	ON_UPDATE_COMMAND_UI(ID_JOB_EDITSPEC, OnUpdateJobEditspec)
	ON_COMMAND(ID_JOB_EDITSPEC, OnJobEditspec)
	ON_UPDATE_COMMAND_UI(ID_CHANGE_REMOVEFIX, OnUpdateRemovefix)
	ON_COMMAND(ID_CHANGE_REMOVEFIX, OnRemovefix)
	ON_UPDATE_COMMAND_UI(ID_CHANGE_ADDJOBFIX, OnUpdateAddjobfix)
	ON_COMMAND(ID_CHANGE_ADDJOBFIX, OnAddjobfix)
	ON_WM_DROPFILES()
	ON_UPDATE_COMMAND_UI(ID_FILE_AUTOEDIT, OnUpdateFileAutoedit)
	ON_UPDATE_COMMAND_UI(ID_FILE_QUICKBROWSE, OnUpdateFileAutobrowse)
	ON_COMMAND(ID_FILE_AUTOEDIT, OnFileAutoedit)
	ON_COMMAND(ID_FILE_QUICKEDIT, OnFileQuickedit)
	ON_COMMAND(ID_FILE_QUICKBROWSE, OnFileQuickbrowse)
	ON_WM_LBUTTONDBLCLK()
	ON_UPDATE_COMMAND_UI(ID_FILE_LOCK, OnUpdateFileLock)
	ON_COMMAND(ID_FILE_LOCK, OnFileLock)
	ON_UPDATE_COMMAND_UI(ID_FILE_UNLOCK, OnUpdateFileUnlock)
	ON_COMMAND(ID_FILE_UNLOCK, OnFileUnlock)
	ON_UPDATE_COMMAND_UI(ID_FILE_GETWHATIF, OnUpdateFileGet)
	ON_COMMAND(ID_FILE_GETWHATIF, OnFileGetWhatIf)
	ON_UPDATE_COMMAND_UI(ID_FILE_GET, OnUpdateFileGet)
	ON_COMMAND(ID_FILE_GET, OnFileGet)
	ON_UPDATE_COMMAND_UI(ID_EDIT_SELECT_ALL, OnUpdateEditSelectAll)
	ON_COMMAND(ID_EDIT_SELECT_ALL, OnEditSelectAll)
	ON_UPDATE_COMMAND_UI(ID_EDIT_COPY, OnUpdateEditCopy)
	ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
	ON_UPDATE_COMMAND_UI(ID_EDIT_COPYCLIENTPATH, OnUpdateEditCopyclientpath)
	ON_COMMAND(ID_EDIT_COPYCLIENTPATH, OnEditCopyclientpath)
	ON_UPDATE_COMMAND_UI(ID_FILE_REVISIONHISTORY, OnUpdateFileRevisionhistory)
	ON_COMMAND(ID_FILE_REVISIONHISTORY, OnFileRevisionhistory)
	ON_UPDATE_COMMAND_UI(ID_FILE_REVISIONTREE, OnUpdateFileRevisionhistory)
	ON_COMMAND(ID_FILE_REVISIONTREE, OnFileRevisionTree)
	ON_UPDATE_COMMAND_UI(ID_FILE_ANNOTATIONS, OnUpdateFileAnnotate)
	ON_COMMAND(ID_FILE_ANNOTATIONS, OnFileTimeLapseView)
	ON_UPDATE_COMMAND_UI(ID_FILE_PROPERTIES, OnUpdateFileInformation)
	ON_COMMAND(ID_FILE_PROPERTIES, OnFileInformation)
	ON_UPDATE_COMMAND_UI(ID_WINEXPLORE, OnUpdateWinExplore)
	ON_COMMAND(ID_WINEXPLORE, OnWinExplore)
	ON_UPDATE_COMMAND_UI(ID_CMDPROMPT, OnUpdateCmdPrompt)
	ON_COMMAND(ID_CMDPROMPT, OnCmdPrompt)
	ON_UPDATE_COMMAND_UI(ID_CHANGE_DESCRIBE, OnUpdateChangeDescribe)
	ON_COMMAND(ID_CHANGE_DESCRIBE, OnChangeDescribe)
	ON_UPDATE_COMMAND_UI(ID_FILE_OPENEDIT, OnUpdateFileOpenedit)
	ON_COMMAND(ID_FILE_OPENEDIT, OnFileOpenedit)
	ON_UPDATE_COMMAND_UI(ID_FILETYPE, OnUpdateFiletype)
	ON_COMMAND(ID_FILETYPE, OnFiletype)
	ON_UPDATE_COMMAND_UI(ID_FILE_MV2OTHERCHGLIST, OnUpdateMoveFiles)
	ON_COMMAND(ID_FILE_MV2OTHERCHGLIST, OnMoveFiles)
	ON_UPDATE_COMMAND_UI(ID_POSITIONDEPOT, OnUpdatePositionDepot)
	ON_COMMAND(ID_POSITIONDEPOT, OnPositionDepot)
	ON_UPDATE_COMMAND_UI(ID_POSITIONCHGS, OnUpdatePositionOtherChgs)
	ON_COMMAND(ID_POSITIONCHGS, OnPositionOtherChgs)
	ON_UPDATE_COMMAND_UI(ID_POSITIONTOPATTERN, OnUpdatePositionToPattern)
	ON_COMMAND(ID_POSITIONTOPATTERN, OnPositionToPattern)
	ON_UPDATE_COMMAND_UI(ID_FILE_SCHEDULE, OnUpdateFileSchedule)
	ON_COMMAND(ID_SORTCHGFILESBYNAME, OnSortChgFilesByName)
	ON_UPDATE_COMMAND_UI(ID_SORTCHGFILESBYNAME, OnUpdateSortChgFilesByName)
	ON_COMMAND(ID_SORTCHGFILESBYEXT, OnSortChgFilesByExt)
	ON_UPDATE_COMMAND_UI(ID_SORTCHGFILESBYEXT, OnUpdateSortChgFilesByExt)
	ON_COMMAND(ID_SORTCHGFILESBYACTION, OnSortChgFilesByAction)
	ON_UPDATE_COMMAND_UI(ID_SORTCHGFILESBYACTION, OnUpdateSortChgFilesByAction)
	ON_COMMAND(ID_SORTCHGFILESBYRESOLVE, OnSortChgFilesByResolve)
	ON_UPDATE_COMMAND_UI(ID_SORTCHGFILESBYRESOLVE, OnUpdateSortChgFilesByResolve)
	ON_COMMAND(ID_SORTCHGSBYUSER, OnSortChgsByUser)
	ON_UPDATE_COMMAND_UI(ID_SORTCHGSBYUSER, OnUpdateSortChgsByUser)
	ON_COMMAND(ID_FILE_SCHEDULE, OnFileGet)
	ON_UPDATE_COMMAND_UI(ID_FILE_QUICKEDIT, OnUpdateFileAutoedit)
	ON_UPDATE_COMMAND_UI(ID_USER_SWITCHTOUSER, OnUpdateUserSwitchtouser)
	ON_COMMAND(ID_USER_SWITCHTOUSER, OnUserSwitchtouser)
	ON_UPDATE_COMMAND_UI(ID_CLIENTSPEC_SWITCH, OnUpdateClientspecSwitch)
	ON_COMMAND(ID_CLIENTSPEC_SWITCH, OnClientspecSwitch)
	ON_UPDATE_COMMAND_UI(ID_FILE_RMVEDITOR, OnUpdateRemoveViewer)
	ON_COMMAND(ID_FILE_RMVEDITOR, OnRemoveViewer)
	ON_COMMAND_RANGE(ID_FILE_EDITOR_1, ID_FILE_EDITOR_1+MAX_MRU_VIEWERS-1, OnFileMRUEditor)
	ON_COMMAND_RANGE(ID_FILE_BROWSER_1, ID_FILE_BROWSER_1+MAX_MRU_VIEWERS-1, OnFileMRUBrowser)
	ON_COMMAND(ID_FILE_NEWEDITOR, OnFileNewEditor)
	ON_COMMAND(ID_FILE_NEWBROWSER, OnFileNewBrowser)
	ON_UPDATE_COMMAND_UI(ID_VIEW_UPDATE_RIGHT, OnUpdateViewUpdate)
	ON_COMMAND(ID_VIEW_UPDATE_RIGHT, OnViewUpdate)
	ON_UPDATE_COMMAND_UI(ID_SELECTFILES_CHANGED, OnUpdateSelectChanged)
	ON_COMMAND(ID_SELECTFILES_CHANGED, OnSelectChanged)
	ON_UPDATE_COMMAND_UI(ID_SELECTFILES_UNCHANGED, OnUpdateSelectChanged)
	ON_COMMAND(ID_SELECTFILES_UNCHANGED, OnSelectUnchanged)
	ON_COMMAND(ID_PERFORCE_OPTIONS, OnPerforceOptions)
	ON_UPDATE_COMMAND_UI(ID_FILTER_SETVIEW, OnUpdateFilterSetview)
	ON_COMMAND(ID_FILTER_SETVIEW, OnFilterSetview)
	ON_UPDATE_COMMAND_UI(ID_FILTER_CLEARVIEW, OnUpdateFilterClearview)
	ON_COMMAND(ID_FILTER_CLEARVIEW, OnFilterClearview)
	ON_UPDATE_COMMAND_UI(ID_ADD_BOOKMARK, OnUpdateAddBookmark)
	ON_COMMAND(ID_ADD_BOOKMARK, OnAddBookmark)
	ON_UPDATE_COMMAND_UI(ID_FILE_ANNOTATE, OnUpdateFileAnnotate)
	ON_UPDATE_COMMAND_UI(ID_FILE_ANNOTATEALL, OnUpdateFileAnnotate)
	ON_UPDATE_COMMAND_UI(ID_FILE_ANNOTATECHG, OnUpdateFileAnnotate)
	ON_UPDATE_COMMAND_UI(ID_FILE_ANNOTATECHGALL, OnUpdateFileAnnotate)
	ON_COMMAND(ID_FILE_ANNOTATE, OnFileAnnotate)
	ON_COMMAND(ID_FILE_ANNOTATEALL, OnFileAnnotateAll)
	ON_COMMAND(ID_FILE_ANNOTATECHG, OnFileAnnotateChg)
	ON_COMMAND(ID_FILE_ANNOTATECHGALL, OnFileAnnotateChgAll)
	ON_MESSAGE(WM_P4ADD, OnP4Add )
	ON_MESSAGE(WM_P4AUTORESOLVE, OnP4AutoResolve )
	ON_MESSAGE(WM_P4MERGE2, OnP4Merge2 )
	ON_MESSAGE(WM_P4MERGE3, OnP4Merge3 )
	ON_MESSAGE(WM_P4RESOLVE, OnP4Resolve )
	ON_MESSAGE(WM_P4CHANGES, OnP4Change )
	ON_MESSAGE(WM_P4OSTAT, OnP4Ostat )
	ON_MESSAGE(WM_P4EDITSPEC, OnP4ChangeSpec )
	ON_MESSAGE(WM_P4ENDSPECEDIT, OnP4EndSpecEdit )
	ON_MESSAGE(WM_P4DELETE, OnP4ChangeDel )
	ON_MESSAGE(WM_P4DIFF, OnP4Diff )
	ON_MESSAGE(WM_P4LISTOPSTAT, OnP4ListOp )
	ON_MESSAGE(WM_P4GET, OnP4SyncAndEdit )
	ON_MESSAGE(WM_P4FIXES, OnP4Fixes )
	ON_MESSAGE(WM_P4FIX, OnP4Fix )
	ON_MESSAGE(WM_P4DESCRIBE, OnP4Describe )
	ON_MESSAGE(WM_P4ENDDESCRIBE, OnP4EndDescribe )
	ON_MESSAGE(WM_P4UNRESOLVED, OnP4UnResolved )
	ON_MESSAGE(WM_P4RESOLVED, OnP4Resolved )
    ON_MESSAGE(WM_P4JOBS, OnP4JobList )
    ON_MESSAGE(WM_JOBDELETED, OnP4JobDel )
	ON_MESSAGE(WM_UPDATEOPEN, OnP4UpdateOpen )
	ON_MESSAGE(WM_REVERTLIST, OnP4UpdateRevert )
	ON_MESSAGE(WM_SETUNRESOLVED, OnP4SetUnresolved )
	ON_MESSAGE(WM_GOTMOVELISTS, OnGotMoveLists )
	ON_MESSAGE(WM_GETDRAGTOCHANGENUM, OnGetDragToChangeNum )
	ON_MESSAGE(WM_INITTREE, OnInitTree )
	ON_MESSAGE(WM_OLEADDFILES, OnOLEAddFiles )
	ON_MESSAGE(WM_GETMYCHANGESLIST, OnGetMyChangesList )
	ON_MESSAGE(WM_P4FILEREVERT, OnP4FileRevert )
	ON_MESSAGE(WM_P4REVERT, OnP4Revert )
	ON_MESSAGE(WM_P4FILEINFORMATION, OnP4FileInformation )
	ON_MESSAGE(WM_P4ENDFILEINFORMATION, OnP4EndFileInformation )
	ON_MESSAGE(WM_P4DIFFCHANGEEDIT, OnP4DiffChangeEdit )
	ON_MESSAGE(WM_THEIRFINDINDEPOT, OnP4TheirFindInDepot )
	ON_MESSAGE(WM_THEIRHISTORY, OnP4TheirHistory )
	ON_MESSAGE(WM_THEIRPROPERTIES, OnP4TheirProperties )
	ON_MESSAGE(WM_SUBCHGOUFC, CallOnUpdateFilterClearview )
	ON_MESSAGE( WM_ACTIVATEMODELESS, OnActivateModeless )
END_MESSAGE_MAP()
 
CDeltaTreeCtrl::CDeltaTreeCtrl()
{
	m_OLESource.SetTreeCtrl(this);
	m_ItemCount=0;
 
	m_CF_DELTA = RegisterClipboardFormat(LoadStringResource(IDS_DRAGFROMDELTA));
	m_CF_DEPOT = RegisterClipboardFormat(LoadStringResource(IDS_DRAGFROMDEPOT));
	m_CF_JOB   = RegisterClipboardFormat(LoadStringResource(IDS_DRAGFROMJOB));
	m_MyRootExpanded= m_OthersRootExpanded= FALSE;
	m_SortByFilename  = GET_P4REGPTR()->SortChgFilesByName();
	m_SortByExtension = GET_P4REGPTR()->SortChgFilesByExt();
	m_SortByAction    = GET_P4REGPTR()->SortChgFilesByAction();
	m_SortByResolveStat = GET_P4REGPTR()->SortChgFilesByResolve();
 
    // Initialize tree state info
    m_FirstVisibleNodeGroup= CHANGELISTS_MINE;
 
	m_MyRoot= m_OthersRoot=NULL;
 
	m_ContextPoint.x = m_ContextPoint.y = -1;
	m_InContextMenu = FALSE;
	m_Need2Edit = m_Need2Refresh = m_EditInProgress = FALSE;
	m_DeltaIsDropTarget = FALSE;
	m_LastDragDropTime  = 0;
	m_DragDropCtr = 0;
	m_NewChgNbr = m_DragToChangeNum = 0;
	m_DragToChange = 0;
	m_PositionTo = _T("");
	m_caption = LoadStringResource(IDS_PENDING_PERFORCE_CHANGELISTS);
	m_RedoExpansion = FALSE;
	if (GET_P4REGPTR()->ExpandChgLists())
	{
		m_PrevExpansion = GET_P4REGPTR()->GetPendChgExpansion();
		if (!m_PrevExpansion.IsEmpty() && m_PrevExpansion.GetAt(0) == _T('1'))
			m_RedoExpansion = TRUE;
	}
}
 
CDeltaTreeCtrl::~CDeltaTreeCtrl()
{
}
 
void CDeltaTreeCtrl::OnShowWindow(BOOL bShow, UINT nStatus)
{
	if (m_EditInProgress && (bShow || GET_P4REGPTR()->AutoMinEditDlg()))
		m_EditInProgressWnd->ShowWindow(bShow ? SW_RESTORE : SW_SHOWMINNOACTIVE);
}
 
LRESULT CDeltaTreeCtrl::OnActivateModeless(WPARAM wParam, LPARAM lParam)
{
	if (m_EditInProgress && wParam == WA_ACTIVE)
		::SetFocus(m_EditInProgressWnd->m_hWnd);
	return 0;
}
 
void CDeltaTreeCtrl::SaveExpansion()
{
	if (GET_P4REGPTR()->ExpandChgLists())
	{
		CString	exp;
		TV_ITEM tvItem;
		tvItem.hItem = m_MyRoot;
		tvItem.stateMask = TVIS_EXPANDED;
		tvItem.mask = TVIF_STATE;
		TreeView_GetItem(m_hWnd, &tvItem);
		if(tvItem.state & TVIS_EXPANDED)
		{
			exp = _T("1");
			HTREEITEM item = GetChildItem(m_MyRoot);
			CString chglit = LoadStringResource(IDS_CHANGE);
			int chglgth = chglit.GetLength();
			while(item != NULL)
			{
				tvItem.hItem = item;
				tvItem.stateMask = TVIS_EXPANDED;
				tvItem.mask = TVIF_STATE;
				TreeView_GetItem(m_hWnd, &tvItem);
				if(tvItem.state & TVIS_EXPANDED)
				{
					int	i;
					CString txt = GetItemText(item);
					txt.TrimLeft();
					if ((i = txt.Find(chglit)) != -1)
					{
						txt = txt.Mid(i + chglgth);
						txt.TrimLeft();
						if ((i = txt.Find(_T(' '), 1)) != -1)
							txt = txt.Left(i);
					}
					exp += _T(",") + txt;
				}
				item = GetNextSiblingItem(item);
			}
		}
		else
			exp = _T("0");
		GET_P4REGPTR()->SetPendChgExpansion(exp);
	}
}
 
 
BOOL CDeltaTreeCtrl::IsAFile(HTREEITEM curr_item)
{
#ifdef _DEBUG
	// Caller should already have checked that tree level is correct
	BOOL underMyRoot;
	ASSERT(GetItemLevel(curr_item, &underMyRoot) == 2);
#endif
 
	if(GetLParam(curr_item) == NULL)
		return(FALSE);
	else
		return(TRUE);
}
 
UINT CDeltaTreeCtrl::GetItemState(HTREEITEM curr_item)
{
	TV_ITEM item;
	item.hItem=curr_item;
	item.mask=TVIF_STATE | TVIF_HANDLE;
	GetItem(&item);	
	return(item.state);
}
 
void CDeltaTreeCtrl::SetUnexpanded(HTREEITEM curr_item)
{
	TV_ITEM tvItem;
	tvItem.hItem=curr_item;
    tvItem.stateMask= TVIS_EXPANDED ;
	tvItem.state=0;
	tvItem.mask=TVIF_STATE | TVIF_HANDLE;
	SetItem(&tvItem);	
}
 
BOOL CDeltaTreeCtrl::HasChildren(HTREEITEM curr_item)
{
	TV_ITEM item;
	item.hItem=curr_item;
	item.mask=TVIF_CHILDREN | TVIF_HANDLE;
	GetItem(&item);	
	if(item.cChildren > 0 )
		return TRUE;
	else
		return FALSE;
}
 
 
 
/////////////////////////////////////////////////////////////////////////////
// CDeltaTreeCtrl diagnostics
 
#ifdef _DEBUG
void CDeltaTreeCtrl::AssertValid() const
{
	CMultiSelTreeCtrl::AssertValid();
}
 
void CDeltaTreeCtrl::Dump(CDumpContext& dc) const
{
	CMultiSelTreeCtrl::Dump(dc);
}
#endif //_DEBUG
 
/////////////////////////////////////////////////////////////////////////////
// CDeltaTreeCtrl message handlers
 
void CDeltaTreeCtrl::Clear()
{
	InitList();
}
 
LRESULT CDeltaTreeCtrl::OnInitTree(WPARAM wParam, LPARAM lParam)
{
	InitList();
	return 0;
}
 
void CDeltaTreeCtrl::DeleteItem(HTREEITEM item)
{
	ASSERT(item != NULL);
 
	LPARAM lParam=GetLParam(item);
	if(lParam > 0)
		delete (CP4FileStats *) lParam;
	
	CMultiSelTreeCtrl::DeleteItem(item);
}
 
void CDeltaTreeCtrl::DeleteLParams(HTREEITEM root)
{
	if(root==NULL)
		return;
 
	HTREEITEM change= GetChildItem(root);
	HTREEITEM file;
	LPARAM lParam;
 
	while(change != NULL)
	{
		file= GetChildItem(change);	
		while(file != NULL)
		{
			lParam=GetLParam(file);
			if(lParam > 0)
            {
                ASSERT_KINDOF(CP4FileStats, (CP4FileStats *) lParam);
                XTRACE(_T("CDeltaTreeCtrl::DeleteLParams: %s\n"), ((CP4FileStats *) lParam)->GetDepotFilename());
				delete (CP4FileStats *) lParam;
            }
 
			file=GetNextSiblingItem(file);
		}
		change=GetNextSiblingItem(change);
	}
}
 
void CDeltaTreeCtrl::InitList()
{
	UpdateTreeState(TRUE);	// saves the current expansion
 
	// Traverse tree, deleting each item's lParam
	DeleteLParams(m_MyRoot);
	if (m_OthersRoot)
	{
		DeleteLParams(m_OthersRoot);
		m_OthersRoot = NULL;
	}
 
    SetRedraw(FALSE);
 
    // Then delete all tree items and replace root level entries
	DeleteAllItems();
	CString rootName;
	rootName.FormatMessage(IDS_PENDING_CHANGELISTS_MY_CLIENT_s, GET_P4REGPTR()->GetP4Client());
	m_MyRoot=Insert(rootName, CP4ViewImageList::VI_YOURPENDING, EXPAND_FOLDER, TVI_ROOT, TRUE);
	m_MyDefault=Insert(LoadStringResource(IDS_DEFAULTCHANGELISTNAME), CP4ViewImageList::VI_YOURCHANGE, 0, m_MyRoot, TRUE);
	if (!m_DragToChangeNum)
		m_DragToChange=m_MyDefault;
 
	if ( GET_P4REGPTR()->GetEnablePendingChgsOtherClients( ) )
	{
		CString txt;
		int i = GET_P4REGPTR()->FilterPendChgsByMyClient();
		if (GET_SERVERLEVEL() < 21 && i > 1)
		{
			OnFilterClearview();
			i = 0;
		}
		switch(i)
		{
		case 1:
			txt.FormatMessage(IDS_PENDING_CHANGELISTS_OTHER_CLIENTS_FILTERED, 
						CString(_T("//")) + GET_P4REGPTR()->GetP4Client() + CString(_T("/...")));
			break;
		case 2:
			txt.FormatMessage(IDS_PENDING_CHANGELISTS_OTHER_CLIENTS_FILTERED, 
						GET_P4REGPTR()->FilterPendChgsByPath());
			break;
		default:
			txt = LoadStringResource(IDS_PENDING_CHANGELISTS_OTHER_CLIENTS);
			break;
		}
		// Initialize others root as already expanded so expand attempts during refresh are ignored
		// in cases where that refresh will already be fetching the needed ifo (running opened -a)
		// The final lParam and child count values are handled after the refresh in UpdateTreeState
		if( m_OthersRootExpanded )
			m_OthersRoot=Insert(txt, CP4ViewImageList::VI_THEIRPENDING, FOLDER_ALREADY_EXPANDED, TVI_ROOT, TRUE);
		else
			m_OthersRoot=Insert(txt, CP4ViewImageList::VI_THEIRPENDING, EXPAND_FOLDER, TVI_ROOT, TRUE);
	}
    SetRedraw(TRUE);
 
	// Select nothing, so there is no focus rect
	SelectItem(NULL);	
 
	// Clear flag for expanding others pending changelist root
	m_ExpandingOthersRoot= FALSE;
}
 
 
// During a tree refresh, the expanded states of items are lost, so record
// this info prior to the refresh and apply it to the view after the refresh
void CDeltaTreeCtrl::UpdateTreeState(BOOL saveTreeState)
{
	HTREEITEM item;
 
	if(saveTreeState)
	{
		m_MyRootExpanded= m_OthersRootExpanded= FALSE;
		m_ExpandedItems.RemoveAll();
		m_SelectedItems.RemoveAll();
 
		// First save selected items
		for(int i=-1; ++i < GetSelectedCount(); )
		{
			int j;
			HTREEITEM item= GetSelectedItem(i);
			CString txt = GetItemText(item);
			if (txt.GetAt(0) == _T('/') && ((j = txt.ReverseFind(_T('#'))) != -1))
				txt = txt.Left(j);
			m_SelectedItems.AddTail(txt);
		}
 
		// Now save the tree expansion
		if(GetCount() > 0)
		{
			// First, save expanded state of root items
			if(HasExpandedChildren(m_MyRoot))
				m_MyRootExpanded= TRUE;
 
			if (m_OthersRoot)
			{
				if(HasExpandedChildren(m_OthersRoot))
					m_OthersRootExpanded= TRUE;
			}
 
			// Then save expaned state of my changes
			item= GetChildItem(m_MyRoot);
			while(item != NULL)
			{
				if(HasExpandedChildren(item))
					m_ExpandedItems.AddHead(GetItemText(item));
				item= GetNextSiblingItem(item);
			}
 
			if (m_OthersRoot)
			{
				// Then save expanded state of other's changes
				item= GetChildItem(m_OthersRoot);
				while(item != NULL)
				{
					if(HasExpandedChildren(item))
						m_ExpandedItems.AddHead(GetItemText(item));
					item= GetNextSiblingItem(item);
				}
			}
		}
 
        // Record the first visible item
        m_FirstVisibleNodeGroup= CHANGELISTS_MINE;
        m_FirstVisibleNodeChange.Empty();
        m_FirstVisibleNodeFile.Empty();
 
        CString nodeText;
        HTREEITEM item= GetFirstVisibleItem();
   
        if( item != NULL )
        {
            BOOL underMyRoot=FALSE;
	        int level=GetItemLevel(item, &underMyRoot);
	        
            // If its a file, record filename minus rev and then set the item to parent
            if( level == 2 )
            {
                if( IsAFile( item ) )
                {
                    nodeText= GetItemText( item ); 
 
                    int pound= nodeText.ReverseFind(_T('#'));
                    if( pound != -1 )
                        m_FirstVisibleNodeFile= nodeText.Left(pound);
 
                }
                item=GetParentItem(item);
                level--;
            }
 
            // If item is a change, record change name and then set item to parent
            ASSERT( item != NULL && item != TVI_ROOT );
            if( level == 1 && item != NULL )
            {
                nodeText= GetItemText( item ); 
                if( nodeText.Find(LoadStringResource(IDS_DEFAULTCHANGELISTNAME)) == 0 )
                    m_FirstVisibleNodeChange= nodeText;
                else if( underMyRoot )
                {
                    m_FirstVisibleNodeChange= nodeText;
                    int comment= m_FirstVisibleNodeChange.Find(_T("{"));
                    if( comment != -1 )
                        m_FirstVisibleNodeChange= m_FirstVisibleNodeChange.Left(comment);
                }
                else
                {
                    int separator= nodeText.Find(_T(" - "));
                    if( separator != -1 )
                        m_FirstVisibleNodeChange= nodeText.Left(separator);
                }
 
                item=GetParentItem(item);
                level--;
            }
 
            // If item not null, record the node group
            ASSERT( item != NULL && item != TVI_ROOT );
            if( item != m_MyRoot )
                m_FirstVisibleNodeGroup= CHANGELISTS_OTHERS;
        }
    }
	else
	{
		if(m_MyRootExpanded)
			Expand(m_MyRoot, TVE_EXPAND);
 
		if (m_OthersRoot)
		{
			if(m_OthersRootExpanded && GetChildCount( m_OthersRoot ) )
				Expand(m_OthersRoot, TVE_EXPAND);
			else
			{
				// Make it ready for an attempted expand operation
				m_OthersRootExpanded= FALSE;
				SetLParam( m_OthersRoot, EXPAND_FOLDER );
				SetChildCount( m_OthersRoot, 1 );
			}
		}
 
		POSITION pos= m_ExpandedItems.GetHeadPosition();
		
		for( int i=0; i< m_ExpandedItems.GetCount(); i++)
		{
			item= FindItemByText(m_ExpandedItems.GetNext(pos));
			if(item != NULL)
				Expand(item, TVE_EXPAND);
		}
 
        // Attempt to scroll previous first item back into view, or at least
        // scroll the parent of that item back to the top of screen
        //
        // First set item to recorded node group
        if( m_FirstVisibleNodeGroup == CHANGELISTS_MINE )
            item= m_MyRoot;
        else
            item= m_OthersRoot;
 
        HTREEITEM changeItem= NULL;
        CString testtext;
 
        // Then try to set item to recorded change, if any
        if(!m_FirstVisibleNodeChange.IsEmpty() )
        {
            int testlen=m_FirstVisibleNodeChange.GetLength();
            changeItem=GetChildItem(item);
            
	        while(changeItem !=NULL)
	        {
		        testtext=GetItemText(changeItem);
                if(m_FirstVisibleNodeChange.Compare(testtext.Left(testlen)) == 0)
			        break;
			    
		        changeItem=GetNextSiblingItem(changeItem);
	        }
 
            if( changeItem != NULL )
                item= changeItem;
        }
 
        // Finally try to set item to recorded file, if any
        if(changeItem != NULL && !m_FirstVisibleNodeFile.IsEmpty() )
        {
            int testlen=m_FirstVisibleNodeFile.GetLength();
            HTREEITEM fileItem=GetChildItem(changeItem);
 
            while(fileItem !=NULL)
	        {
		        testtext=GetItemText(fileItem);
                if(m_FirstVisibleNodeFile.Compare(testtext.Left(testlen)) == 0 && testtext[testlen]==_T('#') )
			        break;
			    
		        fileItem=GetNextSiblingItem(fileItem);
	        }
            
            if( fileItem != NULL )
                item= fileItem;
        }
 
        // Then scroll the tree into position
        if( item != NULL )
            ScrollToFirstItem( item );
 
		// Now reselect any previously selected items that are still in my changelists
		if (!m_SelectedItems.IsEmpty())
		{
			pos= m_SelectedItems.GetHeadPosition();
			
			item = NULL;
			for( int i=0; i< m_SelectedItems.GetCount(); i++)
			{
				CString txt = m_SelectedItems.GetNext(pos);
				if (txt.GetAt(0) == _T('/'))
					item= FindMyOpenFile(txt, item);
				else
					item= FindItemByText(txt);
				if(item != NULL)
					SetSelectState(item, TRUE);
			}
			m_SelectedItems.RemoveAll();
			ApplySelectAtts(GetSelectAtts());
		}
	}
}
 
// A message handler to get target change number without having to
// include CDeltaTreeCtrl.h
LRESULT CDeltaTreeCtrl::OnGetDragToChangeNum(WPARAM wParam, LPARAM lParam)
{
	CPoint *point= (CPoint *) wParam;
 
	point->x= m_DragToPoint.x;
	point->y= m_DragToPoint.y;
 
	XTRACE(_T("OnGetDragToChangeNum change=%d\n"), m_DragToChangeNum);
	return (LRESULT) m_DragToChangeNum;
}
 
// Note: this handler is a stripped down version of OnP4Ostat
//       - doesnt need to run 'P4 fixes'
//       - doesnt need to forward info to Depot window
//       - doesnt need to consider unresolved files
LRESULT CDeltaTreeCtrl::OnP4Add(WPARAM wParam, LPARAM lParam)
{
	BOOL bSorted=FALSE;
	BOOL chainedCommands=FALSE;
	CP4FileStats *stats;
	CString text;
	POSITION pos;
	
	CCmd_Add *pCmd= (CCmd_Add *) wParam;
	ASSERT_KINDOF(CCmd_Add, pCmd);
 
	if( !pCmd->GetError() )
	{
		text.FormatMessage(IDS_ADDED_n_FILES, pCmd->GetAddedFileCount());
		AddToStatus(text, SV_COMPLETION);
	}
	if ( !pCmd->GetError() && pCmd->GetOpenAction() && !pCmd->GetStr2Edit().IsEmpty() )
	{
		int key= pCmd->GetServerKey();
		chainedCommands= TRUE;
 
		m_StringList.RemoveAll();
 
		pos= pCmd->GetStr2Edit().GetHeadPosition();
		while( pos != NULL )
		{
			// Get the filenames to open for edit
			CString txt = pCmd->GetStr2Edit().GetNext(pos);
			m_StringList.AddTail(txt);
		}
 
		CCmd_ListOpStat *pCmd2= new CCmd_ListOpStat;
		pCmd2->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK, key );
		pCmd2->SetHitMaxFileSeeks(TRUE);	// we will need to do a full refresh at the end
		pCmd2->SetChkForSyncs(TRUE);
		CObList const * pList = pCmd->GetList();
		if (pList->GetCount())
		{
			for( pos= pList->GetHeadPosition(); pos!= NULL; )
				pCmd2->Add2RevertList( pList->GetNext(pos), pCmd->GetOpenAction() );
		}
		if( pCmd2->Run( &m_StringList, P4EDIT, pCmd->GetChangeNum() ) )
			MainFrame()->UpdateStatus( LoadStringResource(IDS_OPENING_FILES_FOR_EDIT) );
		else
			delete pCmd2;
		// delete the stats in the pCmd's main list
		// because we are now done with them
		CObList const *list= pCmd->GetList();
		if (!list->IsEmpty())
		{
			for( pos= list->GetHeadPosition(); pos!= NULL; )
				delete (CP4FileStats *) list->GetNext(pos);
		}
	}
	else if ( !pCmd->GetError() && (pCmd->GetOpenAction() == 1) && !pCmd->GetList()->IsEmpty() )
	{	// user requested Edit only, but nothing to edit - must reverts any adds
		int key= pCmd->GetServerKey();
		chainedCommands= TRUE;
 
		m_StringList.RemoveAll();
 
		CObList const * pList = pCmd->GetList();
		for( pos= pList->GetHeadPosition(); pos!= NULL; )
		{
			CP4FileStats *stats= (CP4FileStats *)(pList->GetNext(pos));
			CString name=stats->GetFullDepotPath();
			m_StringList.AddTail(name);
		}
 
		CCmd_ListOpStat *pCmd2= new CCmd_ListOpStat;
		pCmd2->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK, key );
		pCmd2->SetHitMaxFileSeeks(TRUE);	// we will need to do a full refresh at the end
		if( pCmd2->Run( &m_StringList, P4REVERT ) )
			MainFrame()->UpdateStatus( LoadStringResource(IDS_REQUESTING_REVERT) );
		else
			delete pCmd2;
	}
	else if (!pCmd->GetError() 
		  && (pCmd->HitMaxFileSeeks() 
		   || (GET_P4REGPTR( )->ShowEntireDepot( ) == SDF_LOCALTREE)))
	{
		// Too much was added for seeking out each file for an att update
		// to be efficient (or we need to refresh the local view).
		// Just start a full update.
		int key= pCmd->GetServerKey();
		chainedCommands= TRUE;
		MainFrame()->UpdateDepotandChangeViews(REDRILL, key);
		// Clean up any 'stats' in the pCmd's list because this pCmd is soon deleted
		CObList const * pList = pCmd->GetList();
		for( pos= pList->GetHeadPosition(); pos!= NULL; )
		{
			CP4FileStats *stats= (CP4FileStats *)(pList->GetNext(pos));
			delete stats;
		}
	}
	else if( !pCmd->GetError() )
	{
		// Get the filelist
		CObList const *list= pCmd->GetList();
		HTREEITEM currentItem = NULL;
 
        SetRedraw(FALSE);
		if(list->GetCount() > 0)
		{
			// then get the list contents into the tree
			POSITION pos= list->GetHeadPosition();
			while( pos != NULL )
			{
				// Get the cursed filename
				stats= (CP4FileStats *) list->GetNext(pos);
 
				// Find the change this file is under.  Create change if reqd.
				currentItem=InsertChange(stats, TRUE);
				if(currentItem!=NULL)
				{
					Insert(stats->GetFormattedChangeFile(GET_P4REGPTR()->ShowFileType(), GET_P4REGPTR()->ShowOpenAction()),
								TheApp()->GetFileImageIndex(stats,TRUE), (LPARAM) stats, currentItem, FALSE);
				}
			} //while
		} // if
		if( currentItem != NULL && GetChildItem(currentItem) != NULL )
		{
			SetChildCount(currentItem, 1);
			if (GET_P4REGPTR()->ExpandChgLists( ))
				Expand(currentItem, TVE_EXPAND);
		}
        SetRedraw(TRUE);
 
		SortTree();
		bSorted = TRUE;
		RedrawWindow();
		MainFrame()->SetLastUpdateTime(UPDATE_SUCCESS);
		MainFrame()->ClearStatus();
	}
	else
		MainFrame()->ClearStatus();
 
	if( !chainedCommands || MainFrame()->IsQuitting() )
	{
		pCmd->ReleaseServerLock();
		if (!bSorted && (m_SortByExtension || m_SortByResolveStat 
			          || m_SortByAction    || m_SortByFilename))
			SortTree();
	}
    delete pCmd;
 
	return 0;
}
 
 
LRESULT CDeltaTreeCtrl::OnP4AutoResolve(WPARAM wParam, LPARAM lParam)
{
	CCmd_AutoResolve *pCmd= (CCmd_AutoResolve *) wParam;
 
	if( !pCmd->GetError() && !MainFrame()->IsQuitting() )
	{
		CStringList *list= pCmd->GetList();
	
		CString temp;
		if(pCmd->IsPreview())
			temp.FormatMessage(IDS_n_FILES_WOULD_BE_RESOLVED, list->GetCount());
		else
			temp.FormatMessage(IDS_n_FILES_RESOLVED, list->GetCount());
		
		AddToStatus(temp, SV_COMPLETION);
 
		if(!pCmd->IsPreview())
		{
			// 1) Hold onto the key 
			// 2) Clear all unresolved attributes
			// 3) Run resolved -n with the key
			int key= pCmd->GetServerKey();
			ClearUnresolvedFlags();
			CCmd_Unresolved *pCmd2= new CCmd_Unresolved;
			pCmd2->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK, key );
 
			if( !pCmd2->Run() )
			{
				ASSERT(0);
				delete pCmd2;
			}
		}
		else
			pCmd->ReleaseServerLock();
	}
	else
		pCmd->ReleaseServerLock();
		
	MainFrame()->ClearStatus();
	delete pCmd;
	return 0;
}
 
 
void CDeltaTreeCtrl::SetCorrectChglistImage(HTREEITEM change)
{
	HTREEITEM file= GetChildItem(change);	
	while(file != NULL)
	{
		LPARAM lParam=GetLParam(file);
		if(lParam > 0)
        {
			CP4FileStats *stats= (CP4FileStats *) lParam;
            ASSERT_KINDOF(CP4FileStats, stats);
            if (stats->IsUnresolved())
			{
				int ix = stats->IsOtherUserMyClient() ? CP4ViewImageList::VI_YOUROTHERCHGUNRES 
													  : CP4ViewImageList::VI_YOURCHGUNRES;
				SetImage(change, ix, ix);
				return;
			}
		}
		file=GetNextSiblingItem(file);
	}
	SetImage(change, CP4ViewImageList::VI_YOURCHANGE, CP4ViewImageList::VI_YOURCHANGE);
}
 
void CDeltaTreeCtrl::ClearUnresolvedFlags( )
{
	HTREEITEM change= GetChildItem(m_MyRoot);
	HTREEITEM file;
	LPARAM lParam;
 
	while(change != NULL)
	{
		SetImage(change, CP4ViewImageList::VI_YOURCHANGE, CP4ViewImageList::VI_YOURCHANGE);
		file= GetChildItem(change);	
		while(file != NULL)
		{
			lParam=GetLParam(file);
			if(lParam > 0)
            {
				CP4FileStats *stats= (CP4FileStats *) lParam;
                ASSERT_KINDOF(CP4FileStats, stats);
                stats->SetUnresolved(FALSE);
				int img=TheApp()->GetFileImageIndex(stats,TRUE);
				SetImage(file, img, img);
            }
 
			file=GetNextSiblingItem(file);
		}
		change=GetNextSiblingItem(change);
	}
}
 
 
LRESULT CDeltaTreeCtrl::OnP4Merge2(WPARAM wParam, LPARAM lParam)
{
	MainFrame()->ClearStatus();
 
	if(wParam !=0)
	{
		MainFrame()->DoNotAutoPoll();
		CGuiClientMerge *merge= (CGuiClientMerge *) wParam;
		CMerge2Dlg dlg;
		dlg.SetKey(lParam);
		dlg.SetMergeInfo(merge);
		if (dlg.DoModal() == IDC_CANCEL_ALL)
			m_ResolveList.RemoveAll();
		merge->Signal();
		MainFrame()->ResumeAutoPoll();
	}
	
	return 0;
}
 
LRESULT CDeltaTreeCtrl::OnP4Merge3(WPARAM wParam, LPARAM lParam)
{
	MainFrame()->ClearStatus();
 
	if(wParam !=0)
	{
		MainFrame()->DoNotAutoPoll();
		CGuiClientMerge *merge= (CGuiClientMerge *) wParam;
		CMerge3Dlg dlg;
		dlg.SetMergeInfo(merge);
		dlg.SetForceFlag(m_ForcedResolve);
		dlg.SetTextualFlag(m_TextualMerge);
		dlg.SetRunMerge(m_bRunMerge);
		dlg.SetKey(lParam);
		if (dlg.DoModal() == IDC_CANCEL_ALL)
			m_ResolveList.RemoveAll();
		merge->Signal();
		// can't use MainFrame()-> construct
		// because mainfram might have closed.
		CMainFrame * mainWnd = MainFrame();
		if (mainWnd)
			mainWnd->ResumeAutoPoll();
	}
	
	return 0;
}
 
 
LRESULT CDeltaTreeCtrl::OnP4Resolve(WPARAM wParam, LPARAM lParam)
{
	CCmd_Resolve *pCmd= (CCmd_Resolve *) wParam;
 
	if(!pCmd->GetError())
	{
		if(pCmd->GetResolved())
		{
			CP4FileStats *stats= (CP4FileStats *) GetLParam(m_ActiveItem);
			ASSERT_KINDOF(CP4FileStats, stats);
 
			stats->SetUnresolved(FALSE);
			stats->SetResolved(TRUE);
			int img=TheApp()->GetFileImageIndex(stats,TRUE);
			SetImage(m_ActiveItem, img, img);
			SetCorrectChglistImage(TreeView_GetParent(m_hWnd, m_ActiveItem));
		}
	}
	
	delete pCmd;
	MainFrame()->ClearStatus();
 
	// if there are more items to resolve, fire up a resolve on the next one
	if (!m_ResolveList.IsEmpty())
	{
		HTREEITEM item = (HTREEITEM)(m_ResolveList.RemoveHead());
		ResolveItem(item);
	}
	else if (m_SortByExtension || m_SortByResolveStat || m_SortByAction || m_SortByFilename)
		SortTree();
	return 0;
}
 
LRESULT CDeltaTreeCtrl::OnP4UnResolved(WPARAM wParam, LPARAM lParam)
{
	CCmd_Unresolved *pCmd= (CCmd_Unresolved *) wParam;
 
	if(!pCmd->GetError() && !MainFrame()->IsQuitting())
	{
		SET_BUSYCURSOR();
		HTREEITEM item = NULL;
		CObArray const *pArray= pCmd->GetArray();
		for( int i=0; i < pArray->GetSize(); i++ )
		{
			CP4FileStats *stats= (CP4FileStats *) pArray->GetAt(i);
 
			item= FindMyOpenFile( stats->GetFullDepotPath(), item );
 
			if( item != NULL )
			{
				int lParam= GetLParam(item);
				if( lParam > 0 )
				{
					CP4FileStats *fs= (CP4FileStats *) lParam;
					fs->SetUnresolved(TRUE);
					int img=TheApp()->GetFileImageIndex(fs,TRUE);
					SetImage(item, img, img);
					int ix = fs->IsOtherUserMyClient() ? CP4ViewImageList::VI_YOUROTHERCHGUNRES 
													   : CP4ViewImageList::VI_YOURCHGUNRES;
					SetImage(TreeView_GetParent(m_hWnd, item), ix, ix);
				}
				else
					ASSERT(0);
			}
 
			delete stats;
		}
		int key= pCmd->GetServerKey();
		CCmd_Resolved *pCmd2= new CCmd_Resolved;
		pCmd2->Init( m_hWnd, RUN_ASYNC, LOSE_LOCK, key );
		if( !pCmd2->Run() )
		{
			ASSERT(0);
			delete pCmd2;
			::SetCursor(::LoadCursor(NULL, IDC_ARROW));
		}
	}
	else pCmd->ReleaseServerLock();
	
	delete pCmd;
	MainFrame()->ClearStatus();
	return 0;
}
 
LRESULT CDeltaTreeCtrl::OnP4Resolved(WPARAM wParam, LPARAM lParam)
{
	CCmd_Resolved *pCmd= (CCmd_Resolved *) wParam;
 
	if(!pCmd->GetError())
	{
		SET_BUSYCURSOR();
		HTREEITEM item = NULL;
		CObArray const *pArray= pCmd->GetArray();
		for( int i=0; i < pArray->GetSize(); i++ )
		{
			CP4FileStats *stats= (CP4FileStats *) pArray->GetAt(i);
 
			item= FindMyOpenFile( stats->GetFullDepotPath(), item );
 
			if( item != NULL )
			{
				int lParam= GetLParam(item);
				if( lParam > 0 )
				{
					CP4FileStats *fs= (CP4FileStats *) lParam;
					fs->SetResolved(TRUE);
				}
				else
					ASSERT(0);
			}
 
			delete stats;
		}
		if (m_SortByExtension || m_SortByResolveStat || m_SortByAction || m_SortByFilename)
			SortTree();
		::SetCursor(::LoadCursor(NULL, IDC_ARROW));
	}
	
	delete pCmd;
	MainFrame()->ClearStatus();
	return 0;
}
 
LRESULT CDeltaTreeCtrl::OnP4Diff(WPARAM wParam, LPARAM lParam)
{
	CCmd_Diff *pCmd= (CCmd_Diff *) wParam;
    BOOL chainedCommands= FALSE;
    
	if(!pCmd->GetError())
	{
		CStringList *list= pCmd->GetList();
	
		if(m_DoRevert)
		{
			chainedCommands = DoRevert(list, pCmd->GetServerKey());
        }
		else // not m_DoRevert
		{
			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);
			}
		}	
	}
    
    if( !chainedCommands || MainFrame()->IsQuitting() )
    {
        // Error, so make sure server lock is released
        if(pCmd->HaveServerLock())
            pCmd->ReleaseServerLock();
    	MainFrame()->ClearStatus();
    }
	delete pCmd;
	return 0;
}
 
BOOL CDeltaTreeCtrl::DoRevert(CStringList *list, int key/*=0*/, BOOL bUnChg/*=FALSE*/)
{
    BOOL chainedCommands= FALSE;
	POSITION pos;
 
	if(!list->IsEmpty())  // Some filenames in the list
	{
		HTREEITEM currItem=GetLastSelection();  
		CRevertListDlg listDlg;
		listDlg.Init(list);
		if(listDlg.DoModal() == IDOK)
		{
			// first check to see if they want to delete all unchanged files in this chg
			// if so, we can do it quickly using p4 revert -a -c [chg#]
			// however if there are only 1 or 2 files, we do them individually
			if (!listDlg.AnyRowsDeleted() && GET_SERVERLEVEL() >= 14 
			  && currItem && list->GetCount() > 2)
			{
				CCmd_Revert *pCmd= new CCmd_Revert;
				pCmd->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK);
				CString chgnbr;
				m_EditChangeNum=GetChangeNumber(currItem);
				if (m_EditChangeNum)
					chgnbr.Format(_T("%ld"), m_EditChangeNum);
				else
					chgnbr = _T("default");
				pCmd->SetChgName(chgnbr);
				if( pCmd->Run( chgnbr, TRUE, TRUE, FALSE ) )
					m_DoRevert=FALSE;
				else
				{
					MainFrame()->ClearStatus();
					delete pCmd;
				}
			}
			else if(!list->IsEmpty())
			{
				// Copy the stringlist to our list and then delete, so we dont have
				// to keep track of the list pointer and when to delete it
				for(pos=list->GetHeadPosition(); pos!=NULL; )
				{
					CString str = list->GetNext(pos);
					if (GET_SERVERLEVEL() < 14)	// pre 2002.2?
					{
						if (str.FindOneOf(_T("@#%*")) != -1)
						{
							StrBuf b;
							StrBuf f;
							f << CharFromCString(str);
							StrPtr *p = &f;
							StrOps::WildToStr(*p, b);
							str = CharToCString(b.Value());
						}
					}
					else
					{
						int i;
						if ((i = str.ReverseFind(_T('#'))) != -1)
							str = str.Left(i);
					}
					m_StringList.AddHead(str);
				}
			
				// Then start the revert
				CCmd_ListOpStat *pCmdRevert= new CCmd_ListOpStat;
				pCmdRevert->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK, key);
				if( pCmdRevert->Run( &m_StringList, bUnChg ? P4REVERTUNCHG : P4REVERT ) )
				{
					MainFrame()->UpdateStatus( LoadStringResource(IDS_REVERTING_FILES) );
					chainedCommands= TRUE;
				}
				else
					delete pCmdRevert;
			}
		}
	}
	else
		AddToStatus(LoadStringResource(IDS_NO_FILES_WILL_BE_REVERTED_BECAUSE), SV_WARNING);
	return chainedCommands;
}
 
void CDeltaTreeCtrl::OnP4Reopen(CStringList *list)
{
	POSITION pos;
	CString fileName;
	CString info;
	CString temp;
	BOOL isReopenByType= FALSE;
	
	HTREEITEM item = NULL;
	int imageIndex = -1;
	int ix = 0;
	LPARAM param;
	CP4FileStats *stats;
				
    SetRedraw(FALSE);
	for(pos=list->GetHeadPosition(); pos!=NULL;)
	{
		// Get the 'filename#n - reopened; change x' text
		//  or the 'filename#n - reopened; type x' text
		fileName=list->GetNext(pos);
		// Find the space after filename
		int separator= fileName.Find(_T(" - reopened; "));
		info=fileName.Mid(separator+13);
        		
		if(info.Find(_T("type")) != -1)
		{
			isReopenByType= TRUE;
 
            // Then find the file and update the file type info
            int pound=fileName.ReverseFind(_T('#'));
            if( pound != -1 )
                fileName=fileName.Left(pound);  
			
			item=FindMyOpenFile(fileName, item);
			ASSERT(item != NULL);
			if(item != NULL)
			{
				stats= (CP4FileStats *) GetLParam(item);
				stats->SetType(info.Mid(lstrlen(_T("type "))));
				SetItemText(item, stats->GetFormattedChangeFile(GET_P4REGPTR()->ShowFileType(), GET_P4REGPTR()->ShowOpenAction()));
				int img=TheApp()->GetFileImageIndex(stats,TRUE);
				SetImage(item, img, img);
			}
		}
		else
		{
            // Then find and remove the file from beneath m_DragFromChange
 
			int i;
            fileName=fileName.Left(separator);
			if ((i = fileName.ReverseFind(_T('#'))) != -1)
				fileName = fileName.Left(i);
			
			item=GetChildItem(m_DragFromChange);
			param=NULL;
			while(item != NULL)
			{
				if(IsAFile(item))
				{
					param= GetLParam(item);
					ASSERT(param != 0);
					stats= (CP4FileStats *) param;
					ASSERT_KINDOF(CP4FileStats, stats);
					temp= stats->GetFullDepotPath();
					if(temp == fileName)
					{
						imageIndex=GetImage(item);
						stats->SetOpenChangeNum( m_DragToChangeNum );
						ix = stats->IsOtherUserMyClient() ? CP4ViewImageList::VI_YOUROTHERCHANGE 
														  : CP4ViewImageList::VI_YOURCHANGE;
 
						// reopen and update open file info
						//
						if(stats->GetOtherOpens())
						{
							if (GET_SERVERLEVEL() < 19)	// earlier than 2005.1?
							{
								if(stats->IsOtherLock())
									stats->SetLocked(TRUE, FALSE);
								stats->SetOpenAction( stats->GetOtherOpenAction(), FALSE);
								stats->SetOpenAction( 0, TRUE );
								stats->SetOtherUsers(_T(""));
							}
							imageIndex= TheApp()->GetFileImageIndex(stats, TRUE);
						}
 
						temp= stats->GetFormattedChangeFile(
							GET_P4REGPTR()->ShowFileType(), 
							GET_P4REGPTR()->ShowOpenAction());
						// Do NOT call DeltaTreeCtrl::DeleteItem() because 
						// that will nuke the lParam.  All we want to do here
						// is remove the item from the tree control.
						CMultiSelTreeCtrl::DeleteItem(item);
						break;
					}
				}
				item=GetNextSiblingItem(item);
			}
 
			ASSERT(item != NULL);  // just reopened an item that wasnt in tree!
				
			// And add under m_DragToChange
			if(item != NULL && imageIndex >= 0)
			{
				item=Insert(temp, imageIndex, param, m_DragToChange, TRUE);
				// we may have to reset the icon on the dragtochange because
				// the Insert() is looking at data for the drag from change
				// which might have been our client/other user. But we know
				// the dragtochange is ours - so force it for unresolved files.
				stats= (CP4FileStats *) GetLParam(item);
				if (stats->IsUnresolved())
					SetImage(m_DragToChange, CP4ViewImageList::VI_YOURCHGUNRES, 
											 CP4ViewImageList::VI_YOURCHGUNRES);
			}
			ASSERT(item != NULL);
		}// if reopen by type or change
	}
 
	if( !isReopenByType && list->GetCount() )
	{
		int img;
		// Make sure the source change is closed if it was just emptied
		if( GetChildItem(m_DragFromChange) == NULL )
		{
			SetUnexpanded(m_DragFromChange);
			SetChildCount(m_DragFromChange, 0);
			SetLParam(m_DragFromChange, EXPAND_FOLDER);
			SetImage(m_DragFromChange, ix, ix);
		}
		else if ((img = GetImage(m_DragFromChange)) == CP4ViewImageList::VI_YOURCHGUNRES
			   || img == CP4ViewImageList::VI_YOUROTHERCHGUNRES)
		{
			SetCorrectChglistImage(m_DragFromChange);
		}
 
		// Make sure the target change is openable if it contains children
		if( GetChildItem(m_DragToChange) != NULL )
		{
			SetChildCount(m_DragToChange, 1);
			if (GET_P4REGPTR()->ExpandChgLists( ))
				Expand(m_DragToChange, TVE_EXPAND);
		}
		if (m_SortByExtension || m_SortByResolveStat || m_SortByAction || m_SortByFilename)
			SortTree();
	}
 
    SetRedraw(TRUE);
	
	// Make sure all selected items got cleared and window repainted correctly
	UnselectAll();
	RedrawWindow();
 
   	MainFrame()->ClearStatus();
}
 
 
LRESULT CDeltaTreeCtrl::OnP4ListOp(WPARAM wParam, LPARAM lParam)
{
	int key = -1;
	POSITION pos;
	BOOL chainedCommands=FALSE;
	BOOL bNeed2Sync = FALSE;
	BOOL bNeed2Revert = FALSE;
	BOOL bRevertAdds = FALSE;
	int  iRedoOpenedFilter = 0;
	CCmd_ListOpStat *pCmd= (CCmd_ListOpStat *) wParam;
	
	if(!pCmd->GetError())
	{
		iRedoOpenedFilter = pCmd->GetRedoOpenedFilter();
		if( pCmd->GetChkForSyncs() )
		{
			int rc;
 
			key = pCmd->GetServerKey();
			chainedCommands = TRUE;
			if((rc = MsgBox(IDS_ONE_OR_MORE_FILES_IS_NOT_THE_HEAD_REVISION, 
						MB_ICONEXCLAMATION | MB_DEFBUTTON3)) == IDC_BUTTON1)
			{
				if(pCmd->GetRevertAdds()->GetCount())
					bRevertAdds = TRUE;
				else
					MainFrame()->UpdateDepotandChangeViews(REDRILL, key);
			}
			else if (rc == IDC_BUTTON2)	// Sync then edit
			{
				bNeed2Sync   = TRUE;
				bNeed2Revert = TRUE;
				if(pCmd->GetRevertAdds()->GetCount())
					bRevertAdds = TRUE;
			}
			else // (rc == IDC_BUTTON3)	// Cancel
				bNeed2Revert = TRUE;
		}
		else if( pCmd->GetSync2Head() )
		{
			key = pCmd->GetServerKey();
			chainedCommands = TRUE;
			CStringList *pSyncList = pCmd->GetUnsynced();	// the files to sync to head
			SyncList2Head(pSyncList, key);
		}
		else if( pCmd->GetRevertAdds()->GetCount() )
		{
			key = pCmd->GetServerKey();
			chainedCommands = TRUE;
			bRevertAdds = TRUE;
		}
		else if( pCmd->HitMaxFileSeeks() )
		{
			// Too much was added for seeking out each file for an att update
			// to be efficient.  Just start a full update.
			key = pCmd->GetServerKey();
			chainedCommands = TRUE;
			if (pCmd->GetRevertUnchgAfter())
			{
				CCmd_ListOpStat *pCmd2= new CCmd_ListOpStat;
				pCmd2->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK, key );
				pCmd2->SetRedoOpenedFilter(pCmd->GetRedoOpenedFilter());
				pCmd2->SetHitMaxFileSeeks(TRUE);
				if( pCmd2->Run( &m_StringList2, P4REVERTUNCHG ) )
				{
					MainFrame()->UpdateStatus( LoadStringResource(IDS_REQUESTING_REVERT) );
					iRedoOpenedFilter = 0;
				}
				else
				{
					delete pCmd2;
					MainFrame()->UpdateDepotandChangeViews(REDRILL, key);
				}
			}
			else
				MainFrame()->UpdateDepotandChangeViews(REDRILL, key);
			m_Need2Refresh = FALSE;
		}
		else if(pCmd->GetCommand() == P4REVERT
			 || pCmd->GetCommand() == P4REVERTUNCHG
			 || pCmd->GetCommand() == P4VIRTREVERT)
		{
			chainedCommands = OnP4RevertFile(pCmd->GetList(), TRUE, 
									pCmd->GetOutputErrFlag(), pCmd->GetRevertUnchgAfter(), 
									pCmd->GetServerKey(), pCmd->GetRedoOpenedFilter());
			if (chainedCommands)
				iRedoOpenedFilter = 0;
		}
		else if(pCmd->GetCommand() == P4REOPEN)
		{
			OnP4Reopen(pCmd->GetList());
		}
		else if(pCmd->GetCommand() == P4EDIT)
		{
			CStringList *pList = pCmd->GetList();
			// An empty output list coming back from the server
			// can occur if a file has been branched and is then
			// opened for edit (which opens it for add, of course).
			// So if we arrive here with an empty list, just do a
			// full refresh since we have no data to work with.
			if (pList->IsEmpty())
			{
				key = pCmd->GetServerKey();
				chainedCommands = TRUE;
				MainFrame()->UpdateDepotandChangeViews(REDRILL, key);
			}
			else OnP4EditFile(pList);
		}
		else
			ASSERT(0);
	}
 
	// For the above commands, we do not need any ostat type
	// info that CCmd_ListOpStat may have collected, so just
	// delete it to avoid leakage
	pCmd->DeleteStatList();
 
	if( !chainedCommands || MainFrame()->IsQuitting() )
		pCmd->ReleaseServerLock();
 
	BOOL bOutputError = pCmd->GetOutputErrFlag();
 
	if (bNeed2Revert || bRevertAdds)
	{
		m_StringList.RemoveAll();
 
		CStringList * pNewList = 0;
		CStringList * pRevertList;
		CStringList * pSyncList = pCmd->GetUnsynced();	// the files to revert, then sync
		CCmd_ListOpStat *pCmd2= new CCmd_ListOpStat;
		if (bNeed2Sync)
			pNewList = pCmd2->GetUnsynced();	// a place to save the files to sync to head
		else if (bNeed2Revert)
		{
			pRevertList = pCmd->GetRevertIfCancel();
			for( pos= pRevertList->GetHeadPosition(); pos!= NULL; )
				m_StringList.AddTail( pRevertList->GetNext(pos) );
		}
		if (bRevertAdds)
		{
			pRevertList = pCmd->GetRevertAdds();
			for( pos= pRevertList->GetHeadPosition(); pos!= NULL; )
				m_StringList.AddTail( pRevertList->GetNext(pos) );
		}
		if (bNeed2Sync)
		{
			for( pos= pSyncList->GetHeadPosition(); pos!= NULL; )
			{
				CString txt = pSyncList->GetNext(pos);
				m_StringList.AddTail( txt );
                ASSERT(pNewList);
				pNewList->AddTail( txt );
			}
		}
 
        ASSERT(key != -1);
		pCmd2->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK, key );
		if (bNeed2Sync)
			 pCmd2->SetSync2Head(TRUE);			// they want to sync to head afterwards
		else pCmd2->SetHitMaxFileSeeks(TRUE);	// we will need to do a full refresh at the end
		if( pCmd2->Run( &m_StringList, P4REVERT ) )
			MainFrame()->UpdateStatus( LoadStringResource(IDS_REQUESTING_REVERT) );
		else
			delete pCmd2;
	}
 
	delete pCmd;
 
	if (m_Need2Edit)
	{
		m_Need2Edit = FALSE;
		::SendMessage(m_depotWnd, m_Msg2Send, (WPARAM) &m_ClientPath, m_SavelParam);
	}
	if (iRedoOpenedFilter)
		::SendMessage(m_depotWnd, WM_REDOOPENEDFILTER, (WPARAM)iRedoOpenedFilter, 0);
	else if (bOutputError)
		::PostMessage(m_depotWnd, WM_COMMAND, ID_VIEW_UPDATE_LEFT, 0);
	return 0;
}
 
void CDeltaTreeCtrl::SyncList2Head(CStringList *pSyncList, int key)
{
	POSITION pos;
 
	m_StringList.RemoveAll();
 
	for( pos= pSyncList->GetHeadPosition(); pos!= NULL; )
		m_StringList.AddTail( pSyncList->GetNext(pos) + _T("#head") );
 
	CCmd_Get *pCmd= new CCmd_Get;
	pCmd->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK, key);
	if( pCmd->Run( &m_StringList, FALSE, TRUE ) )
		MainFrame()->UpdateStatus( LoadStringResource(IDS_FILE_SYNC) );
	else
		delete pCmd;
}
 
LRESULT CDeltaTreeCtrl::OnP4SyncAndEdit(WPARAM wParam, LPARAM lParam)
{
	CCmd_Get *pCmd= (CCmd_Get *) wParam;
 
	int i;
	int key= pCmd->GetServerKey();
	POSITION pos;
 
	m_StringList.RemoveAll();
 
	CStringList *pSyncList = pCmd->GetGetList();
	for( pos= pSyncList->GetHeadPosition(); pos!= NULL; )
	{
		// Get the filenames to open for edit
		CString txt = pSyncList->GetNext(pos);
		if ((i = txt.Find(_T('#'))) != -1)
			txt = txt.Left(i);
		m_StringList.AddTail(txt);
	}
 
	CCmd_ListOpStat *pCmd2= new CCmd_ListOpStat;
	pCmd2->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK, key );
	pCmd2->SetHitMaxFileSeeks(TRUE);	// we will need to do a full refresh at the end
	if( pCmd2->Run( &m_StringList, P4EDIT, 0 ) )
		MainFrame()->UpdateStatus( LoadStringResource(IDS_OPENING_FILES_FOR_EDIT) );
	else
		delete pCmd2;
 
	delete pCmd;
 
	return 0;
}
 
// Message handler to allow the depot window to pass a result
// set from 'p4 revert'
LRESULT CDeltaTreeCtrl::OnP4UpdateRevert(WPARAM wParam, LPARAM lParam)
{
	CStringList *list= (CStringList *) wParam;
	OnP4RevertFile(list, FALSE);
	return 0;
}
 
BOOL CDeltaTreeCtrl::OnP4RevertFile(CStringList *list, BOOL notifyDepotWnd/*=TRUE*/, 
									BOOL errs/*=FALSE*/, BOOL revertUnchgAfter/*=FALSE*/,
									int key/*=0*/, BOOL redoOpenedFilter/*=FALSE*/)
{
	POSITION pos;
	CString fileName;
	int pound;
 
    // Temporarily disable redraws for both windows
    SetRedraw(FALSE);
    ::SendMessage(m_depotWnd, WM_SETREDRAW, FALSE, 0);
 
	for(pos=list->GetHeadPosition(); pos!=NULL;)
	{
		fileName=list->GetNext(pos);
 
		// Strip revision number if present
		pound=fileName.ReverseFind(_T('#'));
		if(pound != -1)
			fileName=fileName.Left(pound);  
	
		// Let the depot view know what happened
		if(notifyDepotWnd)
			::SendMessage(m_depotWnd, WM_UPDATEOPEN, (WPARAM) &fileName, 0);
 
		// And finally, delete it from this tree
		HTREEITEM item=FindMyOpenFile(fileName);
		if(item != NULL)
		{
			HTREEITEM change= GetParentItem(item);
			DeleteItem(item);
			// Make sure the source change is closed if it was just emptied
			if( change != NULL && GetChildItem(change) == NULL && !errs)
			{
				SetUnexpanded(change);
				SetChildCount(change, 0);
				SetLParam(change, EXPAND_FOLDER);
			}
			SetCorrectChglistImage(change);
		}
		else
			ASSERT(0);
	}	
 
    SetRedraw(TRUE);
    ::SendMessage(m_depotWnd, WM_SETREDRAW, TRUE, 0);
    RedrawWindow();
    ::RedrawWindow( m_depotWnd, NULL, NULL, RDW_INVALIDATE );
	
	if (revertUnchgAfter)
	{
		CCmd_ListOpStat *pCmd2= new CCmd_ListOpStat;
		pCmd2->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK, key );
		pCmd2->SetNbrChgedFilesReverted(list->GetCount());
		pCmd2->SetRedoOpenedFilter(redoOpenedFilter);
		if( pCmd2->Run( &m_StringList2, P4REVERTUNCHG ) )
		{
			MainFrame()->UpdateStatus( LoadStringResource(IDS_REQUESTING_REVERT) );
			return TRUE;
		}
		else
		{
			delete pCmd2;
			MainFrame()->UpdateDepotandChangeViews(REDRILL, key);
		}
	}
	else
		MainFrame()->ClearStatus();
 
	return FALSE;
}
 
void CDeltaTreeCtrl::OnP4EditFile(CStringList *list)
{
	POSITION pos;
	CString fileName;
	int pound;
 
    // Temporarily disable redraws for windows
    SetRedraw(FALSE);
 
	for(pos=list->GetHeadPosition(); pos!=NULL;)
	{
		fileName=list->GetNext(pos);
 
		// Strip revision number if present
		pound=fileName.ReverseFind(_T('#'));
		if(pound != -1)
			fileName=fileName.Left(pound);  
	
		// And finally, update the item's status
		HTREEITEM item=FindMyOpenFile(fileName);
		if(item != NULL)
		{
			CP4FileStats *newStats;
			CP4FileStats *stats= (CP4FileStats *) GetLParam(item);
			HTREEITEM change= GetParentItem(item);
 
			newStats= new CP4FileStats;
			newStats->Create(stats);
			newStats->SetOpenAction(F_EDIT, FALSE);
			DeleteItem(item);
			Insert(newStats->GetFormattedChangeFile(GET_P4REGPTR()->ShowFileType(), 
				GET_P4REGPTR()->ShowOpenAction()), 
				TheApp()->GetFileImageIndex(newStats, TRUE), (LPARAM) newStats, change, TRUE);
		}
		else
			ASSERT(0);
	}	
 
    SetRedraw(TRUE);
    RedrawWindow();
	
   	MainFrame()->ClearStatus();
}
 
// A change description was sent to the server, 'P4 change -i".
// This should be a confirming message. 
LRESULT CDeltaTreeCtrl::OnP4ChangeSpec(WPARAM wParam, LPARAM lParam)
{
	CCmd_EditSpec *pCmd= (CCmd_EditSpec *) wParam;
   	MainFrame()->ClearStatus();
 
	if(!pCmd->GetError() && !m_EditInProgress 
	 && pCmd->PreprocessChgSpec() && pCmd->DoSpecDlg(this))
	{
		m_EditInProgress = TRUE;
		m_EditInProgressWnd = pCmd->GetSpecSheet();
		DragAcceptFiles(FALSE);
	}
	else
	{
		if (pCmd->HaveServerLock())
			pCmd->ReleaseServerLock();
		if( !TheApp()->m_SubmitPath.IsEmpty() )
			MainFrame()->PostMessage(WM_COMMAND, ID_APP_EXIT, 0);
		delete pCmd;
	}
	return 0;
}
 
LRESULT CDeltaTreeCtrl::OnP4EndSpecEdit( WPARAM wParam, LPARAM lParam )
{
	CCmd_EditSpec *pCmd= (CCmd_EditSpec *) wParam;
    BOOL chainedCommands=FALSE;
 
	if (lParam != IDCANCEL && lParam != IDABORT)
    {
		if(pCmd->GetSpecDlgExit() == IDALTERNATE || m_EditChangeNum == 0 || pCmd->EditedLists())
		{
			if (TheApp()->m_SubmitPath.IsEmpty())
			{
				// Get the lock and start the update process w/out dropping the lock
				int key= pCmd->HaveServerLock() ? pCmd->GetServerKey( ) : 0;
           		MainFrame()->UpdateDepotandChangeViews(REDRILL, key);
				chainedCommands=TRUE;
			}
 
			CString txt;
			if(pCmd->GetSpecDlgExit() == IDALTERNATE)
			{
				txt.FormatMessage(IDS_CHANGE_n_SUBMITTED, pCmd->GetNewChangeNum());
				AddToStatus(txt, SV_COMPLETION);
				MainFrame()->SetOldChgUpdateTime(0);
				MainFrame()->SetJobUpdateTime(0);
			}
			UnselectAll();
		}
		else
		{
			if(pCmd->GetSpecDlgExit() == IDNEEDTOREFRESH)
			{
				// We need to do a resolve so update our internal stats
				// Get the lock and start the update process w/out dropping the lock
				int key= pCmd->HaveServerLock() ? pCmd->GetServerKey( ) : 0;
           		MainFrame()->UpdateDepotandChangeViews(REDRILL, key);
				chainedCommands=TRUE;
				// If we got here via a cmd line -S flag,
				// restore the main window and clear the submit path
				if (!TheApp()->m_SubmitPath.IsEmpty())
				{
					MainFrame()->ShowWindow(SW_RESTORE);
					TheApp()->m_SubmitPath.Empty();
				}
			}
			else	// we need to update the screen to reflect the new description
			{
				// The change description is always changed, so put together the
				// new item text for the change node.  Note that the change number
				// must be correctly formatted to avoid bungling the sort order
									
				CString txt;
				CString desctxt=PadCRs(pCmd->GetChangeDesc());
 
				if(GET_P4REGPTR()->ShowChangeDesc())
				{
					int trunc = (GET_SERVERLEVEL() >= 19) 
							  ? GET_P4REGPTR()->GetUseLongChglistDesc() : 31;
					CString shorttxt = TruncateString(desctxt, trunc);
					txt.FormatMessage(
                        shorttxt == desctxt ? IDS_CHANGE_n_s
                                            : IDS_CHANGE_n_s_TRUNC, 
                        pCmd->GetNewChangeNum(), 
						shorttxt);
				}
				else
					txt.FormatMessage(IDS_CHANGE_n, pCmd->GetNewChangeNum());
				
				if(m_EditChangeNum == 0)
				{
					// The default change was edited, so rename the change, and
					// insert a new default change in the tree
					
					SetItemText(m_MyDefault, txt);
					m_MyDefault=Insert(LoadStringResource(IDS_DEFAULTCHANGELISTNAME), CP4ViewImageList::VI_YOURCHANGE, NULL, m_MyRoot, TRUE);
					if (!m_DragToChangeNum)
						m_DragToChange=m_MyDefault;
				}
				else
					// We just edited an existing change, so just update the 
					// description text
					SetItemText(m_EditChange, txt);
		
				txt.FormatMessage(IDS_CHANGE_n_UPDATED, (long) pCmd->GetNewChangeNum());
				AddToStatus(txt);
			}
		}
	}
	if (lParam != IDABORT)
	{
		MainFrame()->ClearStatus();
		if( !chainedCommands || MainFrame()->IsQuitting() )
		{
			if (pCmd->HaveServerLock())
				pCmd->ReleaseServerLock();
			if( !chainedCommands && !TheApp()->m_SubmitPath.IsEmpty() )
				MainFrame()->PostMessage(WM_COMMAND, ID_APP_EXIT, 0);
		}
		CDialog *dlg = (CDialog *)pCmd->GetSpecSheet();
		dlg->DestroyWindow();
	}
	delete pCmd;
	m_EditInProgress = FALSE;
	DragAcceptFiles(TRUE);
	return 0;
}
 
LRESULT CDeltaTreeCtrl::OnP4ChangeDel(WPARAM wParam, LPARAM lParam)
{
	CCmd_Delete *pCmd= (CCmd_Delete *) wParam;
 
	if(!pCmd->GetError())
	{
		CString text=pCmd->GetCompletionData();
		int offset= text.Find(_T("deleted"));
		
		if(offset >= 7 && offset < 18)
		{
			// Completion looks like "Change 5000 deleted."
			AddToStatus( pCmd->GetCompletionMessage(), SV_COMPLETION);
			// No need to delete children since its an empty change
			if (!pCmd->IgnoreActiveItem())
				DeleteItem(m_ActiveItem);
			// Make sure the updated window draws correctly
			UnselectAll();
			RedrawWindow();	
		}
		else
		{
			// Completion looks like "Change 5000 has 4 open files and can't be deleted."
			AddToStatus( pCmd->GetCompletionMessage(), SV_WARNING);
			ASSERT(0);
		}
	}
	
	delete pCmd;
   	MainFrame()->ClearStatus();
	return 0;
}
 
LRESULT CDeltaTreeCtrl::OnP4Ostat(WPARAM wParam, LPARAM lParam)
{
	CP4FileStats *stats;
	
	CCmd_Ostat *pCmd= (CCmd_Ostat *) wParam;
	// Get the filelist
	CObArray const *array= pCmd->GetArray();
	ASSERT_KINDOF(CObArray,array);
 
	if(pCmd->GetError() || MainFrame()->IsQuitting())
	{
		// Something went wrong, so delete the command and the result list
		if(array->GetSize() > 0)
		{
			for( int i=0; i < array->GetSize(); i++)
			   delete (CP4FileStats *) array->GetAt(i);
		}
        pCmd->ReleaseServerLock();
		delete pCmd;
 
		RedrawWindow();
		MainFrame()->SetLastUpdateTime(UPDATE_FAILED);
		
       	MainFrame()->ClearStatus();
		return 0;
	}
	
	// Change-verification parameters used to avoid searching for
	// the same change repeatedly
	HTREEITEM changeItem=NULL;
	int lastChangeNum= -1;
	CString lastOtherUser;
		
	if(array->GetSize() > 0)
	{
		// Temporarily disable redraws
        SetRedraw(FALSE);
		BOOL needExpand=FALSE;
 
		// Array of filestats open for Add - may need to pass this list to the Depot pane
		CObList lAdds;
        
        // then get the list contents into the tree
		for( int i=0; i<array->GetSize(); i++ )
		{
			// Get the cursed filename
			stats= (CP4FileStats *) array->GetAt(i);
 
			if( m_ExpandingOthersRoot && ( stats->IsMyOpen() || stats->IsOtherUserMyClient() ) )
			{
				delete stats;
				continue;
			}
			else if( m_ExpandingOthersRoot )
				needExpand=TRUE;
 
            // Find/create the change this file is under if the change number or user@client has changed
            // Otherwise, use the cached changeItem, because verifying that a change exists is slow as
            // a MUNI light rail car
			if( lastChangeNum != stats->GetOpenChangeNum() || Compare(lastOtherUser, stats->GetOtherUsers()) != 0 )
			{
                if( !stats->IsMyOpen() && stats->GetOpenChangeNum() == 0 
									   && stats->GetOtherOpens() != 0)
                {
                    // Someone else's default change; insert it without checking, because it can't be
                    // in the tree yet.  Note this only works because CCmd_Ostat has sorted the
                    // results by ismyopen+changenum+user@client
                    changeItem=InsertChange(stats, FALSE);
                }
                else
				    changeItem=InsertChange(stats, TRUE);
 
				lastChangeNum = stats->GetOpenChangeNum();
				lastOtherUser = !lastChangeNum && stats->IsMyOpen() 
							  ? _T("") : stats->GetOtherUsers();
			}
 
			if(changeItem!=NULL)
			{
				// Insert the file under the change
				Insert(stats->GetFormattedChangeFile(GET_P4REGPTR()->ShowFileType(), GET_P4REGPTR()->ShowOpenAction()),
							TheApp()->GetFileImageIndex(stats, TRUE), (LPARAM) stats, changeItem, FALSE);
			}
			else
				ASSERT(0);
 
			// if we are showing local files in client tree,
			// save the stats of any adds for passing to the depot pane
			if ((GET_P4REGPTR( )->ShowEntireDepot( ) == SDF_LOCALTREE)
			 && (stats->GetMyOpenAction() == F_ADD || stats->GetOtherOpenAction() == F_ADD 
			  || stats->GetMyOpenAction() == F_BRANCH || stats->GetOtherOpenAction() == F_BRANCH))
				lAdds.AddTail(stats);
 
			if ( !PumpMessages( ) || MainFrame()->IsQuitting() )
			{
                pCmd->ReleaseServerLock();
				delete pCmd;
                SetRedraw(TRUE);
                ::SendMessage(m_depotWnd, WM_SETREDRAW, TRUE, 0);
				return 0;
			}
		} // for entire array
#if 0	// the if() is not quite right yet
		if( m_OthersRoot && needExpand && GET_P4REGPTR()->FilterPendChgsByMyClient() )
		{
			// walk all other client changes and remove empty ones
			HTREEITEM item= m_OthersRoot;
 
			item=GetChildItem(item);	// Search for the second level node
			while(item != NULL)
			{
				HTREEITEM nextitem = GetNextSiblingItem(item);
				HTREEITEM firstchild = GetChildItem(item);
				if (!firstchild)
					DeleteItem(item);
//				else
//				{
//					CString childStr=GetItemText(firstchild);
//					int ii = 0;
//				}
				item = nextitem;
			}
		}
#endif
		if( m_OthersRoot && needExpand )
		{
			SetLParam( m_OthersRoot, FOLDER_ALREADY_EXPANDED);
			Expand( m_OthersRoot, TVE_EXPAND );
		}
 
		// if there were any files opend for add
		// (and we save their fstats because we are showing all local files in client tree)
		// pass those fstat info to the depot pane
		if (lAdds.GetCount())
			::SendMessage(m_depotWnd, WM_SETADDFSTATS, (BOOL)m_ExpandingOthersRoot, (LPARAM)&lAdds);
    } // if
 
    
	// Expand the tree again
    SetRedraw(FALSE);
	SortTree();
	if( !m_ExpandingOthersRoot )
	{
		// First time only - should we re-expand the tree to the previous execution's state?
		if (m_RedoExpansion)
		{
			int i = 2;
			m_MyRootExpanded = TRUE;
			m_ExpandedItems.RemoveAll();
			if ((i = m_PrevExpansion.Find(_T(','))) != -1)
			{
				CString txt;
				CString testtext;
				HTREEITEM item;
				m_PrevExpansion = m_PrevExpansion.Mid(i+1);
				while ((i = m_PrevExpansion.Find(_T(','))) != -1)
				{
					txt = _T(' ') + m_PrevExpansion.Left(i);
					item=GetChildItem(m_MyRoot);
					while (item)
					{
						testtext=GetItemText(item);
						if(testtext.Find(txt) != -1)
						{
							m_ExpandedItems.AddTail(testtext);
							break;
						}
						item=GetNextSiblingItem(item);
					}
					m_PrevExpansion = m_PrevExpansion.Mid(i+1);
				}
				if (!m_PrevExpansion.IsEmpty())
				{
					txt = _T(' ') + m_PrevExpansion;
					item=GetChildItem(m_MyRoot);
					while (item)
					{
						testtext=GetItemText(item);
						if(testtext.Find(txt) != -1)
						{
							m_ExpandedItems.AddTail(testtext);
							break;
						}
						item=GetNextSiblingItem(item);
					}
				}
			}
			m_RedoExpansion = FALSE;
		}
		UpdateTreeState(FALSE);
	}
        
    // And finally, make sure both windows redraw.  This is the last step in a multi-step
    // process, so it is a good place to verify that everything displays properly.  These
    // two lines are not inside the above if{} because we want to make sure that redraw
    // is turned on, even if there are no open files
    SetRedraw(TRUE);
    ::SendMessage(m_depotWnd, WM_SETREDRAW, TRUE, 0);
 
	RedrawWindow();
	if( !m_ExpandingOthersRoot )
	{
		::RedrawWindow( m_depotWnd, NULL, NULL, RDW_INVALIDATE );
		MainFrame()->SetFullRefresh(FALSE);
	}
	
	MainFrame()->SetLastUpdateTime(UPDATE_SUCCESS);
    pCmd->ReleaseServerLock();
	MainFrame()->UpdateStatus(_T(" "));
 
	if( m_OthersRoot && m_ExpandingOthersRoot )
	{
		m_ExpandingOthersRoot= FALSE;
		if (!m_PositionTo.IsEmpty())
		{
			PositionToFileInChg(m_PositionTo, m_OthersRoot, m_OthersRoot, TRUE);
			m_PositionTo.Empty();
		}
	}
	else
	{
		// Notify the mainframe that we have finished dealing with changlists,
		// hence the entire set of port connection async command have finished.
		MainFrame()->FinishedGettingChgs(TRUE);
	}
	delete pCmd;
	return 0;
}
 
 
// Support for fetching fixes as numbered changes are opened:
//
// 1) When changes are added via OnP4Changes() or VerifyChange(),
//    they are added with LParam==0
// 2) If we have fetched the fixes info for a given numbered change,
//    they have LParam==FOLDER_ALREADY_EXPANDED
 
BOOL CDeltaTreeCtrl::ExpandTree( const HTREEITEM item )
{
    if( APP_HALTED() || !item )
        return FALSE;
 
	int lParam= GetLParam( item );
 
	//  A) See if OtherPendingChanges just got expanded for first time, and
	//     if so, go handle that special case
	if( item == m_OthersRoot && lParam == EXPAND_FOLDER && !m_OthersRootExpanded )
		return ExpandOthersRoot( );
 
    //	B) Test to see if it's a numbered change that we havent already expanded
	//	   If it's my root and it has not been previously expanded,
	//	   expand each of my changelists with no files to remove the
	//	   plus sign, or show that it has only jobs
 
	if ( item == m_MyRoot && lParam != FOLDER_ALREADY_EXPANDED )
	{
		ExpandEmptyChglists();
		SetLParam(m_MyRoot, FOLDER_ALREADY_EXPANDED);
	}
	
	if ( item == m_MyRoot || item == m_OthersRoot || lParam == FOLDER_ALREADY_EXPANDED )
		return TRUE;
 
	//	C) Get the change number, and bail if it's somebody's
	//     default change, since there wont be any fixes
	int changeNum= GetChangeNumber(item);
	if ( changeNum <= 0 )
		return TRUE;
 
	//  D) And finally fire up fixes
	CCmd_Fixes *pCmdFixes= new CCmd_Fixes;
	pCmdFixes->Init( m_hWnd, RUN_ASYNC);
	if( pCmdFixes->Run(changeNum, item) )
	{
		MainFrame()->UpdateStatus( LoadStringResource(IDS_UPDATING_JOB_FIXES) );
	}
	else
	{
		delete pCmdFixes;
		RedrawWindow();
       	MainFrame()->ClearStatus();
	}
 
	return TRUE;
}
 
BOOL CDeltaTreeCtrl::ExpandOthersRoot()
{
	// If server is busy, ignore the request
	if( SERVER_BUSY() )
	{
		Sleep(0);
		SET_BUSYCURSOR();
		// wait a bit in 1/10 sec intervals to see if the prev request finishes
		int t=GET_P4REGPTR()->BusyWaitTime();
		do
		{
			Sleep(50);
			t -= 50;
		} while (SERVER_BUSY() && t > 0);
		if( SERVER_BUSY() )
		{
			MessageBeep(0);
			return FALSE;
		}
	}
 
	CCmd_Ostat *pCmdOstat= new CCmd_Ostat;
	pCmdOstat->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK );
	
	if( pCmdOstat->Run( TRUE ) )  
	{
		MainFrame()->UpdateStatus( LoadStringResource(IDS_CHECKING_OPEN_FILES) );
		m_ExpandingOthersRoot=TRUE;
		return TRUE;
	}
	else
	{
		delete pCmdOstat;
		return FALSE;
	}
}
 
LRESULT CDeltaTreeCtrl::OnP4Fixes(WPARAM wParam, LPARAM lParam)
{
	CCmd_Fixes *pCmd= (CCmd_Fixes *) wParam;
 
	if(!pCmd->GetError())
	{
        // The fixes command has the HTREEITEM that it was launched with,
        // and that item is 99.9% likely to still be valid and still point
        // to the right changelist.  But look up the change number anyway,
        // since that 0.1% of cases may happen.
        
        HTREEITEM item= FindChange(pCmd->GetFixedChangeNumber());
        if( item != NULL )
        {
			SetLParam( item, FOLDER_ALREADY_EXPANDED);
			if( pCmd->GetList()->GetCount() == 0 )
			{
				if( GetChildItem( item ) == NULL )
					SetChildCount( item, 0 );
			}
			else
			{
				OnFixes( item, pCmd->GetList());
				Expand( item, TVE_EXPAND );
			}
		}
	}
	
   	MainFrame()->ClearStatus();
		
	delete pCmd;
	return 0;
}
 
void CDeltaTreeCtrl::OnFixes(HTREEITEM activeItem, CObList *fixes)
{
	ASSERT_KINDOF(CObList,fixes);
	CP4Fix *fix;
	CString text;
 
	HTREEITEM changeItem = NULL;
 
    if( !fixes->GetCount() )
        return;
 
    // Turn off redraw and record the top item before we start, so
    // we can undo any spurious scrolling before user sees it
    SetRedraw(FALSE);
    HTREEITEM oldTop= GetFirstVisibleItem();
 
	POSITION pos;
	for(pos= fixes->GetHeadPosition(); pos != NULL; )
	{
		fix=(CP4Fix *) fixes->GetNext(pos);
		ASSERT_KINDOF(CP4Fix,fix);
		
        changeItem = FindChange(fix->GetChangeNum());
		if( changeItem != NULL )
        {
			// Insert the fix under the change
		    text= fix->GetJobName();
		    if(FindFix(fix->GetChangeNum(), fix->GetJobName()) == NULL)
				Insert(text, CP4ViewImageList::VI_JOB, NULL, changeItem, TRUE);
        }
		delete fix;
	} //for
 
	// Make sure the target change is openable if it contains children
	if( changeItem != NULL && GetChildItem(changeItem) != NULL )
	{
		SetChildCount(changeItem, 1);
		if (GET_P4REGPTR()->ExpandChgLists( ))
			Expand(changeItem, TVE_EXPAND);
	}
 
    // Scroll back to old top row, and then redraw
    SetRedraw(TRUE);
    if( oldTop != NULL )
        ScrollToFirstItem( oldTop );
    
}
 
 
LRESULT CDeltaTreeCtrl::OnP4JobDel(WPARAM wParam, LPARAM lParam)
{
	// A  job was just deleted, so we need to verify that the
	// job does not exist in this view as a fix or fixes
	// wParam is an LPCTSTR that contains the job name
	
	ASSERT((LPCTSTR) wParam != NULL && lstrlen((LPCTSTR) wParam) <256);
	
	CString jobName= (LPCTSTR) wParam;
	int compareLen=jobName.GetLength();
 
	HTREEITEM subItem;
	HTREEITEM delItem;
	HTREEITEM item=GetChildItem(m_MyRoot);
	while(item !=NULL)
	{
		subItem=GetChildItem(item);
		while(subItem != NULL)
		{
			delItem=subItem;
			subItem=GetNextSiblingItem(subItem);
	
			if(jobName==(GetItemText(delItem)).Left(compareLen))  
				DeleteItem(delItem);
		}
		item=GetNextSiblingItem(item);
	}
 
	if (m_OthersRoot)
	{
		item=GetChildItem(m_OthersRoot);
		while(item !=NULL)
		{
			subItem=GetChildItem(item);
			while(subItem != NULL)
			{
				delItem=subItem;
				subItem=GetNextSiblingItem(subItem);
		
				if(jobName==(GetItemText(delItem)).Left(compareLen))  
					DeleteItem(delItem);
			}
			item=GetNextSiblingItem(item);
		}
	}
 
	RedrawWindow();
	return 0;
}
 
 
LRESULT CDeltaTreeCtrl::OnP4Fix(WPARAM wParam, LPARAM lParam)
{
	CP4Fix *fix;
	CString text;
	HTREEITEM currentItem;
	int change=0;
	
	CCmd_Fix *pCmd= (CCmd_Fix *) wParam;
	if(pCmd->IsUnfixing() && !pCmd->GetError())
	{
		CObList *list= pCmd->GetList();
	
		if(list->GetCount() > 0)
		{
			POSITION pos= list->GetHeadPosition();
			while( pos != NULL )
			{
				fix= (CP4Fix *) list->GetNext(pos);
				
				// Find the fix and delete it
				currentItem=FindFix(fix->GetChangeNum(), fix->GetJobName());
				change= fix->GetChangeNum();
				if(currentItem!=NULL)
					DeleteItem(currentItem);	
				else
					ASSERT(0);  // Should have been in tree!
 
				delete fix;
			} //while
		} // if
 
		// Make sure the source change looks empty if it was just emptied
		if( change > 0 )
		{
			HTREEITEM parentItem= FindChange( change );
			if( parentItem != NULL && GetChildItem(parentItem) == NULL )
			{
				SetUnexpanded( parentItem );
				SetChildCount( parentItem, 0);
				SetLParam( parentItem, EXPAND_FOLDER );
			}
		}
 
		RedrawWindow();
	}
	else
	{
		// Add new fixes to display
		OnFixes(m_ActiveItem, pCmd->GetList());
        RedrawWindow();
	}
	
   	MainFrame()->ClearStatus();
	delete pCmd;
	return 0;
}
 
 
LRESULT CDeltaTreeCtrl::OnP4JobDescribe(WPARAM wParam, LPARAM lParam)
{
	CCmd_Describe *pCmd= (CCmd_Describe *) wParam;
 
	if(!pCmd->GetError())
	{
		CString desc= MakeCRs(pCmd->GetDescription());
		
		int key;
		CSpecDescDlg *dlg = new CSpecDescDlg(this);
		dlg->SetIsModeless(TRUE);
		dlg->SetKey(key = pCmd->HaveServerLock()? pCmd->GetServerKey() : 0);
		dlg->SetItemName(pCmd->GetReference());
		dlg->SetDescription(desc);
		dlg->SetCaption( LoadStringResource(IDS_PERFORCE_FIXED_JOB_DESCRIPTION) );
		dlg->SetViewType(P4JOB_SPEC);
		dlg->SetShowEditBtn(!key ? TRUE : FALSE);
		if (!dlg->Create(IDD_SPECDESC, this))	// display the description dialog box
		{
			dlg->DestroyWindow();	// some error! clean up
			delete dlg;
		}
	}
 
	delete pCmd;
	MainFrame()->ClearStatus();
	return 0;
}
 
LRESULT CDeltaTreeCtrl::OnP4EndJobDescribe( WPARAM wParam, LPARAM lParam )
{
	CSpecDescDlg *dlg = (CSpecDescDlg *)lParam;
 
	if (wParam == IDC_EDITIT)				// which button did they click to close the box?
	{
		CString jobname = dlg->GetItemName();
		ASSERT(!jobname.IsEmpty());
		MainFrame()->EditJobSpec(&jobname);
	}
	dlg->DestroyWindow();
	return TRUE;
}
		
LRESULT CDeltaTreeCtrl::OnP4UpdateOpen(WPARAM wParam, LPARAM lParam)
{
	// This message is SENDMESSAGE'd by DepotView when a file's open status
	// is changed.  Only three types of status updates are possible:
	// 1) file was locked
	// 2) file was unlocked
	// 3) file was opened for edit, delete, integ or branch
 
	// The command is in lParam, and a CP4FileStats obj is in wParam
	
	CP4FileStats *stats= (CP4FileStats *) wParam;
	CP4FileStats *newStats, *oldStats;
 
	// First step is to try finding the item
	HTREEITEM item = FindMyOpenFile(stats->GetFullDepotPath());
	
	switch(lParam)
	{
	case P4LOCK:
	case P4UNLOCK:
		if(item != NULL)
		{
			oldStats= (CP4FileStats *) GetLParam(item);
 
			// update image and stats values
			oldStats->SetLocked(stats->IsMyLock(), FALSE);
			oldStats->SetLocked(FALSE, TRUE);
			int img=TheApp()->GetFileImageIndex(oldStats, TRUE);
			SetImage(item, img, img);
		}
		else
			// How did we just lock a file that we previously did not
			// have open?
			ASSERT(0);
 
		break;
 
	case P4ADD:
	case P4EDIT:
	case P4DELETE:
	case P4INTEG:
		if(item != NULL)
		{
			oldStats= (CP4FileStats *) GetLParam(item);
			if(stats->GetMyOpenAction() > 0) // Its in the tree and still open
			{
				// update image and stats values
				oldStats->SetLocked(stats->IsMyLock(), FALSE);
				if(stats->IsMyLock())
					// If I have a lock, no other user can
					oldStats->SetLocked(FALSE, TRUE);
				int img=TheApp()->GetFileImageIndex(oldStats, TRUE);
				if ((oldStats->GetMyOpenAction() == F_INTEGRATE) 
					&& (stats->GetMyOpenAction() == F_EDIT))
				{
					HTREEITEM change;
 
					if(stats->GetOpenChangeNum() == m_DragToChangeNum)
						change=m_DragToChange;
					else
					{
						change= InsertChange(stats,TRUE);
						m_DragToChange= change;
						m_DragToChangeNum= stats->GetOpenChangeNum();
					}
					DeleteItem(item);
					newStats= new CP4FileStats;
					newStats->Create(stats);
					Insert(newStats->GetFormattedChangeFile(GET_P4REGPTR()->ShowFileType(), 
						GET_P4REGPTR()->ShowOpenAction()), 
						TheApp()->GetFileImageIndex(newStats, TRUE), (LPARAM) newStats, change, TRUE);
				}
				else if ((lParam == P4INTEG) && stats->IsUnresolved()
					  && (oldStats->GetMyOpenAction() == F_EDIT) 
					  && (stats->GetMyOpenAction() == F_EDIT))
				{
					oldStats->SetUnresolved(TRUE);
					img=TheApp()->GetFileImageIndex(oldStats, TRUE);
					SetImage(item, img, img);
					int ix = stats->IsOtherUserMyClient() ? CP4ViewImageList::VI_YOUROTHERCHGUNRES 
														  : CP4ViewImageList::VI_YOURCHGUNRES;
					SetImage(TreeView_GetParent(m_hWnd, item), ix, ix);
				}
				else
					SetImage(item, img, img);
            }
			else
			{
				// There is probably something wrong if we are here, because we should
				// not be processing reverted files here.  But if the file has no open
				// action and we found it here, deleted it from the tree
				if(stats->GetOtherOpenAction() == 0) // Do the delete if no one else has it open
				{
					ASSERT(0);
					DeleteItem(item);
				}
			}
		}
		else  // item not found in tree
		{
			// File was just opened for edit
			if(stats->GetMyOpenAction() > 0)  
			{
				HTREEITEM change;
				if(stats->GetOpenChangeNum() > 0)
				{
					// Two ways to get here:
					if(stats->GetOpenChangeNum() == m_DragToChangeNum)
						// 1) we opened file as a result of drag-drop
						change=m_DragToChange;
					else
					{
						// 2) we specified the target change during an integrate command
						//    so we need to find the change
						change= InsertChange(stats,TRUE);
					
						// Even though this isnt a drag-drop operation, cache the change info
						// into the drag-drop variables, so we dont need to do this lookup for 
						// every file that was just integrated
						m_DragToChange= change;
						m_DragToChangeNum= stats->GetOpenChangeNum();
					}
				}
				else
				{
					// Two ways to get here:  1) right click on a file in depot view, or 2) drag a
					// file from depot view to default change in this view
					change=m_MyDefault;
				}
 
				newStats= new CP4FileStats;
				newStats->Create(stats);
				if (GET_SERVERLEVEL() < 19)	// earlier than 2005.1?
					newStats->SetOtherOpens(FALSE);  // be consistent w/ data returned by ostat
				Insert(newStats->GetFormattedChangeFile(GET_P4REGPTR()->ShowFileType(), 
					GET_P4REGPTR()->ShowOpenAction()), 
					TheApp()->GetFileImageIndex(newStats, TRUE), (LPARAM) newStats, change, TRUE);
				if( GetChildItem(change) != NULL )
				{
					SetChildCount(change, 1);
					if (GET_P4REGPTR()->ExpandChgLists( ))
						Expand(change, TVE_EXPAND);
				}
			}
			//else (don't assert!  the likely reason we didnt find an open file under
            //      our changes is that the file is open by another user on my client
		} // if item found 
		break;
 
	default:
		ASSERT(0);
 
	} // switch(command)
 
	if (m_SortByExtension || m_SortByResolveStat || m_SortByAction || m_SortByFilename)
		m_Timer = ::SetTimer( m_hWnd, SORT_TIMER, 100, NULL );
	return 0;
}
 
LRESULT CDeltaTreeCtrl::OnP4SetUnresolved(WPARAM wParam, LPARAM lParam)
{
	// This message is SENDMESSAGE'd by DepotView when an open file is gotten
	// at a different revision.
 
	// Find the file
	CP4FileStats *stats= (CP4FileStats *) wParam;
 
	HTREEITEM item=FindMyOpenFile(stats->GetFullDepotPath());
		
	if(item != NULL)
	{
		// Found it, so see if unresolved
		CP4FileStats *oldStats= (CP4FileStats *) GetLParam(item);
        if(oldStats->GetHaveRev() < stats->GetHaveRev())
		    oldStats->SetUnresolved(TRUE);
		oldStats->SetHaveRev(stats->GetHaveRev());
		int img=TheApp()->GetFileImageIndex(oldStats, TRUE);
 
		// And update image and text
		SetImage(item, img, img);
		SetItemText(item, oldStats->GetFormattedChangeFile(GET_P4REGPTR()->ShowFileType(), GET_P4REGPTR()->ShowOpenAction()));
		SetCorrectChglistImage(TreeView_GetParent(m_hWnd, item));
	}
	// else
		// Not a fatal error, could just be that our instance of
		// the gui doesnt yet have this item in the changes window
		//ASSERT(0);
		
	return 0;
}
 
// Get a list of all of my open changes
LRESULT CDeltaTreeCtrl::OnGetMyChangesList(WPARAM wParam, LPARAM lParam)
{
	CStringList *list= (CStringList *) wParam;
	ASSERT_KINDOF(CStringList,list);
 
	GetMyChangesList(list);
	return 0;
}
 
 
HTREEITEM CDeltaTreeCtrl::FindChange(long changeNum)
{
	HTREEITEM item, currentItem;
 
	// Directly assign the root node
	currentItem= m_MyRoot;
		
	// Search for the second level node
	item=GetChildItem(currentItem);
	if(item != NULL)  // there is at least one child
	{
		while(GetChangeNumber(item) != changeNum)
		{
			item=GetNextSiblingItem(item);
			if(item==NULL)
				break;
		}
	}
 
	if(item != NULL)
		return item;  // node exists - return the HTREEITEM
 
	if (m_OthersRoot)
	{
		// Directly assign the root node
		currentItem= m_OthersRoot;
 
		// Search for the second level node
		item=GetChildItem(currentItem);
		if(item != NULL)  // there is at least one child
		{
			while(GetChangeNumber(item) != changeNum)
			{
				item=GetNextSiblingItem(item);
				if(item==NULL)
					break;
			}
		}
	}
	
	// return the item if found, otherwise will return NULL
	return item;  
}
 
HTREEITEM CDeltaTreeCtrl::FindFix(long changeNum, LPCTSTR jobName)
{
	HTREEITEM change= FindChange(changeNum);
	if(change == NULL)
		return NULL;
 
	HTREEITEM item= GetChildItem(change);
	CString temp;
	
	while(item != NULL)
	{
		if(!IsAFile(item))
		{
			temp= GetItemText(item);
			temp.TrimLeft();  // lose the leading space
			if(temp.Compare(jobName)==0)
				break;
		}
		item=GetNextSiblingItem(item);
	}
 
	return item;
}
 
HTREEITEM CDeltaTreeCtrl::FindMyOpenFile(LPCTSTR fileName, HTREEITEM lastfound/*=NULL*/)
{
	// Search for a filename (no rev#)
	
	int fileNameLen = lstrlen(fileName);
 
	if (lastfound)	// we have a guess as to where to start looking - check the next item
	{
		HTREEITEM subItem=GetNextSiblingItem(lastfound);
		if (subItem)
		{
			CString subItemText= GetItemText(subItem);
			int subItemTextLen= subItemText.ReverseFind(_T('#'));
 
			if( fileNameLen == subItemTextLen &&
			   !lstrcmp(fileName, GetItemText(subItem).Left(fileNameLen)) ) 
				return subItem;
		}
	}
 
	BOOL found=FALSE;
	HTREEITEM subItem = NULL;
	HTREEITEM item=GetChildItem(m_MyRoot);
	while(item !=NULL && !found)
	{
		subItem=GetChildItem(item);
		while(subItem != NULL)
		{
			// Compare the fileName with the portion of the
			// item text that precedes the revision '#'
			CString subItemText= GetItemText(subItem);
			int subItemTextLen= subItemText.ReverseFind(_T('#'));
 
			if( fileNameLen == subItemTextLen &&
				!lstrcmp(fileName, GetItemText(subItem).Left(fileNameLen)) ) 
			{
				found=TRUE;
				break;
			}
			subItem=GetNextSiblingItem(subItem);
		}
		item=GetNextSiblingItem(item);
	}
	
	if(found)
		return subItem;
	else
		return NULL;
}
 
HTREEITEM CDeltaTreeCtrl::FindItemByText(LPCTSTR text)
{
	// Search for text
	BOOL found=FALSE;
	CString testtext;
 
	HTREEITEM item=GetChildItem(m_MyRoot);
	while(item !=NULL && !found)
	{
		testtext=GetItemText(item);
		if(lstrcmp(text, testtext) == 0)
			{
				found=TRUE;
				break;
			}
		item=GetNextSiblingItem(item);
	}
	
	if(!found && m_OthersRoot)
	{
		item=GetChildItem(m_OthersRoot);
		while(item !=NULL && !found)
		{
			testtext=GetItemText(item);
			if(lstrcmp(text, testtext) == 0)
			{
				found=TRUE;
				break;
			}
			item=GetNextSiblingItem(item);
		}
	}
 
	if(found)
		return item;
	else
		return NULL;
}
 
 
// InsertChange()
// Insert the change associated with the given file.  Optionally search for that
// change and skip the insert if it is found.  Return tree node for the change.
 
HTREEITEM CDeltaTreeCtrl::InsertChange(CP4FileStats *stats, BOOL searchFirst /*=TRUE*/)
{
	HTREEITEM item, currentItem;
	int  imageIndex;
	BOOL sort = FALSE;
 
	// Directly assign the root node, based on change category
	if( stats->IsOtherUserMyClient() )	
	{
		currentItem= m_MyRoot;
		imageIndex = CP4ViewImageList::VI_YOUROTHERCHANGE;
	}
	else if(stats->IsMyOpen())
	{
		currentItem= m_MyRoot;
		imageIndex = CP4ViewImageList::VI_YOURCHANGE;
	}
	else if( m_OthersRoot )
	{
		currentItem= m_OthersRoot;
		imageIndex = CP4ViewImageList::VI_THEIRCHANGE;
	}
	else return NULL;
 
	// Format the text for the second level node
	CString changeName;
	int changeNumber;
	if((changeNumber = stats->GetOpenChangeNum())==0)
	{
		if(stats->IsMyOpen() && !stats->IsOtherUserMyClient())
			changeName.FormatMessage(IDS_CHANGE_DEFAULT);
		else if(GET_P4REGPTR()->SortChgsByUser())
			changeName.FormatMessage(IDS_CHANGE_USER_s_DEFAULT, stats->GetOtherUsers());
		else
			changeName.FormatMessage(IDS_CHANGE_DEFAULT_USER_s, stats->GetOtherUsers());
	}
	else 
	{
		if(stats->IsMyOpen() && !stats->IsOtherUserMyClient())
			changeName.FormatMessage(IDS_CHANGE_n, changeNumber);
		else
		{
			if (GET_P4REGPTR()->SortChgsByUser())
				changeName.FormatMessage(IDS_CHANGE_USER_s_n, stats->GetOtherUsers(), changeNumber);
			else
				changeName.FormatMessage(IDS_CHANGE_n_USER_s, changeNumber, stats->GetOtherUsers());
		}
	}
 
    if( searchFirst )
    {
	    // Search for the second level node
	    item=GetChildItem(currentItem);
	    if(item != NULL)  // there is at least one child
    	{
	    	while(_tcsncmp(GetItemText(item), changeName, changeName.GetLength()) != 0)
		    {
			    item=GetNextSiblingItem(item);
			    if(item==NULL)
		    		break;
		    }
	    }
 
	    if(item != NULL)
		{
			if (m_DragToChangeNum == changeNumber)
				m_DragToChange = item;
		    return item;  // node exists - return the HTREEITEM
		}
 
		sort = TRUE;  // node doesn't exists - fall thru to insert it and sort the tree
		if (changeNumber && (changeNumber==m_NewChgNbr) 
		 && !m_NewDesc.IsEmpty() && GET_P4REGPTR()->ShowChangeDesc())
		{
			CString desctxt=PadCRs(m_NewDesc);
			int trunc = (GET_SERVERLEVEL() >= 19) ? GET_P4REGPTR()->GetUseLongChglistDesc() : 31;
			CString shorttxt = TruncateString(desctxt, trunc);
			changeName.FormatMessage(shorttxt == desctxt ? IDS_CHANGE_n_s
													     : IDS_CHANGE_n_s_TRUNC, 
														changeNumber, shorttxt);
		}
    }
 
	item = Insert( changeName, imageIndex, 0, currentItem, sort);
	if (m_DragToChangeNum == changeNumber)
		m_DragToChange = item;
    return item;  // return the HTREEITEM
}
 
HTREEITEM CDeltaTreeCtrl::Insert(LPCTSTR text, int imageIndex, LPARAM lParam, 
							 HTREEITEM hParent, BOOL sort)
{
	XTRACE(_T("CDeltaTreeCtrl::Insert txt=%s\n"), text);
 
	if( lParam > 0 )
	{
		CP4FileStats *fs= (CP4FileStats *) lParam;
		if (fs->IsUnresolved())
		{
			int ix = fs->IsOtherUserMyClient() ? CP4ViewImageList::VI_YOUROTHERCHGUNRES 
											   : CP4ViewImageList::VI_YOURCHGUNRES;
			SetImage(hParent, ix, ix);
		}
	}
 
	// Add an entry to the tree
	TV_INSERTSTRUCT tree_insert;
	tree_insert.hInsertAfter= sort ? TVI_SORT : TVI_FIRST;
	tree_insert.hParent=hParent;
	tree_insert.item.mask= TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
	tree_insert.item.iImage=imageIndex;
	tree_insert.item.lParam=lParam;
	tree_insert.item.iSelectedImage=imageIndex;
	tree_insert.item.pszText=const_cast<LPTSTR>(text);
	tree_insert.item.cchTextMax=lstrlen(text);
	return(InsertItem(&tree_insert));
}
 
void CDeltaTreeCtrl::OnUpdateSortChgFilesByName(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!SERVER_BUSY());
	pCmdUI->SetCheck(GET_P4REGPTR()->SortChgFilesByName());
}
 
void CDeltaTreeCtrl::OnUpdateSortChgFilesByExt(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!SERVER_BUSY());
	pCmdUI->SetCheck(GET_P4REGPTR()->SortChgFilesByExt());
}
 
void CDeltaTreeCtrl::OnUpdateSortChgFilesByAction(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!SERVER_BUSY());
	pCmdUI->SetCheck(GET_P4REGPTR()->SortChgFilesByAction());
}
 
void CDeltaTreeCtrl::OnSortChgFilesByName() 
{
	m_SortByFilename = !GET_P4REGPTR()->SortChgFilesByName();
	GET_P4REGPTR()->SetSortChgFilesByName( m_SortByFilename );
	::SendMessage(m_depotWnd, WM_COMMAND, ID_VIEW_UPDATE_LEFT, 0);
}
 
void CDeltaTreeCtrl::OnSortChgFilesByExt() 
{
	m_SortByExtension = !GET_P4REGPTR()->SortChgFilesByExt();
	GET_P4REGPTR()->SetSortChgFilesByExt( m_SortByExtension );
	::SendMessage(m_depotWnd, WM_COMMAND, ID_VIEW_UPDATE_LEFT, 0);
}
 
void CDeltaTreeCtrl::OnSortChgFilesByAction() 
{
	m_SortByAction = !GET_P4REGPTR()->SortChgFilesByAction();
	GET_P4REGPTR()->SetSortChgFilesByAction( m_SortByAction );
	::SendMessage(m_depotWnd, WM_COMMAND, ID_VIEW_UPDATE_LEFT, 0);
}
 
void CDeltaTreeCtrl::OnUpdateSortChgFilesByResolve(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!SERVER_BUSY());
	pCmdUI->SetCheck(GET_P4REGPTR()->SortChgFilesByResolve());
}
 
void CDeltaTreeCtrl::OnSortChgFilesByResolve() 
{
	m_SortByResolveStat = !GET_P4REGPTR()->SortChgFilesByResolve();
	GET_P4REGPTR()->SetSortChgFilesByResolve( m_SortByResolveStat );
	SortTree();
}
 
void CDeltaTreeCtrl::OnUpdateSortChgsByUser(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!SERVER_BUSY() && GET_P4REGPTR()->GetEnablePendingChgsOtherClients());
	pCmdUI->SetCheck(GET_P4REGPTR()->SortChgsByUser());
}
 
void CDeltaTreeCtrl::OnSortChgsByUser() 
{
	BOOL sortChgsByUser = !GET_P4REGPTR()->SortChgsByUser();
	GET_P4REGPTR()->SetSortChgsByUser( sortChgsByUser );
	::SendMessage(m_depotWnd, WM_COMMAND, ID_VIEW_UPDATE_LEFT, 0);
}
 
LRESULT CDeltaTreeCtrl::OnP4Change(WPARAM wParam, LPARAM lParam)
{
	XTRACE(_T("OnP4Change() wParam=%ld lParam=%ld\n"), wParam, lParam);
	if( lParam )
	{
		// Just got a list of changes
		CObList *list= (CObList *) wParam;
		ASSERT_KINDOF(CObList, list);
 
		POSITION pos= list->GetHeadPosition();
 
        SetRedraw(FALSE);
		while(pos != NULL)
		{
			CP4Change *change= (CP4Change *) list->GetNext(pos);
			ASSERT_KINDOF(CP4Change, change);
	
			if(change->IsPending())
			{
				HTREEITEM item;
				if(change->IsMyChange())
				{
					// Its my client, but maybe not my user
					if( Compare( change->GetUser(), GET_P4REGPTR()->GetMyID()) == 0 )
						item=Insert(change->GetFormattedChange(GET_P4REGPTR()->ShowChangeDesc(),
																		GET_P4REGPTR()->SortChgsByUser()), 
									CP4ViewImageList::VI_YOURCHANGE, NULL, m_MyRoot, TRUE);
					else
						item=Insert(change->GetFormattedChange(GET_P4REGPTR()->ShowChangeDesc(),
																		GET_P4REGPTR()->SortChgsByUser()), 
																		CP4ViewImageList::VI_YOUROTHERCHANGE, NULL, m_MyRoot, TRUE);
				}
				else if (m_OthersRoot)
				{
					item=Insert(change->GetFormattedChange(GET_P4REGPTR()->ShowChangeDesc(),
																	GET_P4REGPTR()->SortChgsByUser()), 
									CP4ViewImageList::VI_THEIRCHANGE, NULL, m_OthersRoot, TRUE);
				}
				else item = NULL;
 
				if( change->GetChangeNumber() > 0 && item )
					SetChildCount( item, 1 );
			}
			delete change;
		}
        SetRedraw(TRUE);
		delete list;
	}
	else
	{
		CCmd_Changes *pCmd= (CCmd_Changes *) wParam;
		ASSERT_KINDOF(CCmd_Changes,pCmd);
 
		if(pCmd->GetError() || MainFrame()->IsQuitting())
		{
           	MainFrame()->ClearStatus();
			MainFrame()->SetLastUpdateTime(UPDATE_FAILED);
			pCmd->ReleaseServerLock();
		}
		else
		{
            int key= pCmd->GetServerKey( );
 
			CCmd_Ostat *pCmdOstat= new CCmd_Ostat;
			pCmdOstat->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK, key);
			
			// Only run 'p4 opened -a' if other pending changes root was expanded at
			// the time the refresh was initiated
			if( pCmdOstat->Run( m_OthersRoot && m_OthersRootExpanded ) )
			{
				MainFrame()->UpdateStatus( LoadStringResource(IDS_CHECKING_OPEN_FILES) );
				MainFrame()->SetDeltaUpdateTime(GetTickCount());
			}
			else
			{
				delete pCmdOstat;
               	MainFrame()->ClearStatus();
				pCmd->ReleaseServerLock();
				MainFrame()->SetLastUpdateTime(UPDATE_FAILED);
			}
		}
		delete pCmd;
	}
	return 0;
}
 
DROPEFFECT CDeltaTreeCtrl::OnDragEnter(COleDataObject* pDataObject, DWORD dwKeyState, CPoint point) 
{
	STGMEDIUM stg;
	m_DropEffect=DROPEFFECT_NONE;
	m_DragDataFormat=0;
	m_DragLastOver=NULL;
	m_DragLastHighlite=NULL;
	CString fname;
 
	// Dont allow a drop if the server is busy, since a drop immediately attempts to
	// invoke a server command
	if(SERVER_BUSY() || m_EditInProgress)
		return DROPEFFECT_NONE;
 
	m_DeltaIsDropTarget = TRUE;
	if(pDataObject->IsDataAvailable( (unsigned short) m_CF_DELTA))
	{
		// Set the display of the drag-from items
		m_DropEffect=DROPEFFECT_MOVE;
		m_DragDataFormat=m_CF_DELTA;
	}
	else if(pDataObject->IsDataAvailable( (unsigned short) m_CF_DEPOT))
	{
		m_DragFromChange=NULL;
		m_DropEffect=DROPEFFECT_COPY;
		m_DragDataFormat=m_CF_DEPOT;
	}
	else if(pDataObject->IsDataAvailable( (unsigned short) m_CF_JOB))
	{
		m_DragFromChange=NULL;
		m_DropEffect=DROPEFFECT_COPY;
		m_DragDataFormat=m_CF_JOB;
	}
	else if(pDataObject->GetData(CF_HDROP, &stg, NULL))
	{
		if(stg.tymed==TYMED_HGLOBAL)
		{
			// Note: df.pFiles is offset in bytes to LPCWSTR filename list, a sequence of
			//       wide char null terminated strings followed by an additional null char
			void *buf=GlobalLock(stg.hGlobal);
			_DROPFILES *df=(DROPFILES *) buf;
 
			if(df->fWide)
			{
				// NT uses wide char set for file drag-drop
				fname=(LPCWSTR) ((char *)buf+df->pFiles);  // points to first filename
			}
			else
			{
				// NT-lite uses single byte chars for file drag-drop
				fname=(LPCSTR) ((char *)buf+df->pFiles);  // points to first filename
			}
			
			// Perform a crude check on string to see if it looks like a filename 
			
			if(fname[1] == ':')
			{
				m_DropEffect=DROPEFFECT_COPY;
				m_DragDataFormat=CF_HDROP;
			}
			else if ((fname[0] == '\\') && (fname[1] == '\\'))
			{
				m_DropEffect = DROPEFFECT_NONE;	// we don't handle UNC filename yet, so ignore it
			}
			else
			{
				AddToStatus(LoadStringResource(IDS_DATA_WAS_NOT_CF_HDROP_FILES), SV_ERROR);
				AddToStatus(fname, SV_ERROR);
			}
			GlobalUnlock(buf);
		}
		else
				AddToStatus(LoadStringResource(IDS_NO_GLOBAL_CF_HDROP_DATA_RECEIVED), SV_ERROR);
 
		ReleaseStgMedium(&stg);
		m_DragFromChange=NULL;
	}
	else
		AddToStatus(LoadStringResource(IDS_UNEXPECTED_CLIPBOARD_FORMAT));
 
	m_DeltaIsDropTarget = FALSE;
	return m_DropEffect;
}
 
 
void CDeltaTreeCtrl::OnDragLeave() 
{
	m_PendingDeselect=FALSE;
	
	// Undo drop target highlite, if any
	SelectDropTarget(NULL);
}
 
DROPEFFECT CDeltaTreeCtrl::OnDragOver(COleDataObject* pDataObject, DWORD dwKeyState, CPoint point) 
{
	BOOL isDeltaWndDrag= pDataObject->IsDataAvailable( (unsigned short) m_CF_DELTA);
 
	if( isDeltaWndDrag )
	{
		// Left-drag support.  Dont clear pending deselect until the cursor
		// actually moves!
		CPoint pt= point;
		ClientToScreen( &pt );
		if( !m_DragSourceRect.PtInRect( pt ) )
			m_PendingDeselect=FALSE;
	}
 
	// If there are valid files to drop, drop effect is DROPEFFECT_COPY
	// Where is the drag?
	TV_HITTESTINFO hitTest;
	hitTest.pt=point;
	hitTest.flags=TVHT_ONITEM|TVHT_ONITEMRIGHT;
	HitTest(&hitTest);
 
	// Dont allow a drop if the server is busy, since a drop immediately attempts to
	// invoke a server command
	if(SERVER_BUSY())
	{
		m_DragLastOver=NULL;
		SelectDropTarget(NULL);
		return DROPEFFECT_NONE;
	}
 
	// Same as last time?
	if(hitTest.hItem == m_DragLastOver && hitTest.hItem != NULL )
		return m_DropEffect;
 
	// Find which item gets the drop highlite
	HTREEITEM dropItem;
	
	
	if( hitTest.hItem == m_MyRoot )
	{
		// Crack open the root to show default change if reqd
		EnsureVisible(m_MyDefault);
		dropItem=m_MyDefault;
	}
	else if( hitTest.hItem == NULL )
		dropItem=NULL;
	else
	{
		if( IsMyPendingChange(hitTest.hItem ) )
			// Its my change, so its drop-able
			dropItem=hitTest.hItem;
		else if( IsMyPendingChangeFile( hitTest.hItem ) )  
			// Its within my change - drop-able on that change
			dropItem=GetParentItem(hitTest.hItem);
		else 
			dropItem=NULL;     
	}
 
	// Finally, make sure we dont show a drop highlite if its a file being dragged
	// fromt the current change to the current change
	if(m_DragFromChange == dropItem)
		dropItem=NULL;
	
	// Update the highlited item.  If highlite item is NULL, any highlite is cleared
	if(m_DragLastHighlite != dropItem)
	{
		m_DragLastHighlite=dropItem;
		SelectDropTarget(m_DragLastHighlite);
	}
		
	return m_DropEffect;
 
}
 
 
int CDeltaTreeCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CMultiSelTreeCtrl::OnCreate(lpCreateStruct) == -1)
		return -1;
	
	SetIndent(15);
	SetScrollTime(10);
	SetImageList( TheApp()->GetImageList(), TVSIL_NORMAL );
 
	// Register that we accept file mangler files
	DragAcceptFiles(TRUE);
 
	return 0;
}
 
// Files can be added three ways:
// Method 1) Drop from MS Exploder - handled in this::OnDrop()
// Method 2) File-AddToSourceControl on menu
// Method 3) Drop from File Mangler - see this::OnDropFiles()
//
// Provide a public member to take the added files from methods 2 and 3
void CDeltaTreeCtrl::AddFileList(int changeNum, CStringList *list, BOOL bDropped/*=FALSE*/)
{
    int key=0;
	
	if(SERVER_BUSY() || m_EditInProgress || !GET_SERVER_LOCK(key))
	{
		if (m_EditInProgress)
			CantDoItRightNow(IDS_ADDEDIT_FILE);
		else
			ASSERT(0);
		return;
	}
 
	ASSERT_KINDOF(CStringList, list);
 
	ASSERT(changeNum >= 0);
   	MainFrame()->ClearStatus();
 
	CStringList demangledList;
	// Demangle the file list
	POSITION pos= list->GetHeadPosition();
	while(pos != NULL)
		demangledList.AddHead(DemanglePath(list->GetNext(pos)));
 
	m_DragToChangeNum= changeNum;
	m_DragToChange= FindChange(changeNum);
	CString changeTxt;
	if(changeNum)
		changeTxt.Format(_T("%ld"), changeNum);
    else
        changeTxt = LoadStringResource(IDS_DEFAULTCHANGELISTNAME);
 
	// Get a list of my changes
	CStringList changeList;
	GetMyChangesList(&changeList);
	
	CAddListDlg dlg;
	dlg.Init(&demangledList, &changeList, changeTxt, bDropped, key);
 
	if(dlg.DoModal() != IDCANCEL)
	{
		int action = dlg.GetAction();
		// Get a copy of the file list, since the list that the
		// dialog has will go out of scope while Cmd_Add runs
		CStringList *enumList= dlg.GetEnumeratedList();
		m_StringList.RemoveAll();
		POSITION pos= enumList->GetHeadPosition();
		while (pos != NULL)
		{
			CString filename = enumList->GetNext(pos);
			if ((action == 3) && (filename.FindOneOf(_T("@#%")) != -1))
			{
				StrBuf b;
				StrBuf f;
				f << CharFromCString(filename);
				StrPtr *p = &f;
				StrOps::WildToStr(*p, b);
				filename = CharToCString(b.Value());
			}
			m_StringList.AddHead(filename);
		}
 
		m_DragToChangeNum = dlg.GetSelectedChange();
		m_DragToChange = m_DragToChangeNum ? FindChange(m_DragToChangeNum) : m_MyDefault;
 
		if (action == 3)
		{
			// Start the delete operation
			CCmd_ListOpStat *pCmd= new CCmd_ListOpStat;
			pCmd->Init( m_depotWnd, RUN_ASYNC, HOLD_LOCK, key );
			if( pCmd->Run( &m_StringList, P4DELETE, m_DragToChangeNum ) )
				MainFrame()->UpdateStatus( LoadStringResource(IDS_REQUESTING_DELETE) );
			else
				delete pCmd;
		}
		else
		{
			// Start the add and/or edit operation(s)
			CCmd_Add *pCmd= new CCmd_Add;
			pCmd->Init(m_hWnd, RUN_ASYNC, HOLD_LOCK, key);
			pCmd->SetOpenAction(action);
			pCmd->SetHitMaxFileSeeks(m_DragToChange ? dlg.GetNeed2Refresh() : TRUE);
			if( pCmd->Run( m_DragToChangeNum, &m_StringList ) )
				MainFrame()->UpdateStatus( LoadStringResource(IDS_ADDING_FILES) );
			else
				delete pCmd;
		}
	}
	else
		RELEASE_SERVER_LOCK(key);
}
 
// File mangler file drop
void CDeltaTreeCtrl::OnDropFiles(HDROP hDropInfo) 
{
	TCHAR buf[1024];
	UINT bufsize=1024;
	UINT index=0xFFFFFFFF;
	CStringList list;
	
	// m_LastDragDropTime contains the time the last drag from this window was dropped.
	// If the current time is REALLY CLOSE (1/2 second) to the same time as when that
	// drop was done, then OnDropFiles() is being called as a result of that drop and
	// we don't have anything to do because this is NOT a drop from File Mangler,
	// so just return and don't try to add files.
	// However, if m_LastDragDropTime is not close to the current time, this is a drop
	// from an external window (probably File Mangler) and we need to add the files that
	// were dropped.
	if ((m_LastDragDropTime + 500) > GetTickCount())
		return;
 
	POINT pt;
	if(!DragQueryPoint(hDropInfo, &pt))
		return;  // got dropped outside client area
 
	// Use pt to mark where the drop was
	m_DragToPoint.x = pt.x;
	m_DragToPoint.y = pt.y;
	ClientToScreen(&m_DragToPoint);
	// Get the item from the tree
	m_DragToChange = GetDropHilightItem();
	if (m_DragToChange != NULL)
		m_DragToChangeNum = GetChangeNumber(m_DragToChange);
	else
	{
		m_DragToChangeNum = 0;
		m_DragToChange = m_MyDefault;
	}
	XTRACE(_T("OnDropFiles change=%d\n"), m_DragToChangeNum);
	
	// Get the actual file list
	UINT numFiles=DragQueryFile(hDropInfo, index, buf, bufsize);
	for(index=0; index<numFiles; index++)
	{
		DragQueryFile(hDropInfo, index, buf, bufsize);
		list.AddHead(buf);
	}
 
	// Release the memory allocated for the drag-drop operation
	DragFinish(hDropInfo);
 
	// And perform the add operation
	if(numFiles > 0)
		AddFileList(m_DragToChangeNum, &list, TRUE);
}
 
 
BOOL CDeltaTreeCtrl::OnDrop(COleDataObject* pDataObject, DROPEFFECT dropEffect, CPoint point) 
{
	STGMEDIUM stg;
	BOOL success=FALSE;
	CString fname;
	HTREEITEM item;
 
	if(SERVER_BUSY() || m_EditInProgress)
	{
		// OnDragEnter() and OnDragOver() should avoid a drop at 
		// the wrong time!
		ASSERT(0);
		return FALSE;
	}
	
	// OnDragOver has already updated current selection
	m_DragToPoint.x=point.x;
	m_DragToPoint.y=point.y;
	ClientToScreen(&m_DragToPoint);
	m_DragToChange=GetDropHilightItem();
 
	if(m_DragToChange !=NULL)
		m_DragToChangeNum=GetChangeNumber(m_DragToChange);
	else
	{
		m_DragToChangeNum=0;
		m_DragToChange=m_MyDefault;
	}
 
	XTRACE(_T("OnDrop change=%d\n"), m_DragToChangeNum);
 
	m_DeltaIsDropTarget = TRUE;
	if(m_DragDataFormat == m_CF_DELTA)
	{
		// File(s) and or job(s) being being moved from one change to here
		if(m_DragLastHighlite == NULL)
			success=TRUE;  // No work to do since dropped into originating change (but must say we did work to prevent unnecessary fstat!)
		else
		{
			// Build a list of changes and a list of jobs
			m_DroppedFileList.RemoveAll();
			m_DroppedJobList.RemoveAll();
			for(int i=GetSelectedCount()-1; i>=0; i--)
			{
				item=GetSelectedItem(i);
				if(!IsAFile(item))
					m_DroppedJobList.AddHead(GetItemText(item));
				else
				{
					fname=GetItemText(item);
					fname=fname.Left(fname.ReverseFind(_T('#')));
					m_DroppedFileList.AddHead(fname);
				}
			}
			
			PostMessage(WM_GOTMOVELISTS, 0, 0);
			success=TRUE;
		}
	}
	else if (m_DragDataFormat == m_CF_DEPOT)
	{
		// File(s) being added from depot to this window - work will be done by
		// CDepotView. But do let CDepotView know it was dropped in CDeltaTreeCtrl.
		::SendMessage(m_depotWnd, WM_DROPTARGET, PENDINGCHG, 
						MAKELPARAM(m_DragToPoint.x, m_DragToPoint.y));
		success=TRUE;
	}
	else if (m_DragDataFormat == m_CF_JOB)
	{
		m_EditChangeNum = m_DragToChangeNum;
		if (m_EditChangeNum)
		{
			CStringList jobnames;
			jobnames.AddHead(MainFrame()->GetDragFromJob());
			AddJobFixes(&jobnames, NULL);
			success=TRUE;
		}
		else
		{
			AddToStatus(LoadStringResource(IDS_CANT_ADD_JOB_TO_DEFAULT_CHG), SV_WARNING);
			success=FALSE;
		}
	}
	else if(m_DragDataFormat == CF_HDROP)
	{
		m_DroppedFileList.RemoveAll();
 
		// Its a list of files from MS Exploder
		if(pDataObject->GetData(CF_HDROP, &stg, NULL))
		{
			if(stg.tymed==TYMED_HGLOBAL)
			{
				// Notes: 
				// 1) df.pFiles is offset in bytes to LPCWSTR filename list, a sequence of
				//    wide char null terminated strings followed by an additional null char
				// 2) fortunately, CString assignment operator will eat unicode and conver to chars
				// 3) just grab the info and then release the drag operation so exploder isnt frozen
				//    a WM_GOTDROPLIST posted back to ourselves handles the list processing
						
				void *buf=GlobalLock(stg.hGlobal);
				_DROPFILES *df=(DROPFILES *) buf;
							
				MainFrame()->UpdateStatus( LoadStringResource(IDS_ENUMERATING_FILES), TRUE );
 
				// NT and Win95 will provide unicode and bytechars, respectively, for drop list
				if(df->fWide)  
				{
					LPCWSTR tPtr=(LPCWSTR) ((char *)buf+df->pFiles);  // points to first filename
					while(*tPtr != 0)  // Not at double null terminator
					{
						// Add to list, do NOT recurse directories here so gui doesnt
						// get frozen w/ large recurse operations
#ifdef UNICODE
						fname=tPtr;
                        tPtr += lstrlen(tPtr)+1;
#else
                        int bufSize = WideCharToMultiByte(CP_ACP, 0, tPtr, -1, 0, 0, 0, 0);
                        LPTSTR buf = fname.GetBufferSetLength(bufSize);
                        WideCharToMultiByte(CP_ACP, 0, tPtr, -1, buf, bufSize, 0, 0);
                        fname.ReleaseBuffer();
                        tPtr += wcslen(tPtr)+1;
#endif
						m_DroppedFileList.AddHead(fname);
					}
				}
				else
				{
					LPCSTR tPtr=(LPCSTR) ((char *)buf+df->pFiles);  // points to first filename
					while(*tPtr != 0)  // Not at double null terminator
					{
						// Add to list, do NOT recurse directories here so gui doesnt
						// get frozen w/ large recurse operations
						fname=tPtr;
						m_DroppedFileList.AddHead(fname);
						tPtr+=(fname.GetLength()+1);  // Advance a number of wide chars
					}
				}
							
				success=TRUE;
			}
			ReleaseStgMedium(&stg);
			// Post a message so we can return from this OLE nightmare
			// before processing the file list
			if(m_DroppedFileList.GetCount())
				PostMessage(WM_OLEADDFILES, 0, 0);
			else
               	MainFrame()->ClearStatus();
		}
	}
	else
		ASSERT(0);  // Dropped unknown data somehow
	
	m_DeltaIsDropTarget = FALSE;
	// Dont leave drop target selected
	SelectDropTarget(NULL);
	return success;
}
 
// A message handler to queue file enumeration work after an OLE drag-drop
// operation, allowing the OLE operation to complete before we start this
LRESULT CDeltaTreeCtrl::OnOLEAddFiles(WPARAM wParam, LPARAM lParam)
{
	AddFileList( m_DragToChangeNum, &m_DroppedFileList, TRUE);
	return 0;
}
 
LRESULT CDeltaTreeCtrl::OnGotMoveLists(WPARAM wParam, LPARAM lParam)
{
	
	if(m_DroppedJobList.GetCount() > 0)
	{
		AfxMessageBox(IDS_UNABLE_TO_DRAG_JOBS_BETWEEN_CHANGES, MB_ICONINFORMATION);
	}
	
	if(m_DroppedFileList.GetCount() > 0)
	{
		CCmd_ListOpStat *pCmd= new CCmd_ListOpStat;
		pCmd->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK );
		if (m_Need2Refresh)
			pCmd->SetHitMaxFileSeeks(TRUE);	// we will need to do a full refresh at the end
		if( pCmd->Run( &m_DroppedFileList, P4REOPEN, m_DragToChangeNum ) )
			MainFrame()->UpdateStatus( LoadStringResource(IDS_REOPENING_FILES) );
		else
			delete pCmd;
	}
	
	return 0;
}
			
BOOL CDeltaTreeCtrl::OnScroll(UINT nScrollCode, UINT nPos, BOOL bDoScroll, BOOL *bScrolled) 
{
	BYTE vScroll = HIBYTE(nScrollCode);
	
	if(m_DropEffect==DROPEFFECT_COPY || m_DropEffect==DROPEFFECT_MOVE)
	{
		if(vScroll==0) // LINEUP
		{
			*bScrolled = ScrollTree(1);
			return TRUE;
		}
		else if(vScroll==1)  //LINEDOWN
		{
			*bScrolled = ScrollTree(-1);
			return TRUE;
		}
	}
	return FALSE;
}
 
// Utility function to fill a stringlist with the names
// of all of My Changes, for use in file add and integrate dialogs
void CDeltaTreeCtrl::GetMyChangesList(CStringList *changeList)
{
	if (m_EditInProgress)
	{
		changeList->AddHead(LoadStringResource(IDS_DEFAULTCHANGELISTNAME));
		return;
	}
 
    CString changeLabel = LoadStringResource(IDS_CHANGE);
	int lgthChgLabel = changeLabel.GetLength();
	HTREEITEM item=GetChildItem(m_MyRoot);
	while(item !=NULL)
	{
		CString changeName= GetItemText(item);
		if(changeName.Find(changeLabel)!= -1)
		{
			changeName=changeName.Mid(lgthChgLabel);
			changeName.TrimLeft();
			int blank=changeName.Find(_T(' '));
			if(blank != -1)
			{
				// check for different user: "NNNN - otheruser@myclient {Description ...}"
				if ((changeName.Find(_T(" - ")) == blank) && (changeName.Find(_T('@')) != -1))
				{
					item=GetNextSiblingItem(item);	// if other user, skip it - can't use it
					continue;
				}
				changeName.Replace(_T('{'), _T(' '));
				changeName.TrimRight(_T(" }"));
			}
		}
		else if (changeName == LoadStringResource(IDS_DEFAULTCHANGELISTNAME))
		{
			changeList->AddHead(LoadStringResource(IDS_DEFAULTCHANGELISTNAME));
			changeName = LoadStringResource(IDS_NEWCHANGELISTNAME);
		}
		else // if not a numbered change and not my Default - must be another user's Default
		{
			item=GetNextSiblingItem(item);	// skip it - can't use it
			continue;
		}
		changeList->AddHead(changeName);
		item=GetNextSiblingItem(item);
	}
}
 
 
// Utility function will all of my changelists that have no files
// This will result in the + going away for empty changelists
void CDeltaTreeCtrl::ExpandEmptyChglists()
{
    CString changeLabel = LoadStringResource(IDS_CHANGE);
	HTREEITEM item=GetChildItem(m_MyRoot);
	while(item !=NULL)
	{
		CString changeName= GetItemText(item);
		if(changeName.Find(changeLabel)!= -1)
		{
			changeName=changeName.Mid(7);
			changeName.TrimLeft();
			int blank=changeName.Find(_T(' '));
			if(blank != -1)
			{
				// check for different user: "NNNN - otheruser@myclient {Description ...}"
				if ((changeName.Find(_T(" - ")) == blank) && (changeName.Find(_T('@')) != -1))
				{
					item=GetNextSiblingItem(item);	// if other user, skip it - only expand ours
					continue;
				}
			}
		}
		else	// not a numbered change
		{
			item=GetNextSiblingItem(item);
			continue;
		}
		if (!GetChildItem(item))
			ExpandTree(item);
		item=GetNextSiblingItem(item);
	}
}
 
 
long CDeltaTreeCtrl::GetChangeNumber(HTREEITEM item)
{
	ASSERT(item != NULL);
 
 	BOOL underMyRoot;
	if ((GetItemLevel(item, &underMyRoot) == 2) && IsAFile(item))
		item = GetParentItem(item);
 
	long changeNo= -1L;
	
	CString itemStr= GetItemText(item);
	if(itemStr.Find(LoadStringResource(IDS_DEFAULTCHANGELISTNAME)) == 0)
		changeNo= 0;
	else if (GET_P4REGPTR()->SortChgsByUser() 
	      && ((itemStr.Find(_T(" -  Default")) + (int)(sizeof(_T(" -  Default"))/sizeof(TCHAR) - 1)) == itemStr.GetLength()))
		changeNo= 0;
	else
	{
		int i;
		CString ChgLit = LoadStringResource(IDS_CHANGE_n);
		i = ChgLit.Find(_T('%'));
		ASSERT(i != -1);
		ChgLit = ChgLit.Left(i);
		ChgLit.TrimRight();
		i = itemStr.Find(ChgLit);
		i += (i == -1) ? 1 : ChgLit.GetLength();
		for(; i< itemStr.GetLength(); i++)
		{
			if(_istdigit(itemStr[i]))
				 break;
		}
		if(i<itemStr.GetLength())
		{	
			itemStr=itemStr.Mid(i);
			changeNo=_ttol(itemStr);
		}
	}
	// Shouldnt be calling this function unless user was on a change!
	ASSERT(changeNo >= 0);
	return changeNo;
}
 
long CDeltaTreeCtrl::GetSelectedChangeNumber()
{
	HTREEITEM item=GetLastSelection();
	return GetChangeNumber(item);
}
 
void CDeltaTreeCtrl::OnChangeDel() 
{
	HTREEITEM item=GetLastSelection();  
			
	if (item == NULL)
		{ ASSERT(0); return; }
 
	long changeNo=GetSelectedChangeNumber();
 
	if(changeNo == 0)
	{
		AfxMessageBox(IDS_DEFAULT_CHANGELIST_MAY_NOT_BE_DELETED, MB_ICONEXCLAMATION);
		return;
	}
	
	CString txt;
	txt.FormatMessage(IDS_ARE_YOU_SURE_YOU_WANT_TO_DELETE_CHANGELIST_n, changeNo);
	if(AfxMessageBox(txt, MB_ICONQUESTION|MB_YESNO) != IDYES)
		return;
 
	CCmd_Delete *pCmd= new CCmd_Delete;
	txt.Format(_T("%ld"), changeNo);
	pCmd->Init( m_hWnd, RUN_ASYNC);
	if( pCmd->Run( P4CHANGE_DEL, txt ) )
	{
		m_ActiveItem=item;
		txt.FormatMessage(IDS_DELETING_n, changeNo);
		MainFrame()->UpdateStatus(txt);
	}	
	else
		delete pCmd;
}
 
 
void CDeltaTreeCtrl::OnChangeDescribe() 
{
	HTREEITEM item=GetLastSelection();  
			
	if (item == NULL)
		{ ASSERT(0); return; }
 
	m_EditChange= item;
	long changeNumber= GetSelectedChangeNumber();
	
	if(changeNumber > 0)
	{
		CString changeTxt;
		changeTxt.Format(_T("%ld"), changeNumber);
 
		CCmd_Describe *pCmd= new CCmd_Describe;
		pCmd->Init( m_hWnd, RUN_ASYNC);
		if( pCmd->Run( P4DESCRIBE, changeTxt) )
			MainFrame()->UpdateStatus( LoadStringResource(IDS_FETCHING_CHANGELIST_DESCRIPTION) );
		else
			delete pCmd;
	}
}
 
LRESULT CDeltaTreeCtrl::OnP4Describe(WPARAM wParam, LPARAM lParam)
{
	CCmd_Describe *pCmd= (CCmd_Describe *) wParam;
 
	if(pCmd->GetSpecType() != P4JOB_SPEC)
		return OnP4ChangeDescribe( wParam, lParam);
	else
		return OnP4JobDescribe( wParam, lParam);
}
 
LRESULT CDeltaTreeCtrl::OnP4EndDescribe(WPARAM wParam, LPARAM lParam)
{
	CSpecDescDlg *dlg = (CSpecDescDlg *)lParam;
 
	if(dlg->GetViewType() != P4JOB_SPEC)
		return OnP4EndChgDescribe( wParam, lParam);
	else
		return OnP4EndJobDescribe( wParam, lParam);
}
 
LRESULT CDeltaTreeCtrl::OnP4ChangeDescribe(WPARAM wParam, LPARAM lParam)
{
	CCmd_Describe *pCmd= (CCmd_Describe *) wParam;
 
	if(!pCmd->GetError())
	{
		// Get the descriptive text
		CString desc= MakeCRs(pCmd->GetDescription());
		
		// If we are talking to a pre 2002.2 server,
		// Then add the section about affected files
		if (GET_SERVERLEVEL() < 14)
		{
			HTREEITEM child= GetChildItem(m_EditChange);
			if( child != NULL && IsAFile(child) )
			{
				desc += LoadStringResource(IDS_AFFECTEDFILES);
			}
 
			CString fileText;
			while( child != NULL )
			{
				if( IsAFile( child ) )
				{
					CP4FileStats *fs= (CP4FileStats *) GetLParam(child);
					if( fs->IsMyOpen() )
						fileText.Format(_T("\r\n%s#%d %s"), fs->GetFullDepotPath(),
													fs->GetHaveRev(),
													fs->GetActionStr( fs->GetMyOpenAction() ) );
					else
						fileText.Format(_T("\r\n%s#%d %s"), fs->GetFullDepotPath(),
													fs->GetHaveRev(),
													fs->GetActionStr( fs->GetOtherOpenAction() ) );
 
					// do reallocs in large chunks, rather than letting CString::operator +=() do it
					// in little bits.  This makes a huge speed difference if the number if items is large.
					if(desc.GetLength() + fileText.GetLength() + 1 > desc.GetAllocLength())
					{
						// grow the buffer 16k at a time, adjusting the first time to get an even 4k multiple
						int newSize = desc.GetAllocLength() + 16384;
						newSize -= newSize % 16384;
						desc.GetBuffer(newSize);
						desc.ReleaseBuffer();
					}
 
					desc+= fileText;
				}
				child= GetNextSiblingItem(child);
			}
		}
 
		int key;
		CSpecDescDlg *dlg = new CSpecDescDlg(this);
		dlg->SetIsModeless(TRUE);
		dlg->SetKey(key = pCmd->HaveServerLock()? pCmd->GetServerKey() : 0);
		dlg->SetItemName(pCmd->GetReference());
		dlg->SetDescription(desc);
		dlg->SetCaption(LoadStringResource(IDS_PERFORCE_CHANGELIST_DESCRIPTION));
		dlg->SetShowEditBtn(!key && IsMyPendingChange(m_EditChange));
		dlg->SetViewType(P4CHANGE_SPEC);
		if (!dlg->Create(IDD_SPECDESC, this))	// display the description dialog box
		{
			dlg->DestroyWindow();	// some error! clean up
			delete dlg;
		}
	}
 
	delete pCmd;
   	MainFrame()->ClearStatus();
	return 0;
}
 
LRESULT CDeltaTreeCtrl::OnP4EndChgDescribe( WPARAM wParam, LPARAM lParam )
{
	CSpecDescDlg *dlg = (CSpecDescDlg *)lParam;
 
	if (wParam == IDC_EDITIT)	// which button did they click to close the box?
	{
		CString ref = dlg->GetItemName();
		ASSERT(!ref.IsEmpty());
 
		int i;
		BOOL found = FALSE;
		long chgnbr = _ttol(ref);
 
		// find the HTREEITEM - user might have chged the selection
		HTREEITEM item=GetChildItem(m_MyRoot);
		while(item !=NULL && !found)
		{
			CString testtext=GetItemText(item);
			if ((i = testtext.Find(' ')) != -1)
			{
				testtext = testtext.Mid(i);
				testtext.TrimLeft();
				if ((i = testtext.Find(' ')) != -1)
					testtext = testtext.Left(i);
			}
			if(lstrcmp(ref, testtext) == 0)
			{
				found=TRUE;
				break;
			}
			item=GetNextSiblingItem(item);
		}
		if (found)
		{
			m_ChangeIsSelected=TRUE;
			m_EnableChangeSubmit=FALSE;
			m_SubmitOnlyChged=m_SubmitOnlySeled=FALSE;
			ChangeEdit(chgnbr, item);
		}
		else
		{
			CString txt;
			txt.FormatMessage(IDS_SE_ERR_FNF, ref);
			AddToStatus(txt, SV_WARNING);
		}
	}
	dlg->DestroyWindow();
	return TRUE;
}
 
// Following handlers for change spec editing and submitting
void CDeltaTreeCtrl::OnChangeSubmit() 
{
	m_ChangeIsSelected=TRUE;
	m_EnableChangeSubmit=TRUE;
	m_SubmitOnlyChged=GET_P4REGPTR()->GetSubmitOnlyChged();
	m_SubmitOnlySeled=IsSelectionInSubmittableChange();
	ChangeEdit();
}
 
void CDeltaTreeCtrl::OnChangeEdspec() 
{
	m_ChangeIsSelected=TRUE;
	m_EnableChangeSubmit=FALSE;
	m_SubmitOnlyChged=m_SubmitOnlySeled=FALSE;
	ChangeEdit();
}
 
void CDeltaTreeCtrl::OnChangeNew()
{
	m_ChangeIsSelected=FALSE;
	m_EnableChangeSubmit=FALSE;
	m_SubmitOnlyChged=m_SubmitOnlySeled=FALSE;
	ChangeEdit();
}
 
void CDeltaTreeCtrl::CallOnChangeNew()
{
	OnChangeNew();
}
 
void CDeltaTreeCtrl::ChangeEdit(long chgnum /*= -1*/, HTREEITEM chgItem /*= 0*/)
{
	if (m_EditInProgress)
	{
		CantDoItRightNow(IDS_EDITSTRING);
		return;
	}
 
	HTREEITEM item;
 
	// Get the relevant change number and the list of files under the change
	if (chgnum != -1)
	{
		m_EditChangeNum = chgnum;
		m_EditChange = chgItem;
	}
	else if(m_ChangeIsSelected)
	{
		item=GetLastSelection();  
		if(!IsMyPendingChange(item))
			item=GetParentItem(item);
 
		if (item == NULL)
			{ ASSERT(0); return; }
 
		m_EditChangeNum=GetChangeNumber(item);
 
		if(m_EditChangeNum < 0L)
			{ ASSERT(0); return; }
 
		m_EditChange=item;
	}
	else
	{
		m_EditChangeNum=0;
		m_EditChange=m_MyDefault;
	}
 
    // Empty lists
	m_FileList.RemoveAll();
	m_SelectionList.RemoveAll();
	m_FileListDefinitive = FALSE;
	
	// If they want to only set the check on changed files,
	// we must get a list of edited files into m_FileList.
	// Also if they are submitting a selection of files from the chglist
	// we must get a list of the selected files into m_SelectionList
	if (m_EnableChangeSubmit 
	 && (m_SubmitOnlyChged || m_SubmitOnlySeled || GET_SERVERLEVEL() >= 21))
	{
		CString fileName;
		int files=0;
 
		BOOL b20051 = FALSE;
		CP4Command *pcmd = 0;
		CGuiClient *client = 0;
		if (GET_SERVERLEVEL() >= 19)		// 2005.1 or later?
		{
			Error e;
			pcmd = new CP4Command;
			client = pcmd->GetClient();
			client->SetTrans();
			client->Init(&e);
			if( !e.Test() )
				b20051 = TRUE;
			else
				delete pcmd;
		}
 
		item=GetChildItem(m_EditChange);
		while(item!=NULL)
		{
			if(IsAFile(item))
			{
				fileName=GetItemText(item);
				if ((m_SubmitOnlyChged || GET_SERVERLEVEL() >= 21)	//always build list for 6.1+
				 && (!m_SubmitOnlySeled || IsSelected(item)))
				{
					if (fileName.Find(_T("<edit>")) != -1)
					{
						if (b20051)	// working with good 2005.1 or later server?
						{
							LPARAM lParam=GetLParam(item);
							CP4FileStats *stats = (CP4FileStats *) lParam;
							if (TheApp()->digestIsSame(stats, FALSE, client)
							 && stats->GetType() == stats->GetHeadType())
								m_FileList.AddTail(stats->GetFullDepotPath());
						}
						else
						{
							m_FileList.AddTail(fileName.Left(fileName.ReverseFind(_T('#'))));
							++files;
						}
					}
					if ((files > 32000) && !m_SubmitOnlySeled)
						break;
				}
				if (m_SubmitOnlySeled && IsSelected(item))
					m_SelectionList.AddTail(fileName.Left(fileName.ReverseFind(_T('#'))));
			}
			item=GetNextSiblingItem(item);
		}
		if (b20051)
		{
			delete pcmd;
			m_FileListDefinitive = TRUE;
			RunChangeEdit(0);
			return;
		}
		if (m_FileList.GetCount())
		{
		  if (GET_SERVERLEVEL() >= 14)	// 2002.2 or later?
		  {
			if (files <= 32000)
			{
				CCmd_Revert *pCmd= new CCmd_Revert;
				pCmd->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK);
				pCmd->SetAlternateReplyMsg( WM_P4DIFFCHANGEEDIT );
				CString chgnbr;
				if (m_EditChangeNum)
					chgnbr.Format(_T("%ld"), m_EditChangeNum);
				else
					chgnbr = _T("default");
				if( pCmd->Run( chgnbr, TRUE, TRUE, TRUE ) )
				{
					MainFrame()->UpdateStatus(LoadStringResource(IDS_RUNNING_DIFF));
					return;
				}
				else
					delete pCmd;
			}
			else
			{
				CString msg;
				msg.FormatMessage(IDS_TOOMANYFILE4SUBMITONLYCHGED, files);
				if (IDNO == AfxMessageBox(msg, MB_YESNO | MB_ICONEXCLAMATION))
					return;
			}
		  }
		}
	}
	RunChangeEdit(0);
}
 
LRESULT CDeltaTreeCtrl::OnP4DiffChangeEdit(WPARAM wParam, LPARAM lParam)
{
	CCmd_Revert *pCmd= (CCmd_Revert *) wParam;
    
	if(!pCmd->GetError())
	{
		m_FileList.RemoveAll();
		CStringList *list= pCmd->GetFileList();
		POSITION pos;
	
		if(!list->IsEmpty())  // Some filenames in the list
		{
			int i;
			for(pos=list->GetHeadPosition(); pos!=NULL;)
			{
				CString str = list->GetNext(pos);
				if (str.Find(_T(", not reverted")) != -1)
					continue;
				if ((i = str.Find(_T('#'))) != -1)
					str = str.Left(i);
				m_FileList.AddHead(str);
			}
        }
		m_FileListDefinitive = TRUE;
	}
	int key= pCmd->GetServerKey();
	delete pCmd;
	RunChangeEdit(key);
	return 0;
}
 
void CDeltaTreeCtrl::RunChangeEdit(int key)
{
	// At this point, context has been saved in m_EditChangeNum, m_EnableChangeSubmit,
	// and m_FileList members. So start the spec edit process.  The dialog
    // is invoked by CCmd_EditSpec
 
	MainFrame()->UpdateStatus( LoadStringResource(IDS_RETRIEVING_CHANGELIST_SPEC) );
	CCmd_EditSpec *pCmd= new CCmd_EditSpec;
    pCmd->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK, key );
    if( pCmd->Run( m_EditChangeNum, m_EnableChangeSubmit, FALSE, m_SubmitOnlyChged, 
																 m_SubmitOnlySeled) )
		MainFrame()->UpdateStatus( LoadStringResource(IDS_EDITING_CHANGELIST_SPEC) );	
	else
		delete pCmd;
}
 
BOOL CDeltaTreeCtrl::IsAMemeberOfFileList(CString &fileName)
{
	for (POSITION pos= m_FileList.GetHeadPosition(); pos!=NULL; )
		if (m_FileList.GetNext( pos ) == fileName)
			return TRUE;
	return FALSE;
}
 
BOOL CDeltaTreeCtrl::IsAMemeberOfSelectionList(CString &fileName)
{
	for (POSITION pos= m_SelectionList.GetHeadPosition(); pos!=NULL; )
		if (m_SelectionList.GetNext( pos ) == fileName)
			return TRUE;
	return FALSE;
}
 
 
// TODO:  allow this function to be called for selected file level in addition to
//        change level
void CDeltaTreeCtrl::OnChangeRevorig() 
{
    if( SERVER_BUSY() )
    {
        ASSERT(0);
        return;
    }
 
	HTREEITEM currItem=GetLastSelection();  
	
	// no selected item - menu enables should have prevented
	if (currItem == NULL)
		{ ASSERT(0); return; }
 
	// selected item not one of my changes - fix menu enables should have prevented
	if(GetParentItem(currItem) != m_MyRoot)
		{ ASSERT(0); return; }
 
	// Empty list
	m_StringList.RemoveAll();
	
	SET_BUSYCURSOR();
	MainFrame()->UpdateStatus(LoadStringResource(IDS_DIFFFILES));
 
	int files=0;
 
	HTREEITEM item=GetChildItem(currItem);
	while(item!=NULL)
	{
		if(IsAFile(item))
		{
			if(++files > 32000)
			{	
				AfxMessageBox(IDS_UNABLE_TO_DIFF_MORE_THAN_32000_FILES, MB_ICONEXCLAMATION);
				return;
			}
			if (GET_SERVERLEVEL() < 14)	// pre 2002.2?
			{
				CString fileName=GetItemText(item);
				fileName=fileName.Left(fileName.ReverseFind(_T('#')));  // Strip revision number
				m_StringList.AddTail(fileName);
			}
		}
		item=GetNextSiblingItem(item);
	}
 
	if (GET_SERVERLEVEL() >= 14)	// 2002.2 or later?  If so we can use p4 revert -an
	{
		CCmd_Revert *pCmd= new CCmd_Revert;
		pCmd->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK);
		CString chgnbr;
		m_EditChangeNum=GetChangeNumber(currItem);
		if (m_EditChangeNum)
			chgnbr.Format(_T("%ld"), m_EditChangeNum);
		else
			chgnbr = _T("default");
		if( pCmd->Run( chgnbr, TRUE, TRUE, TRUE ) )
			m_DoRevert=TRUE;
		else
		{
			MainFrame()->ClearStatus();
			delete pCmd;
		}
		return;
	}
 
	CCmd_Diff *pCmd= new CCmd_Diff;
	pCmd->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK);
	if( pCmd->Run( &m_StringList, _T("-sr") ) )
	{
		if(files > 5)
			MainFrame()->UpdateStatus(LoadStringResource(IDS_RUNNING_MASSIVE_DIFF));
		else
			MainFrame()->UpdateStatus(LoadStringResource(IDS_RUNNING_DIFF));
 
		m_DoRevert=TRUE;
	}
	else
		delete pCmd;
}
 
void CDeltaTreeCtrl::OnFileDiff() 
{
	// should always have something selected
	if(GetSelectedCount()==0)
	{
		ASSERT(0);
		return;
	}
 
	// see if it's a chglist or file(s) that's selected
	HTREEITEM initialItem = GetSelectedItem(0);
	BOOL root;
	int level = GetItemLevel(initialItem, &root);
	if (level == 1)
	{
		// a chglist is selected, so select its files
		if (GET_SERVERLEVEL() >= 19)	// 2005.1 or later? Then select only chged files
		{
			int tot;
			if (SelectChgUnchg(TRUE, &tot))		// any file(s) get selected?
			{
				int i = tot - GetSelectedCount();	// compute nbr not selected (i.e. unchged)
				if (i)								// any unchanged? if so, tell user
				{
					CString txt;
					if(i == 1)
						txt.FormatMessage(IDS_ONECLIENTFILEDOESNOTDIFFER);
					else
						txt.FormatMessage(IDS_SEVERALCLIENTFILESDONOTDIFFER_n, i);
					AddToStatus(txt, SV_MSG);
				}
			}
			else	// all unchanged; tell user and return
			{
				AddToStatus(LoadStringResource(IDS_NONE_OF_THE_SELECTED_CLIENT_FILES_DIFFER), SV_COMPLETION);
				return;
			}
		}
		else
			SelectAllFilesInChange(initialItem, 0);	// older server: Sellect all the chglist files
		if (GetSelectedCount() < 1)
		{
			UnselectAll();
			SetSelectState(initialItem, TRUE);
			return;
		}
	}
 
	// get a stringlist of files and deal with any adds
	BOOL bFoundAdd = AssembleStringList( NULL, FALSE );
	if (bFoundAdd)
	{
		if ((level != 1) || m_StringList.IsEmpty())
			AddToStatus(LoadStringResource(IDS_CANTDIFFADDEDFILES), SV_WARNING);
		if (m_StringList.IsEmpty())
			return;
	}
 
	// see if we are diffing "a whole buncha files"
	if (m_StringList.GetCount() > _ttoi(GET_P4REGPTR()->GetWarnLimitDiff()))
	{
		CString txt;
		txt.FormatMessage(IDS_DIFF_WARNLIMIT_EXCEEDED_d, m_StringList.GetCount());
		if (IDYES != AfxMessageBox(txt, MB_YESNO))
			return;
	}
 
	// If the server is busy because we triggered an expand of a changelist
	// and are getting the attached jobs, wait for the server to finish
	if (level == 1)
	{
		UnselectAll();
		SetSelectState(initialItem, TRUE);	// reselect original chglist
		if (SERVER_BUSY())
		{
			int t=GET_P4REGPTR()->BusyWaitTime();
			do
			{
				Sleep(50);
				t -= 50;
			} while (SERVER_BUSY() && t > 0);
		}
	}
 
	// finally run the diff command against the selected file(s)
	m_DoRevert=FALSE;
	CCmd_Diff *pCmd= new CCmd_Diff;
	pCmd->Init( m_hWnd, RUN_ASYNC);
	if( pCmd->Run( &m_StringList ) )
		MainFrame()->UpdateStatus( LoadStringResource(IDS_DIFFING_FILE) );
	else
		delete pCmd;
}
 
void CDeltaTreeCtrl::OnFiletype() 
{
	HTREEITEM item=GetLastSelection();  
	
	if (item == NULL)
		ASSERT(0);
	else if (!IsAFile(item))
		AfxMessageBox(IDS_CANTCHGFILETYPE4JOB);
	else
	{
		CFileType dlg;
		CP4FileStats *stats;
		stats= (CP4FileStats *) GetLParam(item);
		dlg.m_itemStr = stats->GetFormattedChangeFile(TRUE, TRUE);
		int i=GetSelectedCount();
		if (i > 1)
		{
			CString str = GetItemText(item);
			str = str.Mid(str.ReverseFind(_T('#')));
			str = str.Mid(str.Find(_T("<")));
			str = str.Left(str.Find(_T(">")));
			while(--i >= 0)
			{
				item=GetSelectedItem(i);
				if(!IsAFile(item))
					continue;
				CString fname=GetItemText(item);
				CString type =fname.Mid(fname.ReverseFind(_T('#')));
				type = type.Mid(type.Find(_T("<")));
				type = type.Left(type.Find(_T(">")));
				if (type != str)
				{
					dlg.m_Action = 1;
					break;
				}
			}
		}
		if (dlg.DoModal() == IDOK)
			ReopenAs(dlg.m_fileType);
	}
}
 
void CDeltaTreeCtrl::OnMoveFiles() 
{
	HTREEITEM item=GetLastSelection();  
	
	if (item == NULL)
		ASSERT(0);
	else
	{
		CMoveFiles dlg;
		// Get a list of my changes
		CStringList list;
		GetMyChangesList(&list);
		// Get current change item and save in m_DragFromChange
		HTREEITEM currentItem=GetLastSelection();
		m_DragFromChange=GetParentItem(currentItem);
		// Get current change number and convert to string
		long changeNo=GetChangeNumber(m_DragFromChange);
		CString curChg;
		if (!changeNo)
			curChg = LoadStringResource(IDS_CHANGE_DEFAULT);
		else
			curChg.Format(_T("%ld"), changeNo);
		// Remove current change number from list
		// as the list is copied to the dlg
		POSITION pos;
		for( pos = list.GetHeadPosition(); pos != NULL; )
		{
			int i;
			CString changeStr = dlg.m_ChangeList.GetNext( pos );
			CString chg = ((i = changeStr.Find(_T(' '), 2)) != -1) 
						? changeStr.Left(i) : changeStr;
			if (chg != curChg)
				dlg.m_ChangeList.AddHead(changeStr);
		}
 
		// display the dialog
		if (dlg.DoModal() == IDOK)
		{
			// Save the change number to move to
			m_DragToChangeNum=dlg.m_SelectedChange;
			m_DragToChange = m_DragToChangeNum ? FindChange(m_DragToChangeNum) : m_MyDefault;
			m_Need2Refresh = m_DragToChange ? dlg.m_Need2Refresh : TRUE;
 
			// Build a list of files and a list of jobs
			m_DroppedFileList.RemoveAll();
			m_DroppedJobList.RemoveAll();
			for(int i=GetSelectedCount()-1; i>=0; i--)
			{
				item=GetSelectedItem(i);
				if(!IsAFile(item))
					m_DroppedJobList.AddHead(GetItemText(item));
				else
				{
					CString fname=GetItemText(item);
					fname=fname.Left(fname.ReverseFind(_T('#')));
					m_DroppedFileList.AddHead(fname);
				}
			}
			// And finally do the actual move
			OnGotMoveLists(0, 0);
		}
	}
}
 
 
/*
	_________________________________________________________________
*/
 
void CDeltaTreeCtrl::OnFileLock() 
{
	LockOrUnlock( P4LOCK );
}
 
void CDeltaTreeCtrl::OnFileUnlock() 
{
	LockOrUnlock( P4UNLOCK );
}
 
void CDeltaTreeCtrl::LockOrUnlock( int which ) 
{
	if(GetSelectedCount()==0)
	{
		ASSERT(0);
		return;
	}
 
	AssembleStringList( );
 
	// Run the command for the depot window
	CCmd_ListOpStat *pCmd= new CCmd_ListOpStat;
	pCmd->Init( m_depotWnd, RUN_ASYNC, HOLD_LOCK );
	if( pCmd->Run( &m_StringList, which ) )
        MainFrame()->UpdateStatus( LoadStringResource(which == P4LOCK ? 
            IDS_REQUESTINGLOCK : IDS_REQUESTINGUNLOCK));
	else
		delete pCmd;
}
 
 
/*
	_________________________________________________________________
*/
 
void CDeltaTreeCtrl::OnUpdateFileSchedule(CCmdUI* pCmdUI) 
{
	BOOL root;
	BOOL rc = FALSE;
	if (!SERVER_BUSY() && GetSelectedCount() > 0)
	{
		int level = GetItemLevel(GetSelectedItem(0), &root);
		if (level == 2)
			rc = (IsMyPendingChangeFile( GetSelectedItem(0) ) && IsAFile( GetSelectedItem(0)) );
		else if (level == 1)
			rc = (IsMyPendingChange(GetSelectedItem(0)) 
					&& HasChildren(GetSelectedItem(0)) 
					&& GetSelectedCount()==1);
	}
	pCmdUI->Enable(rc);
}
 
void CDeltaTreeCtrl::OnFileGetWhatIf() 
{
	FileGet(TRUE);
}
 
void CDeltaTreeCtrl::OnFileGet()
{
	FileGet(FALSE);
}
 
void CDeltaTreeCtrl::FileGet(BOOL whatIf)
{
	BOOL root;
	if(GetSelectedCount()==0)
	{
		ASSERT(0);
		return;
	}
 
	if (GetItemLevel(GetSelectedItem(0), &root) == 2)
		AssembleStringList( );
	else
	{
		int files = 0;
		CString fileName;
		m_StringList.RemoveAll();
		HTREEITEM item=GetChildItem(GetSelectedItem(0));
		while(item!=NULL)
		{
			if(IsAFile(item))
			{
				fileName=GetItemText(item);
				fileName=fileName.Left(fileName.ReverseFind(_T('#')));  // Strip revision number
				m_StringList.AddTail(fileName);
				if(files++ > 32000)
				{	
					AfxMessageBox(IDS_UNABLE_TO_RESOLVE_MORE_THAN_32000_FILES, MB_ICONEXCLAMATION);
					return;
				}
			}
			item=GetNextSiblingItem(item);
		}
	}
 
	CCmd_Get *pCmd= new CCmd_Get;
	pCmd->Init( m_depotWnd, RUN_ASYNC);
	if( pCmd->Run( &m_StringList, whatIf ) )
		MainFrame()->UpdateStatus( LoadStringResource(IDS_FILE_SYNC) );
	else
		delete pCmd;
}
 
void CDeltaTreeCtrl::OnFileRevisionhistory() 
{
	HTREEITEM currentItem=GetLastSelection();  
	if( IsAFile(currentItem) && !SERVER_BUSY() )
	{
		CString fname= GetItemText( currentItem );
	
		int pound= fname.Find(_T('#'));
		if( pound != -1 )
			fname= fname.Left( pound );
 
				
		CCmd_History *pCmd= new CCmd_History;
		pCmd->Init( m_depotWnd, RUN_ASYNC);
		pCmd->SetCallingWnd(m_hWnd);
		if( pCmd->Run(fname) )
		{
			MainFrame()->UpdateStatus( LoadStringResource(IDS_REQUESTING_HISTORY) );
		}
		else
			delete pCmd;
	}
}
 
void CDeltaTreeCtrl::OnFileRevisionTree() 
{
	HTREEITEM currentItem=GetLastSelection();  
	if( IsAFile(currentItem) && !SERVER_BUSY() )
	{
		int i, j;
		CString path = GetItemText( currentItem );
		if ((i = path.Find(_T('#'))) != -1)
		{
			if ((j = path.Find(_T(' '), i)) != -1)
				path = path.Left(j);
			if (path[i+1] == _T('0'))
				path = path.Left(i);
		}
		TheApp()->CallP4RevisionTree( path );
	}
}
 
void CDeltaTreeCtrl::OnFileTimeLapseView() 
{
	HTREEITEM currentItem=GetLastSelection();  
	if( IsAFile(currentItem) && !SERVER_BUSY() && MainFrame()->HaveTLV() )
	{
		int i;
		CString path = GetItemText( currentItem );
		if (((i = path.Find(_T('#'))) != -1) && ((i = path.Find(_T(' '), i)) != -1))
			path = path.Left(i);
		TheApp()->CallP4A( path, _T(""), 0 );
	}
}
 
void CDeltaTreeCtrl::OnFileAnnotate() 
{
	FileAnnotate(FALSE);
}
 
void CDeltaTreeCtrl::OnFileAnnotateAll() 
{
	FileAnnotate(TRUE);
}
 
void CDeltaTreeCtrl::OnFileAnnotateChg() 
{
	FileAnnotate(FALSE, TRUE);
}
 
void CDeltaTreeCtrl::OnFileAnnotateChgAll() 
{
	FileAnnotate(TRUE, TRUE);
}
 
void CDeltaTreeCtrl::FileAnnotate(BOOL bAll, BOOL bChg/*=FALSE*/) 
{
	HTREEITEM currentItem=GetLastSelection();
	
	if (currentItem == NULL || !IsAFile(currentItem))
		ASSERT(0);
	else
	{
		CP4FileStats *fs= (CP4FileStats *) GetLParam(currentItem);
		CString itemStr= fs->GetFullDepotPath();
		
		CCmd_PrepBrowse *pCmd= new CCmd_PrepBrowse;
		pCmd->Init( m_depotWnd, RUN_ASYNC);
		pCmd->SetFileType(fs->IsTextFile() ? FST_TEXT : FST_BINARY);
		CString fType = fs->GetHeadType();
		::SendMessage(m_depotWnd, WM_SETVIEWER, 0, (LPARAM)GET_P4REGPTR()->GetEditApp());
		if( pCmd->Run( FALSE, itemStr, fType, bAll, bChg, FALSE, fs->GetHaveRev(),
			GET_P4REGPTR()->GetAnnotateWhtSpace(),
			bChg ? GET_P4REGPTR()->GetAnnotateIncInteg() : FALSE) )
		{
			MainFrame()->UpdateStatus( LoadStringResource(IDS_FETCHING_FILE) );
		}
		else
			delete pCmd;
	}
}
 
 
//	If user right clicks on a file and chooses 'Explore', run Windows Explorer
//	in the directory where that file resides on the client machine.
//	We can only do this for a specific file - not for multiple selected files
//	since they may map to different directories.
 
void CDeltaTreeCtrl::OnWinExplore() 
{
    BOOL root;
 
    if (GetSelectedCount() && 
		GetItemLevel(GetSelectedItem(0), &root)== 2 && 
        IsMyPendingChangeFile(GetSelectedItem(0)) )
    {
        HTREEITEM item = NULL;
		if (m_ContextPoint.x != -1 && m_ContextPoint.y != -1)
		{
			// find out what item was clicked to generate the last context menu
			TV_HITTESTINFO ht;
			ht.pt=m_ContextPoint;
			ScreenToClient(&ht.pt);
			ht.flags=TVHT_ONITEMLABEL | TVHT_ONITEMICON | TVHT_ONITEMBUTTON;
			item=HitTest( &ht );
		}
		if (!item || !IsSelected(item) || !IsAFile(item))
		{
			item = GetSelectedItem(0);
			if (!IsAFile(item))
				return;
		}
 
		CString clientPath;
        if(GetClientPath(item, clientPath))
        {
            int	i;
			CString switches;
 
			clientPath.Replace('/', '\\');
			if (GET_P4REGPTR()->GetExplorer()				// not using Win Explorer
			 || (::GetFileAttributes(clientPath) == -1))	// file not found
			{
				switches = _T("");
				if ((i = clientPath.ReverseFind('\\')) != -1)
					clientPath = clientPath.Left(i);
			}
			else
			{
				switches = _T("/select,");
			}
 
			if (clientPath.FindOneOf(_T(" &()[]{}^=;!'+,`~")) != -1)
			{
				clientPath.TrimLeft();
				clientPath.TrimRight();
				clientPath = _T('\"') + clientPath + _T('\"');
			}
 
            STARTUPINFO si;
            memset(&si, 0, sizeof(si));
            si.cb = sizeof(si);
            PROCESS_INFORMATION pi;
            CreateProcess(NULL, const_cast<LPTSTR>((LPCTSTR)(TheApp()->GetExplorer() 
													+ switches + clientPath)), 
                NULL, NULL, 
#ifdef UNICODE
                FALSE, DETACHED_PROCESS | NORMAL_PRIORITY_CLASS | CREATE_UNICODE_ENVIRONMENT, 
#else
                FALSE, DETACHED_PROCESS | NORMAL_PRIORITY_CLASS, 
#endif
                MainFrame()->P4GetEnvironmentStrings(),
				NULL, &si, &pi);
        }
    }
}
 
//	If user right clicks on a file and chooses 'Command Prompt', run a Command Prompt
//	in the directory where that file resides on the client machine.
//	We can only do this for a specific file - not for multiple selected files
//	since they may map to different directories; otherwise run MainFrame's OnCmdPrompt()
 
void CDeltaTreeCtrl::OnCmdPrompt() 
{
	BOOL root;
 
	if (GetSelectedCount() && 
		GetItemLevel(GetSelectedItem(0), &root)== 2 && 
		IsMyPendingChangeFile(GetSelectedItem(0)) )
	{
        HTREEITEM item = NULL;
		if (m_ContextPoint.x != -1 && m_ContextPoint.y != -1)
		{
			// find out what item was clicked to generate the last context menu
			TV_HITTESTINFO ht;
			ht.pt=m_ContextPoint;
			ScreenToClient(&ht.pt);
			ht.flags=TVHT_ONITEMLABEL | TVHT_ONITEMICON | TVHT_ONITEMBUTTON;
			item=HitTest( &ht );
		}
		if (!item || !IsSelected(item) || !IsAFile(item))
		{
			item = GetSelectedItem(0);
			if (!IsAFile(item))
			{
				MainFrame()->OnCmdPromptPublic();
				return;
			}
		}
 
		CString clientPath;
		if(GetClientPath(item, clientPath))
		{
			int	i;
			clientPath.Replace('/', '\\');
			if ((i = clientPath.ReverseFind(_T('\\'))) != -1)
				clientPath = clientPath.Left(i);
 
			TCHAR	cmd[MAX_PATH+1];
 
			GetEnvironmentVariable(_T("ComSpec"), cmd, MAX_PATH);
 
			STARTUPINFO si;
			memset(&si, 0, sizeof(si));
			si.cb = sizeof(si);
			PROCESS_INFORMATION pi;
			CreateProcess(NULL, cmd, 
				NULL, NULL, 
#ifdef UNICODE
                FALSE, CREATE_NEW_CONSOLE | NORMAL_PRIORITY_CLASS | CREATE_UNICODE_ENVIRONMENT, 
#else
				FALSE, CREATE_NEW_CONSOLE | NORMAL_PRIORITY_CLASS, 
#endif
				MainFrame()->P4GetEnvironmentStrings(), 
				clientPath, &si, &pi);
		}
	}
	else
		MainFrame()->OnCmdPromptPublic();
}
 
void CDeltaTreeCtrl::OnJobDescribe() 
{
	HTREEITEM item=GetLastSelection();  
	
	if (item == NULL)
		ASSERT(0);
	else
	{
		CString itemStr=GetItemText(item);
		itemStr.TrimLeft(); 
 
		CCmd_Describe *pCmd= new CCmd_Describe;
		pCmd->Init( m_hWnd, RUN_ASYNC);
		if( pCmd->Run( P4JOB_SPEC, itemStr ) )
			MainFrame()->UpdateStatus( LoadStringResource(IDS_FETCHING_JOB_SPEC) );	
		else
			delete pCmd;
	}	
}
 
void CDeltaTreeCtrl::OnJobEditspec() 
{
	HTREEITEM item=GetLastSelection();  
	
	if (item == NULL)
		ASSERT(0);
	else
	{
		CString itemStr=GetItemText(item);
		itemStr.TrimLeft(); 
		MainFrame()->EditJobSpec(&itemStr);
	}
}
 
void CDeltaTreeCtrl::OnAddjobfix() 
{
    if( SERVER_BUSY() )
    {
		EnumChildWindows(AfxGetMainWnd()->m_hWnd, ChildSetRedraw, TRUE);
        ASSERT(0);
        return;
    }
 
	HTREEITEM currItem=GetLastSelection();  
		
	if(!IsMyPendingChange(currItem))
		currItem=GetParentItem(currItem);
 
	// no selected item - menu enables should have prevented
	if (currItem == NULL)
		{ EnumChildWindows(AfxGetMainWnd()->m_hWnd, ChildSetRedraw, TRUE); ASSERT(0); return; }
 
	// selected item not one of my changes - fix menu enables should have prevented
	if(GetParentItem(currItem) != m_MyRoot)
		{ EnumChildWindows(AfxGetMainWnd()->m_hWnd, ChildSetRedraw, TRUE); ASSERT(0); return; }
	
	// Record the change that is involved
	m_ActiveItem=currItem;
	m_EditChangeNum=GetSelectedChangeNumber();
 
	if(m_EditChangeNum < 0L)
		{ EnumChildWindows(AfxGetMainWnd()->m_hWnd, ChildSetRedraw, TRUE); ASSERT(0); return; }
 
    // Ask jobs window to update itself (if required) and send WM_P4JOBS when done
    // The reply message will be handled below
    SET_APP_HALTED(TRUE);
    ::SendMessage( m_jobWnd, WM_FETCHJOBS, (WPARAM)m_EditChangeNum, (LPARAM)m_hWnd);
}
 
 
LRESULT CDeltaTreeCtrl::OnP4JobList(WPARAM wParam, LPARAM lParam)
{
    m_EditChangeNum= wParam;
 
    // Get the list of jobs
    CObList *jobs= (CObList *) ::SendMessage( m_jobWnd, WM_QUERYJOBS, 0, 0);
    ASSERT(jobs);
    ASSERT_KINDOF(CObList,jobs);
 
	CString *spec= (CString *) ::SendMessage( m_jobWnd, WM_QUERYJOBSPEC, 0, 0);
    ASSERT(spec);
 
	CStringArray *cols= (CStringArray *) ::SendMessage( m_jobWnd, WM_QUERYJOBCOLS, 0, 0);
    ASSERT(cols);
 
	CString *curr= (CString *) ::SendMessage( m_jobWnd, WM_QUERYJOBSELECTION, 0, 0);
 
	CJobListDlg dlg;
	dlg.SetJobFont(GetFont());
	dlg.SetJobList(jobs);
	dlg.SetJobSpec(spec);
	dlg.SetJobCols(cols);
	dlg.SetJobCurr(curr);
	CStringList *jobnames= dlg.GetSelectedJobs();
 
	EnumChildWindows(AfxGetMainWnd()->m_hWnd, ChildSetRedraw, TRUE);
	int retcode= dlg.DoModal();
    SET_APP_HALTED(FALSE);
 
	// Delete the job list
	for(POSITION pos=jobs->GetHeadPosition(); pos!=NULL; )
		delete (CP4Job *) jobs->GetNext(pos);
    delete jobs;
 
	if (retcode == IDOK && jobnames->GetCount() > 0)
		AddJobFixes(jobnames, dlg.m_JobStatusValue.GetLength() 
					? (LPCTSTR)dlg.m_JobStatusValue : NULL);
	else if (retcode == IDRETRY)
	{
	    ::SendMessage( m_jobWnd, WM_CLEARLIST, 0, 0);   
		PostMessage(WM_COMMAND, ID_CHANGE_ADDJOBFIX, 0);
	}
 
	MainFrame()->ClearStatus();
    return 0;
}
 
void CDeltaTreeCtrl::AddJobFixes(CStringList *jobnames, LPCTSTR jobstatusvalue)
{
    POSITION pos;
    CString str;
   
	// Copy the joblist
	m_JobList.RemoveAll();
	for(pos= jobnames->GetHeadPosition(); pos != NULL; )
	{
		str= jobnames->GetNext(pos);
		m_JobList.AddHead(str);
	}
 
	CCmd_Fix *pCmdFix= new CCmd_Fix;
	pCmdFix->Init( m_hWnd, RUN_ASYNC, LOSE_LOCK);
	if( pCmdFix->Run( &m_JobList, m_EditChangeNum, FALSE, jobstatusvalue ) )
	{
	    MainFrame()->UpdateStatus( LoadStringResource(IDS_FIXING_JOBS) );	
	}	
	else
		delete pCmdFix;
}
 
void CDeltaTreeCtrl::OnRemovefix() 
{
	HTREEITEM item=GetLastSelection();  
	m_ActiveItem=item;
		
	if (item == NULL)
		ASSERT(0);
	else
	{
		// Get the change number
		BOOL underMyRoot;
		int level=GetItemLevel(item, &underMyRoot);
		if(level==2) 
		{
			HTREEITEM change=GetParentItem(item);
			ASSERT(change != NULL);
			long changeNum= GetChangeNumber(change);
			ASSERT(changeNum);
 
			CString itemStr=GetItemText(item);
			itemStr.TrimLeft();  // Strip leading space
			m_StringList.RemoveAll();
			m_StringList.AddHead(itemStr);
 
			CCmd_Fix *pCmd= new CCmd_Fix;
			pCmd->Init( m_hWnd, RUN_ASYNC);
			if( pCmd->Run( &m_StringList, changeNum, TRUE ) )
				MainFrame()->UpdateStatus( LoadStringResource(IDS_UNFIXING_JOB) );	
			else
				delete pCmd;
		}
	}
}
 
 
void CDeltaTreeCtrl::OnChgListRevert() 
{
	if (GET_SERVERLEVEL() < 19)	// if server is before 2005.1, don't try to diff - just warn
	{
		if (IDYES != AfxMessageBox(IDS_REVERTING_FILES_WILL_OVERWRITE_EDITS, 
									MB_YESNO|MB_ICONQUESTION))
			return;
	}
	else	// for 2005.2 and later servers, we can locally check to see if any files have changed
	{
		CString text;
		HTREEITEM currentItem = GetSelectedItem(0);
		int tot;
		BOOL b = SelectChgUnchg(TRUE, &tot);
		if (b)
		{
			int n = GetSelectionSetSize();
			text.FormatMessage(IDS_n_CHGED_REVERT_YESNO, n);
		}
		UnselectAll();
		SetSelectState( currentItem, TRUE );
		if (IDYES != AfxMessageBox(b ? text : LoadStringResource(IDS_ALL_UNCHGED_REVERT_YESNO), 
									MB_YESNO|MB_ICONQUESTION))
			return;
	}
 
	CString chg;
	long l = GetSelectedChangeNumber();
	if (l)
		chg.Format(_T("%ld"), l);
	else
		chg = _T("default");
	m_SelectionList.RemoveAll();
	m_SelectionList.AddHead(chg);
	m_SelectionList.AddTail(_T("//..."));
 
	m_DoRevert = FALSE;
	CCmd_Revert *pCmd= new CCmd_Revert;
	pCmd->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK);
	if( pCmd->Run(&m_SelectionList , TRUE ) )
		MainFrame()->UpdateStatus( LoadStringResource(IDS_REQUESTING_REVERT) );
	else
		delete pCmd;
}
 
void CDeltaTreeCtrl::OnFileRevert() 
{
	int cnt = GetSelectedCount();
	if(!cnt)
	{
		ASSERT(0);
		return;
	}
	if (GET_P4REGPTR()->AlwaysWarnOnRevert())
	{
		AssembleStringList( );
		OnP4FileRevert(0, 0);
		return;
	}
	if(cnt == 1 && IsMyPendingChange(GetSelectedItem(0)))
	{
		if (AnyFilesInChange(GetSelectedItem(0)))
			OnChgListRevert();
		return;
	}
 
	AssembleStringList( );
 
	if (GET_SERVERLEVEL() >= 14)
	{
		// Make a new list of selected files, but don't include those opened for add.
		// We can't use the list above from AssembleStringList()
		// because this list will be cleared by the Revert -an command 
		// plus we don't have to ask about any adds.
		AssembleStringList(&m_SelectionList, FALSE);
		
		// Run the p4 revert -an command on all the selected files not opened for add
		CCmd_Revert *pCmd= new CCmd_Revert;
		pCmd->Init( m_hWnd, RUN_ASYNC);
		pCmd->SetAlternateReplyMsg( WM_P4FILEREVERT );
		pCmd->SetNbrNonEdits(m_StringList.GetCount() - m_SelectionList.GetCount());
		if (m_SelectionList.IsEmpty())
		{
			pCmd->ClearError();
			OnP4FileRevert((WPARAM)pCmd, 0);
		}
		else if( pCmd->Run( &m_SelectionList, FALSE, TRUE, TRUE, FALSE, TRUE ) )
			MainFrame()->UpdateStatus(LoadStringResource(IDS_RUNNING_DIFF));
		else
			delete pCmd;
	}
	else
	{
		CCmd_Opened *pCmd= new CCmd_Opened;
		pCmd->Init( m_hWnd, RUN_ASYNC);
		pCmd->SetAlternateReplyMsg( WM_P4FILEREVERT );
 
		if( pCmd->Run( FALSE, FALSE, -1, &m_StringList ) )
			MainFrame()->UpdateStatus( LoadStringResource(IDS_REQUESTING_FILE_INFORMATION) );
		else
			delete pCmd;
	}
}
 
LRESULT CDeltaTreeCtrl::OnP4Revert( WPARAM wParam, LPARAM lParam )
{
	BOOL chainedCommands=FALSE;
 
	CCmd_Revert *pCmd= (CCmd_Revert *) wParam;
	ASSERT_KINDOF(CCmd_Revert, pCmd);
 
	if( !pCmd->GetError() )
	{
		if(m_DoRevert)
		{
			chainedCommands = DoRevert(pCmd->GetFileList(), 
									   pCmd->GetServerKey(), pCmd->OnlyUnChgd());
        }
		else
		{
			int cnt = pCmd->GetFileList()->GetCount();
			if (cnt > MAX_FILESEEKS)
			{
				int key= pCmd->GetServerKey();
				chainedCommands= TRUE;
				MainFrame()->UpdateDepotandChangeViews(REDRILL, key);
			}
			else
				OnP4RevertFile(pCmd->GetFileList());
 
			CString chg;
			CString text;
			if (pCmd->OnlyUnChgd() && !(chg = pCmd->GetChgName()).IsEmpty() && !pCmd->IsPreview())
				text.FormatMessage(IDS_REVERTEDALL_n_FILES, cnt, chg);
			else
				text.FormatMessage(IDS_REVERTED_n_FILES, cnt);
			AddToStatus(text, SV_COMPLETION);
		}
	}
	if( !chainedCommands || MainFrame()->IsQuitting() )
		pCmd->ReleaseServerLock();
	delete pCmd;
	return (0);
}
 
LRESULT CDeltaTreeCtrl::OnP4FileRevert( WPARAM wParam, LPARAM lParam )
{
	BOOL	bBox = TRUE;
	BOOL	bUseDashA = FALSE;
 
	if (!GET_P4REGPTR()->AlwaysWarnOnRevert())
	{
		if (GET_SERVERLEVEL() >= 14)
		{
			// m_StringList still contains our revert list
			CCmd_Revert *pCmd= (CCmd_Revert *) wParam;
 
			if(!pCmd->GetError() 
			&& pCmd->GetFileList()->GetCount() + pCmd->NbrNonEdits() == m_StringList.GetCount())
			{
				bBox = FALSE;
				if (pCmd->NbrNonEdits() == 0)
					bUseDashA = TRUE;
			}
			delete pCmd;
		}
		else
		{
			CCmd_Opened *pCmd= (CCmd_Opened *) wParam;
 
			if(!pCmd->GetError())
			{
				bBox = FALSE;
				m_StringList.RemoveAll();
				CObList *list = pCmd->GetList( );
				ASSERT_KINDOF( CObList, list );
				for(POSITION pos= list->GetHeadPosition(); pos!=NULL; )
				{
					CP4FileStats *stats = ( CP4FileStats * )list->GetNext( pos );
					ASSERT_KINDOF( CP4FileStats, stats );
					m_StringList.AddHead(stats->GetFullDepotPath( ));
					if (stats->GetMyOpenAction() != F_ADD)
						bBox = TRUE;
					delete stats;
				}
			}
			else AssembleStringList( );
			delete pCmd;
		}
	}
 
	if (bBox)
	{
		if(AfxMessageBox(IDS_REVERTING_FILES_WILL_OVERWRITE_EDITS, MB_ICONQUESTION|MB_YESNO) != IDYES)
		{
			MainFrame()->ClearStatus();
			return (0);
		}
	}
 
	CCmd_ListOpStat *pCmd2= new CCmd_ListOpStat;
	pCmd2->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK );
	// MUST use a temp variable or the release version 
	// will return garbage from SendMessage!
	int iFlag;
	::SendMessage(m_depotWnd, WM_ISFILTEREDONOPEN, 0, (LPARAM)&iFlag);
	pCmd2->SetRedoOpenedFilter(iFlag);
	if( pCmd2->Run( &m_StringList, bUseDashA ? P4REVERTUNCHG : P4REVERT ) )
		MainFrame()->UpdateStatus( LoadStringResource(IDS_REQUESTING_REVERT) );
	else
		delete pCmd2;
 
	return (0);
}
 
 
int CDeltaTreeCtrl::GetItemLevel(HTREEITEM currentItem, BOOL *underMyRoot)
{
	if (currentItem == NULL)
		return 0;
 
	int Level=0;
 
	// get its parent and grandparent (tree is only 3 layers deep)
	HTREEITEM parentItem=GetParentItem(currentItem);
	HTREEITEM rootItem;
	if(parentItem != NULL)
	{
		Level++;
		rootItem=GetParentItem(parentItem);
		if(rootItem!=NULL)
			Level++;
	}
	else
		rootItem=NULL;
		
	// is the item at or under m_MyRoot?
	if(currentItem != m_MyRoot && parentItem != m_MyRoot && rootItem != m_MyRoot)
		*underMyRoot=FALSE;
	else
		*underMyRoot=TRUE;
 
	return Level;
}
 
BOOL CDeltaTreeCtrl::OKToAddSelection( HTREEITEM currentItem )
{
	if (GetParentItem(currentItem) != GetLastSelectionParent())
		return FALSE;
														
	BOOL underMyRoot;
	int Level=GetItemLevel(currentItem, &underMyRoot);
 
	// Multi-select of files and jobs is OK.  All other 
	// multi-select is illegal
	if(Level==2)
		return TRUE;
	else
		return FALSE;
}
 
 
/*
	_________________________________________________________________
 
	Called by MSTreeView during OnLButtonDown to see if the user is 
	dragging before letting the mouse button up, which would indicate
	a drag drop operation.
	_________________________________________________________________
*/
 
BOOL CDeltaTreeCtrl::TryDragDrop( HTREEITEM currentItem )
{
	// Only files are draggable
	BOOL underMyRoot;
	if( GetItemLevel( currentItem, &underMyRoot ) != 2 )
		return FALSE;
 
	// Store the change this is from
	m_DragFromChange=GetParentItem(currentItem);
 
	// Dont actually send data - clipboard format is all the info target requires
	/*(DYNAMIC_DOWNCAST(CDeltaView,GetView()))->*/m_OLESource.DelayRenderData( (unsigned short) m_CF_DELTA);	// for P4WIN
	/*(DYNAMIC_DOWNCAST(CDeltaView,GetView()))->*/m_OLESource.DelayRenderData( (unsigned short) CF_HDROP);	// for external programs (dragging to an editor)
 
	// We lie here and tell it we will only do COPY, but actually we will really do a MOVE
	// if we drop the selection on another changelist.  This lie is done to prevent other
	// external programs that can accept a drag&drop from MOVing the files; they will only
	// COPY the files, never MOVE them.  Note that this means if you drag a file to
	// Explorer, you will copy it to the new location, not move it.
	m_DragDropCtr++;
	if(/*(DYNAMIC_DOWNCAST(CDeltaView,GetView()))->*/m_OLESource.DoDragDrop(DROPEFFECT_COPY, &m_DragSourceRect, NULL) == DROPEFFECT_MOVE)
	{
		// this code is probably now obsolete since we don't call DoDragDrop() with
		// DROPEFFECT_MOVE anymore.  But I'll leave it, just in case....
		m_LastDragDropTime = GetTickCount();// record the time so we can distinguish between CF_HDROP's from this window and CF_HDROP's from an external window
		UnselectAll();
		return TRUE;
	}
	else
	{
		m_LastDragDropTime = GetTickCount();// record the time so we can distinguish between CF_HDROP's from this window and CF_HDROP's from an external window
		return FALSE;
	}
}
 
// This rountine provides a list of dropped file names for CF_HDROP format drag and drop
// when the Changelist pane is the source of the drag and drop.
// The return value is the length of all the file names plus number of files (this is one less
// than the length of the memory needed to render the file names).  If there is nothing to
// render, the return value is 0.
// Call this routine with a NULL to just obtain the length needed for the buffer; call it
// with a pointer to the addr of a buffer in order to load that buffer with the file names.
int CDeltaTreeCtrl::RenderFileNames(LPTSTR p)
{
	static LPTSTR	pFN = 0;	// ptr to buffer to store file names to be rendered
	static DWORD	lFN = 0;	// lgth of buffer at pFN
	static DWORD	uFN = 0;	// amt of buffer at pFN actually in use
	static DWORD	ddCtr = 0;	// counter to validate contents of buffer at pFN
	LPTSTR ptr;
	int		i;
 
	// If the change list pane is the drop target, don't provide a list of files
	// because files from the chglist pane to the chglist pane are NOT in CF_HDROP format.
	if ( m_DeltaIsDropTarget )
		return 0;
 
	if (!pFN)
	{
		 pFN = (LPTSTR)::VirtualAlloc(NULL, lFN = 4096*sizeof(TCHAR), MEM_COMMIT, PAGE_READWRITE);
		 if (!pFN)
			 return(0);	// out of memory!
	}
	else if (ddCtr == m_DragDropCtr)	// is this D&D the same as the one we have stored?
	{
		if (p)
			memcpy(p, pFN, uFN*sizeof(TCHAR));
		return uFN;
	}
 
	for(i=GetSelectedCount()-1, ptr = pFN, uFN = 0; i>=0; i--)
	{
		HTREEITEM item= GetSelectedItem(i);
		if( IsMyPendingChangeFile( item ) )
		{
			CString clientPath;
			if(GetClientPath(item, clientPath))
			{
				if ((ptr + clientPath.GetLength() + (2*sizeof(TCHAR))) 
						>= (pFN + (lFN/sizeof(TCHAR))))	// running out of room?
				{
					LPTSTR sav = (LPTSTR)::VirtualAlloc(NULL, (lFN + 4096)*sizeof(TCHAR), MEM_COMMIT, PAGE_READWRITE);
					if (!sav)
						return(0);	// we're in trouble - out of memory!
					memcpy(sav, pFN, uFN*sizeof(TCHAR));
					ptr = sav + (ptr - pFN);
					::VirtualFree(pFN, 0, MEM_RELEASE);
					pFN = sav;
					lFN += 4096;
				}
				lstrcpy(ptr, clientPath);
				ptr += clientPath.GetLength() + 1;
				uFN += clientPath.GetLength() + 1;
			}
		}
	}
	*ptr = _T('\0');
	ddCtr = m_DragDropCtr;
	if (p)
		memcpy(p, pFN, uFN*sizeof(TCHAR));
	return uFN;
}
 
// Render CF_HDROP format drag and drop data.  Note that this routine is NOT a CDeltaTreeCtrl
// routine - it is an override of COleDataSource for m_OLESource.  It calls back to
// CDeltaTreeCtrl::RenderFileNames() to render the files names - it just sets up the structure
// that will hold the rendered file names.
BOOL CP4OleDataSource::OnRenderData( LPFORMATETC lpFormatEtc, LPSTGMEDIUM lpStgMedium )
{
	int	lgth;
 
	if ((lgth = m_deltaTree->RenderFileNames(NULL)) == 0)
		return FALSE;
	lpStgMedium->tymed = TYMED_HGLOBAL;
	lpStgMedium->hGlobal = GlobalAlloc(GHND, sizeof(_DROPFILES) + (lgth + 2)*sizeof(TCHAR));
	LPDROPFILES lpdropfiles = (LPDROPFILES)GlobalLock(lpStgMedium->hGlobal);
	lpdropfiles->pFiles = sizeof(_DROPFILES);
	lpdropfiles->pt.x = 0;
	lpdropfiles->pt.y = 0;
	lpdropfiles->fNC = FALSE;
#ifdef UNICODE
	lpdropfiles->fWide = TRUE;
#else
	lpdropfiles->fWide = FALSE;
#endif
	BOOL rc = m_deltaTree->RenderFileNames((LPTSTR)((char*)lpdropfiles + lpdropfiles->pFiles)) 
			? TRUE : FALSE;
	GlobalUnlock(lpStgMedium->hGlobal);
	if (!rc)	// if there were no file names rendered, clean up
	{
		GlobalFree(lpStgMedium->hGlobal);
		lpStgMedium->hGlobal = 0;
	}
	return rc;
}
 
 
//////////////////////////////////////////////////////////////////////////////////
// Context menu implementation.  Due to an apparent MFC bug, two mouse click handlers
// are included to make this work.  Prolly in the next release of MFC, the default
// OnCOntextMenu linkage can be used.
 
void CDeltaTreeCtrl::OnContextMenu(CWnd* pWnd, CPoint point) 
{
	BOOL defChange;
 
	m_ContextPoint = point;
 
	GetParentFrame()->ActivateFrame();
	m_Need2Edit = FALSE;
 
	HTREEITEM currentItem;
    SetItemAndPoint( currentItem, point );
    ClientToScreen( &point );
 
	BOOL underMyRoot=FALSE;
	int Level=0;
	if(currentItem != NULL)
		Level=GetItemLevel(currentItem, &underMyRoot);
 
	// Create the empty menus
	CP4Menu popMenu;
	popMenu.CreatePopupMenu();
	CP4Menu editMenu;
	editMenu.CreatePopupMenu();
	CP4Menu viewMenu;
	CP4Menu annotateMenu;
	CP4Menu resolveMenu;
	resolveMenu.CreatePopupMenu( );
 
	// make a new selection new if reqd
	if(!IsSelected(currentItem))
	{
		UnselectAll();
		SetSelectState(currentItem, TRUE);
	}
			
	// Most options only relevant for my own open files
	if( currentItem == NULL || (!IsMyPendingChange( currentItem ) && !IsMyPendingChangeItem( currentItem )) )
	{
		if( currentItem != NULL && Level == 1)
		{
			popMenu.AppendMenu( stringsON, ID_CHANGE_DESCRIBE, LoadStringResource( IDS_DESCRIBEIT ) );
			if(HasChildren(currentItem))
				popMenu.AppendMenu( stringsON, ID_POSITIONDEPOT, LoadStringResource(IDS_FINDCHGFILESINDEPOT_F));
		}
		goto EndContext;
	}
 
	defChange= (Level==1 && GetChangeNumber(currentItem)==0);
				
	if(Level==1)  // Its a change
	{
		//		for all changelists with files in them. put submit first
		//
		if(HasChildren(currentItem))
		{
			popMenu.AppendMenu( stringsON, ID_CHANGE_SUBMIT );
			popMenu.AppendMenu(MF_SEPARATOR);
		}
 
		//		for numbered changelists only
		//
		if( !defChange)
		{
			popMenu.AppendMenu( stringsON, ID_CHANGE_EDSPEC, LoadStringResource( IDS_EDITSPEC ) );
			popMenu.AppendMenu( stringsON, ID_CHANGE_DESCRIBE, LoadStringResource( IDS_DESCRIBEIT ) );
			popMenu.AppendMenu( stringsON, ID_CHANGE_ADDJOBFIX, LoadStringResource( IDS_ADDJOBFIX ) );
		}
 
		// Choice for empty changes if not default
		if(!HasChildren(currentItem) && !defChange)
			popMenu.AppendMenu( stringsON, ID_CHANGE_DEL );
 
		// Choices relevant only to non-empty change
		if(HasChildren(currentItem))
		{
			popMenu.AppendMenu( stringsON, ID_CHANGE_REVORIG );
			popMenu.AppendMenu( stringsON, ID_FILE_DIFFHEAD, LoadStringResource(IDS_DIFFFILESAGAINSTDEPOT));	
			popMenu.AppendMenu( stringsON, ID_POSITIONDEPOT, LoadStringResource(IDS_FINDCHGFILESINDEPOT_F));	
		}
	}
	if(Level==2) // Its a file or job (jobs not supported yet)
	{
		if(AnyMyPendingChangeFiles())
		{
			if ( AnyMyInteg() || AnyMyBranch() )
			{
				if(!SERVER_BUSY() && IsEditableFile())
				{
					viewMenu.CreatePopupMenu();
					viewMenu.AppendMenu( stringsON, ID_FILE_QUICKBROWSE, 
								LoadStringResource( IDS_ASSOCVIEWER ));
 
					int actualMRUs=0;
					for(int i=0; i < MAX_MRU_VIEWERS; i++)
					{
						if( GET_P4REGPTR()->GetMRUViewerName(i).GetLength() > 0 )
						{
							viewMenu.AppendMenu( stringsON, ID_FILE_BROWSER_1+i, 
									CString ( _T("&") + GET_P4REGPTR()->GetMRUViewerName(i)) );
							actualMRUs++;
						}
					}
 
					viewMenu.AppendMenu( stringsON, ID_FILE_NEWBROWSER, 
						LoadStringResource ( IDS_OTHERVIEWER ) );
 
					if(!SERVER_BUSY() && viewMenu.GetMenuItemCount() > 0)
					{
						popMenu.AppendMenu(MF_POPUP, (UINT) viewMenu.GetSafeHmenu(), 
							LoadStringResource( IDS_VIEWUSING ));
					}
				}
 
			}
			
			if(!SERVER_BUSY() && IsEditableFile())
			{
				editMenu.AppendMenu( stringsON, ID_FILE_QUICKEDIT, 
							LoadStringResource( IDS_ASSOCEDITOR ));
 
				int actualMRUs=0;
				for(int i=0; i < MAX_MRU_VIEWERS; i++)
				{
					if( GET_P4REGPTR()->GetMRUViewerName(i).GetLength() > 0 )
					{
						editMenu.AppendMenu( stringsON, ID_FILE_EDITOR_1+i, 
								CString ( _T("&") + GET_P4REGPTR()->GetMRUViewerName(i)) );
						actualMRUs++;
					}
				}
 
				editMenu.AppendMenu( stringsON, ID_FILE_NEWEDITOR, LoadStringResource ( IDS_OTHEREDITOR ) );
				editMenu.AppendMenu( stringsON, ID_FILE_RMVEDITOR, LoadStringResource ( IDS_RMVEDITOR ));
			}
 
			if(!SERVER_BUSY() && editMenu.GetMenuItemCount() > 0)
			{
				popMenu.AppendMenu(MF_POPUP, (UINT) editMenu.GetSafeHmenu(), 
					LoadStringResource( IDS_EDITUSING ));
			}
 
			if ( AnyMyInteg() || AnyMyBranch() )
				popMenu.AppendMenu( stringsON, ID_FILE_OPENEDIT, LoadStringResource( IDS_REOPENFOREDIT ) );
 
			popMenu.AppendMenu( stringsON, ID_FILE_DIFFHEAD, 
				LoadStringResource(GetSelectedCount() > 1 ? IDS_DIFFFILESAGAINSTDEPOT : IDS_DIFFFILEAGAINSTDEPOT) );	
 
			if(!SERVER_BUSY())
			{
				popMenu.AppendMenu(stringsON, ID_FILETYPE, LoadStringResource( IDS_CHANGEFILETYPE) );
				popMenu.AppendMenu(stringsON, ID_FILE_MV2OTHERCHGLIST, LoadStringResource( IDS_FILE_MV2OTHERCHGLIST) );
			}
				
			if(AnyMyUnLocked())
				popMenu.AppendMenu( stringsON, ID_FILE_LOCK, LoadStringResource( IDS_LOCK ) );	
			if(AnyMyLock())
				popMenu.AppendMenu( stringsON, ID_FILE_UNLOCK, LoadStringResource( IDS_UNLOCK ) );	
		}
	}
 
	if (((Level==1) && HasChildren(currentItem)) || ((Level==2) && AnyMyPendingChangeFiles()))	// for both changes and files
	{
		resolveMenu.AppendMenu( stringsON, ID_FILE_RESOLVE, LoadStringResource( IDS_INTERACTIVELY )  );	
		resolveMenu.AppendMenu( stringsON, ID_FILE_AUTORESOLVE, LoadStringResource( IDS_AUTORESOLVE ) );	
		resolveMenu.AppendMenu( stringsON, ID_FILE_RUNMERGETOOL, LoadStringResource( IDS_RUNMERGETOOL )  );	
		resolveMenu.AppendMenu( stringsON, ID_FILE_SCHEDULE, 
				LoadStringResource(((Level==1) || (GetSelectedCount() > 1)) ? IDS_SCHEDULEFILESFORRESOLVE 
																			: IDS_SCHEDULEFILEFORRESOLVE) );
		if (Level==2 && IsAFile(currentItem) && GetSelectedCount()==1 && !SERVER_BUSY()
		 && IsMyPendingChangeItem(currentItem))
		{
			CP4FileStats *stats= (CP4FileStats *) GetLParam(currentItem);
			if(stats != NULL && (stats->IsUnresolved() || stats->IsResolved()))
			{
				resolveMenu.AppendMenu(MF_SEPARATOR);
				resolveMenu.AppendMenu( stringsON, ID_THEIRFILE_PROPERTIES, LoadStringResource( IDS_THEIRFILE_PROPERTIES )  );
				resolveMenu.AppendMenu( stringsON, ID_THEIRFILE_REVISIONHISTORY, LoadStringResource( IDS_THEIRFILE_REVISIONHISTORY )  );
				resolveMenu.AppendMenu( stringsON, ID_THEIRFILE_FINDINDEPOT, LoadStringResource( IDS_THEIRFILE_FINDINDEPOT )  );
			}
		}
		if(!SERVER_BUSY())
			popMenu.AppendMenu(MF_POPUP, (UINT) resolveMenu.GetSafeHmenu(), 
				LoadStringResource ( (Level==1) ? IDS_MENU_RESOLVE_FILES : IDS_MENU_RESOLVE ) );
	}
 
	if (Level == 2) // rest of a file or job
	{
		if( IsAFile(currentItem) )
		{
			if (!SERVER_BUSY() && GET_SERVERLEVEL() >= 14 && GetSelectedCount()==1)
			{
				CP4FileStats *fs= (CP4FileStats *) GetLParam( GetSelectedItem(0) );
				BOOL enable = ( fs->GetHaveRev() <= 1
								&& ( fs->GetMyOpenAction() == F_ADD 
								  || fs->GetMyOpenAction() == F_BRANCH ) ) ? FALSE : TRUE;
				if (enable)
				{
					CString fileType = fs->GetHeadType();
					enable = ((fileType.Find(_T("text")) != -1) 
							|| (fileType.Find(_T("symlink")) != -1)) ? TRUE : FALSE;
				}
				if (enable)
				{
					annotateMenu.CreatePopupMenu();
					annotateMenu.AppendMenu( stringsON, ID_FILE_ANNOTATE, LoadStringResource ( IDS_FILE_ANNOTATE ) );
					annotateMenu.AppendMenu( stringsON, ID_FILE_ANNOTATEALL, LoadStringResource ( IDS_FILE_ANNOTATEALL ) );
					annotateMenu.AppendMenu( stringsON, ID_FILE_ANNOTATECHG, LoadStringResource ( IDS_FILE_ANNOTATECHG ) );
					annotateMenu.AppendMenu( stringsON, ID_FILE_ANNOTATECHGALL, LoadStringResource ( IDS_FILE_ANNOTATECHGALL ) );
					popMenu.AppendMenu(MF_POPUP, (UINT) annotateMenu.GetSafeHmenu(), 
						LoadStringResource( IDS_ANNOTATEFILE ));
				}
			}
			popMenu.AppendMenu( stringsON, ID_FILE_PROPERTIES, LoadStringResource( IDS_PROPERTIES ) );
			if (MainFrame()->HaveP4QTree())
				popMenu.AppendMenu( stringsON, ID_FILE_REVISIONTREE,LoadStringResource( IDS_REVISIONTREE ) );
			if (MainFrame()->HaveTLV())
				popMenu.AppendMenu( stringsON, ID_FILE_ANNOTATIONS, LoadStringResource( IDS_ANNOTATIONS ));
			popMenu.AppendMenu( stringsON, ID_FILE_REVISIONHISTORY, LoadStringResource( IDS_REVISIONHISTORY ) );
			if (!GetChangeNumber(currentItem))	// is it the default change?
			{
				popMenu.AppendMenu( MF_SEPARATOR );
				popMenu.AppendMenu( stringsON, ID_CHANGE_SUBMIT, LoadStringResource( IDS_SUBMIT_SELECTED ) );
			}
			popMenu.AppendMenu( MF_SEPARATOR);
			popMenu.AppendMenu( stringsON, ID_POSITIONDEPOT, LoadStringResource( IDS_POSITIONDEPOT ) );
			BOOL b = TRUE;
			if (GET_SERVERLEVEL() >= 19)			// 2005.1 or later?
			{
				CP4FileStats *stats= (CP4FileStats *) GetLParam(currentItem);
				if (stats->GetOtherOpenAction() == 0)
					b = FALSE;
			}
			if (b)
				popMenu.AppendMenu( stringsON, ID_POSITIONCHGS, LoadStringResource( IDS_POSITIONOTHERCHG ) );
			if (GetSelectedCount()==1)
				popMenu.AppendMenu( stringsON, ID_ADD_BOOKMARK, LoadStringResource(IDS_ADD_BOOKMARK) );
			popMenu.AppendMenu( stringsON, ID_WINEXPLORE, LoadStringResource( IDS_EXPLORE ) );
			popMenu.AppendMenu( stringsON, ID_CMDPROMPT, LoadStringResource( IDS_CMDPROMPT ) );
		}
 
		if(AnyJobs())
		{
			// job options
			popMenu.AppendMenu( stringsON, ID_JOB_DESCRIBE, LoadStringResource( IDS_DESCRIBEFIXEDJOB ) );	
			popMenu.AppendMenu( stringsON, ID_JOB_EDITSPEC, LoadStringResource( ID_JOB_EDITSPEC ) );
			popMenu.AppendMenu( stringsON, ID_CHANGE_REMOVEFIX, LoadStringResource( IDS_UNFIXJOB ) );	
		}
		else
		{
			popMenu.AppendMenu( MF_SEPARATOR );
			popMenu.AppendMenu( stringsON, ID_FILE_REVERT, LoadStringResource( IDS_REVERT ) );	
		}
	}
 
 
EndContext:
	if( currentItem != NULL && !IsMyPendingChangeItem( currentItem ) && Level == 2)
	{
		if ( IsAFile(currentItem) )
		{
			popMenu.AppendMenu( stringsON, ID_FILE_PROPERTIES, LoadStringResource( IDS_PROPERTIES ) );
			popMenu.AppendMenu( stringsON, ID_FILE_REVISIONHISTORY, LoadStringResource( IDS_REVISIONHISTORY ) );
			popMenu.AppendMenu( stringsON, ID_POSITIONDEPOT, LoadStringResource( IDS_POSITIONDEPOT ) );
			popMenu.AppendMenu( stringsON, ID_POSITIONCHGS, LoadStringResource( IDS_POSITIONOTHERCHG ) );
		}
		else
			popMenu.AppendMenu( stringsON, ID_JOB_DESCRIBE, LoadStringResource( IDS_DESCRIBEFIXEDJOB ));
	}
 
	if ( Level == 1 && popMenu.GetMenuItemCount( ) > 0 )
		popMenu.AppendMenu(MF_SEPARATOR);
 
	if ( Level != 2 )
	{
        popMenu.AppendMenu( stringsON, ID_CHANGE_NEW, LoadStringResource( IDS_NEWCHANGELIST ) );
        popMenu.AppendMenu( stringsON, ID_SORTCHGFILESBYNAME, LoadStringResource( IDS_SORTCHGFILESBYNAME ) );
        popMenu.AppendMenu( stringsON, ID_SORTCHGFILESBYEXT, LoadStringResource( IDS_SORTCHGFILESBYEXT ) );
        popMenu.AppendMenu( stringsON, ID_SORTCHGFILESBYACTION, LoadStringResource( IDS_SORTCHGFILESBYACTION ) );
        popMenu.AppendMenu( stringsON, ID_SORTCHGFILESBYRESOLVE, LoadStringResource( IDS_SORTCHGFILESBYRESOLVE ) );
		popMenu.AppendMenu( stringsON, ID_SORTCHGSBYUSER, LoadStringResource( IDS_SORTCHGSBYUSER ) );
 
		if( currentItem != NULL && !IsMyPendingChange( currentItem ) && Level == 1)
		{
			popMenu.AppendMenu( MF_SEPARATOR );
			popMenu.AppendMenu( stringsON, ID_USER_SWITCHTOUSER, LoadStringResource(IDS_USER_SWITCHTOUSER));
		}
		if( currentItem != NULL && !underMyRoot && Level == 1)
			popMenu.AppendMenu( stringsON, ID_CLIENTSPEC_SWITCH, LoadStringResource(IDS_CLIENTSPEC_SWITCH));
 
		if( currentItem != NULL && !underMyRoot && Level == 0)
		{
			popMenu.AppendMenu( MF_SEPARATOR );
			popMenu.AppendMenu(MF_ENABLED | MF_STRING, ID_FILTER_SETVIEW, LoadStringResource(IDS_FILTER_PCO_SETVIEW));
			popMenu.AppendMenu(MF_ENABLED | MF_STRING, ID_FILTER_CLEARVIEW, LoadStringResource(IDS_FILTER_PCO_CLEARVIEW));
		}
		popMenu.AppendMenu( MF_SEPARATOR );
		popMenu.AppendMenu( stringsON, ID_VIEW_UPDATE, LoadStringResource( IDS_REFRESH ) );
	}
 
	MainFrame()->AddToolsToContextMenu(&popMenu);
 
	// Finally blast the menu onto the screen
	m_InContextMenu = TRUE;
	popMenu.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON,	point.x, point.y, AfxGetMainWnd());
	m_InContextMenu = FALSE;
}
 
 
void CDeltaTreeCtrl::OnRButtonDown(UINT nFlags, CPoint point) 
{
	// Do nothing	
}
 
void CDeltaTreeCtrl::OnRButtonUp(UINT nFlags, CPoint point) 
{
    //CTreeView::OnRButtonUp(nFlags, point);
	CPoint screenPt=point;
	ClientToScreen(&screenPt);
    m_ContextContext= MOUSEHIT;
	OnContextMenu(NULL, screenPt);
}
 
 
 
//////////////////////////////////////////////////////////////////
// Handlers for OnUpdateUI
 
 
void CDeltaTreeCtrl::OnUpdateChangeDescribe(CCmdUI* pCmdUI) 
{
	long chgnbr = 0;
	BOOL underMyRoot;
	BOOL b = GetSelectedCount()==1 && 
			 GetItemLevel( GetSelectedItem(0), &underMyRoot ) == 1 &&
			 (chgnbr = GetSelectedChangeNumber()) > 0;
 
    CString txt;
	if (b)
		txt.FormatMessage(IDS_DESCRIBEPENDING_d, chgnbr);
	else
		txt.LoadString(IDS_DESCRIBESUBMITTED);
	pCmdUI->SetText ( txt );
	pCmdUI->Enable(!SERVER_BUSY() && b);
}
 
void CDeltaTreeCtrl::OnUpdateChgEdspec(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!SERVER_BUSY() && !m_EditInProgress &&
					( IsSelectionSubmittableChange() ||
					  IsSelectionInSubmittableChange() ||
 
					  ( GetSelectedCount()==1 &&
					  IsMyPendingChange(GetSelectedItem(0)) &&
					  GetChangeNumber(GetSelectedItem(0)) != 0) ) 
 
					  );
}
 
void CDeltaTreeCtrl::OnUpdateChgDel(CCmdUI* pCmdUI) 
{
	pCmdUI->SetText( LoadStringResource ( IDS_DELEMPTYCHANGELIST ) );
	pCmdUI->Enable(!SERVER_BUSY() && GetSelectedCount()==1 &&
					IsMyPendingChange(GetSelectedItem(0)) &&
					!HasChildren(GetSelectedItem(0)) 
					&& GetChangeNumber(GetSelectedItem(0)) != 0 );
}
 
void CDeltaTreeCtrl::OnUpdateChgNew(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!SERVER_BUSY() && !m_EditInProgress);	
}
 
void CDeltaTreeCtrl::OnUpdateChgRevorig(CCmdUI* pCmdUI) 
{
	pCmdUI->SetText( LoadStringResource ( IDS_REVERTUNCHANGED ) );
	pCmdUI->Enable(!SERVER_BUSY() && GetSelectedCount()==1 &&
					IsMyPendingChange(GetSelectedItem(0)) &&
					AnyFilesInChange(GetSelectedItem(0)) );	
}
 
void CDeltaTreeCtrl::OnUpdateChgSubmit(CCmdUI* pCmdUI) 
{
	pCmdUI->SetText( LoadStringResource ( IDS_SUBMIT ) );
	pCmdUI->Enable( MainFrame()->SetMenuIcon(pCmdUI, !SERVER_BUSY() && !m_EditInProgress
		&& ( IsSelectionSubmittableChange()
			|| IsSelectionInSubmittableChange() ) ) );	
}
 
void CDeltaTreeCtrl::OnUpdateFileLock(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( MainFrame()->SetMenuIcon(pCmdUI, !SERVER_BUSY() && AnyMyUnLocked()) );
}
 
void CDeltaTreeCtrl::OnUpdateFileUnlock(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( MainFrame()->SetMenuIcon(pCmdUI, !SERVER_BUSY() && AnyMyLock()) );
}
 
void CDeltaTreeCtrl::OnUpdateFileRevisionhistory(CCmdUI* pCmdUI) 
{
	BOOL root;
	BOOL enable= (!SERVER_BUSY() && GetSelectedCount() == 1 &&
					GetItemLevel(GetSelectedItem(0), &root)== 2 && 
					IsAFile( GetSelectedItem(0)) );
	if( enable )
	{
		CP4FileStats *fs= (CP4FileStats *) GetLParam( GetSelectedItem(0) );
		if( fs->GetHaveRev() <= 1 &&
			( fs->GetMyOpenAction() == F_ADD || fs->GetMyOpenAction() == F_BRANCH ) )
			enable= FALSE;
	}
	pCmdUI->Enable( MainFrame()->SetMenuIcon(pCmdUI, enable) );
}
 
void CDeltaTreeCtrl::OnUpdateFileAnnotate(CCmdUI* pCmdUI) 
{
	BOOL root;
	BOOL enable = !SERVER_BUSY() && GET_SERVERLEVEL() >= 14
					&& GetSelectedCount()==1
					&& GetItemLevel(GetSelectedItem(0), &root)== 2 
					&& IsAFile( GetSelectedItem(0) );
	if( enable )
	{
		CP4FileStats *fs= (CP4FileStats *) GetLParam( GetSelectedItem(0) );
		if( fs->GetHaveRev() <= 1 &&
			( fs->GetMyOpenAction() == F_ADD || fs->GetMyOpenAction() == F_BRANCH ) )
			enable= FALSE;
		if (enable)
		{
			CString fileType = fs->GetHeadType();
			enable = ((fileType.Find(_T("text")) != -1) 
					 || (fileType.Find(_T("symlink")) != -1)) ? TRUE : FALSE;
		}
	}
	pCmdUI->Enable( MainFrame()->SetMenuIcon(pCmdUI, enable) );
}
 
void CDeltaTreeCtrl::OnUpdateWinExplore(CCmdUI* pCmdUI) 
{
	BOOL root;
	pCmdUI->Enable(GetSelectedCount() &&
					GetItemLevel(GetSelectedItem(0), &root)== 2 && 
					IsMyPendingChangeFile( GetSelectedItem(0)) );
}
 
void CDeltaTreeCtrl::OnUpdateCmdPrompt(CCmdUI* pCmdUI) 
{
	BOOL root;
	pCmdUI->Enable(GetSelectedCount() &&
					GetItemLevel(GetSelectedItem(0), &root)== 2 && 
					IsMyPendingChangeFile( GetSelectedItem(0)) );
}
 
void CDeltaTreeCtrl::OnUpdateFileGet(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( MainFrame()->SetMenuIcon(pCmdUI, !SERVER_BUSY() 
		&& GetSelectedCount() > 0 
		&& IsMyPendingChangeFile(GetSelectedItem(0))) );
}
 
void CDeltaTreeCtrl::OnUpdateFileDiffhead(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(MainFrame()->SetMenuIcon(pCmdUI, !SERVER_BUSY()
		&& GetSelectedCount() > 0
		&& (IsMyPendingChangeFile(GetSelectedItem(0))
		 || (IsMyPendingChange(GetSelectedItem(0))
		  && AnyFilesInChange(GetSelectedItem(0))))));	
}
 
void CDeltaTreeCtrl::OnUpdateFiletype(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!SERVER_BUSY() && GetSelectedCount() > 0 &&
					AnyMyPendingChangeFiles() );	
}
 
void CDeltaTreeCtrl::OnUpdateMoveFiles(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!SERVER_BUSY() && GetSelectedCount() > 0
		&& AnyMyPendingChangeFiles()
		&& !m_EditInProgress );	
}
 
void CDeltaTreeCtrl::OnUpdateJobDescribe(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( OnUpdateJob(pCmdUI, IDS_DESCRIBEIT_s) );
}
 
void CDeltaTreeCtrl::OnUpdateJobEditspec( CCmdUI* pCmdUI ) 
{
	pCmdUI->Enable( OnUpdateJob(pCmdUI, IDS_EDITSPEC_s) );
}
 
BOOL CDeltaTreeCtrl::OnUpdateJob(CCmdUI* pCmdUI, int msgnbr)
{
	BOOL bEnable = FALSE;
	int cnt = GetSelectedCount();
	if (!SERVER_BUSY() && cnt >= 1 && AnyJobs())
	{
		HTREEITEM item= GetSelectedItem(0);
		
		int i = 0;
		if (cnt > 1)
		{
			BOOL underMyRoot;
			int level= GetItemLevel(item, &underMyRoot);
 
			if(level ==2)
			{
				for( ; i < cnt; i++)
				{
					if(GetLParam(GetSelectedItem(i)) == NULL)
					{
						item= GetSelectedItem(i);
						break;
					}
				}
			}
		}
 
		if (item == NULL || GetLParam(item) != NULL)
			ASSERT(0);
		else
		{
			CString itemStr=GetItemText(item);
			itemStr.TrimLeft(); 
			if (!itemStr.IsEmpty( ))
			{
				CString txt;
				txt.FormatMessage(msgnbr, TruncateString(itemStr, 50));
				pCmdUI->SetText ( txt );
				bEnable = TRUE;
			}
		}
	}
	return bEnable ;
}
 
void CDeltaTreeCtrl::OnUpdateAddjobfix(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!SERVER_BUSY() && 
			  (	 (GetSelectedCount() == 1 && IsMyPendingChange(GetSelectedItem(0)) && 
				  GetChangeNumber(GetSelectedItem(0)) )  ||
			     IsSelectionInMyNumberedChange()) );
}
 
void CDeltaTreeCtrl::OnUpdateRemovefix(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!SERVER_BUSY() && GetSelectedCount() == 1 &&
					AnyJobs() );	
}
 
 
void CDeltaTreeCtrl::OnUpdateFileRevert(CCmdUI* pCmdUI) 
{
	int cnt = GetSelectedCount();
	HTREEITEM currentItem = GetSelectedItem(0);
	pCmdUI->Enable( MainFrame()->SetMenuIcon(pCmdUI, !SERVER_BUSY() && cnt > 0 
		&& (AnyMyPendingChangeFiles() || (cnt == 1 
										&& IsMyPendingChange(currentItem) 
										&& AnyFilesInChange(currentItem)))) );	
}
 
 
//////////////////////////////////////////////////////////////
// Funcions for use in OnUpdateUI handlers and OnContextMenu()
 
BOOL CDeltaTreeCtrl::IsMyPendingChange(HTREEITEM currentItem)
{
	BOOL myChange= FALSE;
	BOOL underMyRoot;
	int level= GetItemLevel(currentItem, &underMyRoot);
 
	if(level==1 && underMyRoot)
	{
		if( GetImage( currentItem) != CP4ViewImageList::VI_YOUROTHERCHANGE )
			myChange= TRUE;
	}
	
	return myChange;
}
 
BOOL CDeltaTreeCtrl::IsOpenedForInteg(HTREEITEM currentItem)
{
	BOOL opened4integ= FALSE;
	BOOL underMyRoot;
	int level= GetItemLevel(currentItem, &underMyRoot);
 
	if(level==2 && underMyRoot && GetLParam(currentItem) != NULL)
	{
		CP4FileStats *fs= (CP4FileStats *) GetLParam(currentItem);
		if(fs->GetMyOpenAction()==F_INTEGRATE && fs->GetHaveRev() != 0)
		{
			opened4integ=TRUE;
		}
	}
	return opened4integ;
}
 
BOOL CDeltaTreeCtrl::IsOpenedForBranch(HTREEITEM currentItem)
{
	BOOL opened4branch= FALSE;
	BOOL underMyRoot;
	int level= GetItemLevel(currentItem, &underMyRoot);
 
	if(level==2 && underMyRoot && GetLParam(currentItem) != NULL)
	{
		CP4FileStats *fs= (CP4FileStats *) GetLParam(currentItem);
		if(fs->GetMyOpenAction()==F_BRANCH && fs->GetHaveRev() != 0)
		{
			opened4branch=TRUE;
		}
	}
	return opened4branch;
}
 
BOOL CDeltaTreeCtrl::IsMyPendingChangeFile(HTREEITEM currentItem)
{
	BOOL myFile= FALSE;
	BOOL underMyRoot;
	int level= GetItemLevel(currentItem, &underMyRoot);
 
	if(level==2 && underMyRoot && GetLParam(currentItem) != NULL)
	{
		CP4FileStats *fs= (CP4FileStats *) GetLParam(currentItem);
		if( !fs->IsOtherUserMyClient() )
			myFile= TRUE;
	}
 
	return myFile;
}
 
BOOL CDeltaTreeCtrl::IsMyPendingChangeItem(HTREEITEM currentItem)
{
	BOOL myItem= FALSE;
	BOOL underMyRoot;
	int level= GetItemLevel(currentItem, &underMyRoot);
 
	if(level==2 && underMyRoot)
	{
		HTREEITEM changeItem= GetParentItem(currentItem);
		if( GetImage( changeItem ) != CP4ViewImageList::VI_YOUROTHERCHANGE )
			myItem= TRUE;
	}
 
	return myItem;
}
 
BOOL CDeltaTreeCtrl::IsSelectionSubmittableChange()
{
	// True if only one item is selected and that item is a change
	// that I can be submit
	return ( GetSelectedCount()==1 && 
		     IsMyPendingChange(GetSelectedItem(0)) &&
			 AnyFilesInChange(GetSelectedItem(0)) );
}
 
BOOL CDeltaTreeCtrl::IsSelectionInSubmittableChange()
{
	// True if item(s) selected are in a change
	// that I can be submit
	return ( GetSelectedCount() > 0 && 
			 IsMyPendingChangeItem(GetSelectedItem(0)) &&
			 AnyFilesInChange( GetParentItem(GetSelectedItem(0)) ) );
}
 
BOOL CDeltaTreeCtrl::IsSelectionInMyNumberedChange()
{
	// True if item(s) selected are in my numbered (not default) change
	if( GetSelectedCount() == 0 )
		return FALSE;
 
	HTREEITEM parentItem=GetParentItem(GetSelectedItem(0));
	if(parentItem == NULL)
		return FALSE;
	
	return( IsMyPendingChange(parentItem) && GetChangeNumber(parentItem) > 0 );
}
 
 
BOOL CDeltaTreeCtrl::AnyMyPendingChangeFiles()
{
	BOOL myChangeFile=FALSE;
	
	for(int i=GetSelectedCount()-1; i>=0; i--)
	{
		if(IsMyPendingChangeFile(GetSelectedItem(i)))
		{
			myChangeFile=TRUE;
			break;
		}
	}
	return myChangeFile;
}
 
BOOL CDeltaTreeCtrl::AnyJobs()
{
	BOOL anyJobs=FALSE;
	
	if(GetSelectedCount() ==0 )
		{ return FALSE; }
 
	HTREEITEM firstItem= GetSelectedItem(0);
	
	BOOL underMyRoot;
	int level= GetItemLevel(firstItem, &underMyRoot);
 
	if(level ==2)
	{
		for(int i=GetSelectedCount()-1; i>=0; i--)
		{
			if(GetLParam(GetSelectedItem(i)) == NULL)
			{
				anyJobs=TRUE;
				break;
			}
		}
	}
	return anyJobs;
}
 
BOOL CDeltaTreeCtrl::AnyFilesInChange( HTREEITEM changeItem )
{
	BOOL anyFiles=FALSE;
	
	if( changeItem == NULL )
		{ return FALSE; }
 
	HTREEITEM child= GetChildItem( changeItem );
	while( child != NULL )
	{
		if( GetLParam( child ) > 0 )
		{
			anyFiles= TRUE;
			break;
		}
		child= GetNextSiblingItem( child );
	}
	
	return anyFiles;
}
 
 
BOOL CDeltaTreeCtrl::AnyMyInteg()
{
	BOOL anyMyInteg=FALSE;
	
	if(GetSelectedCount() ==0 )
		{ return FALSE; }
 
	HTREEITEM firstItem= GetSelectedItem(0);
		
	if(IsMyPendingChangeItem( firstItem ))
	{
		for(int i=GetSelectedCount()-1; i>=0; i--)
		{
			if(IsOpenedForInteg(GetSelectedItem(i)))
			{
				anyMyInteg=TRUE;
				break;
			}
		}
	}
	return anyMyInteg;
}
 
 
BOOL CDeltaTreeCtrl::AnyMyBranch()
{
	BOOL anyMyBranch=FALSE;
	
	if(GetSelectedCount() ==0 )
		{ return FALSE; }
 
	HTREEITEM firstItem= GetSelectedItem(0);
		
	if(IsMyPendingChangeItem( firstItem ))
	{
		for(int i=GetSelectedCount()-1; i>=0; i--)
		{
			if(IsOpenedForBranch(GetSelectedItem(i)))
			{
				anyMyBranch=TRUE;
				break;
			}
		}
	}
	return anyMyBranch;
}
 
 
BOOL CDeltaTreeCtrl::AnyMyLock()
{
	BOOL anyMyLock=FALSE;
	
	if(GetSelectedCount() ==0 )
		{ return FALSE; }
 
	HTREEITEM firstItem= GetSelectedItem(0);
	CP4FileStats *stats;
		
	if(IsMyPendingChangeItem( firstItem ))
	{
		for(int i=GetSelectedCount()-1; i>=0; i--)
		{
			stats= (CP4FileStats *) GetLParam(GetSelectedItem(i));
			if(stats != NULL)
			{
				if(stats->IsMyLock())
				{
					anyMyLock=TRUE;
					break;
				}
			}
		}
	}
	return anyMyLock;
 
}
 
 
BOOL CDeltaTreeCtrl::AnyMyUnLocked()
{
	BOOL anyMyUnLocked=FALSE;
	
	if(GetSelectedCount() ==0 )
		{ return FALSE; }
 
	HTREEITEM firstItem= GetSelectedItem(0);
	CP4FileStats *stats;
	
	if(IsMyPendingChangeItem(firstItem))
	{
		for(int i=GetSelectedCount()-1; i>=0; i--)
		{
			stats= (CP4FileStats *) GetLParam(GetSelectedItem(i));
			if(stats != NULL)
			{
				if(!stats->IsMyLock())
				{
					anyMyUnLocked=TRUE;
					break;
				}
			}
		}
	}
	return anyMyUnLocked;
}
 
// A file is consider binary (as far as this routine is concerned)
// if its base type is "binary"
// or its base type is "text" plus its storage type is C or F
BOOL CDeltaTreeCtrl::AnyBinaryFiles(BOOL bAnyResolvable/*=FALSE*/)
{
	BOOL anyMyFilesBinary=FALSE;
	
	if(GetSelectedCount() ==0 )
		{ return FALSE; }
 
	HTREEITEM firstItem= GetSelectedItem(0);
		
	if(IsMyPendingChangeItem( firstItem ))
	{
		int		baseType;
		int		storeType;
		BOOL	typeK;
		BOOL	typeW;
		BOOL	typeX;
		BOOL	typeO;
		BOOL	typeM;
		BOOL	typeL;
		BOOL	typeS;
		int		nbrrevs;
		BOOL	unknown;
		for(int i=GetSelectedCount()-1; i>=0; i--)
		{
			TheApp()->GetFileType(GetItemText(GetSelectedItem(i)), 
							baseType, storeType, typeK, typeW, typeX, 
							typeO, typeM, typeL, typeS, nbrrevs, unknown);
			if ((baseType == 1) 
			 || (baseType == 0 && (storeType == 1 || storeType == 3))
			 || (baseType == 5 && (storeType == 1 || storeType == 3)))
			{
				if (bAnyResolvable)
				{
					CP4FileStats *stats = (CP4FileStats *) GetLParam(GetSelectedItem(i));
					if(stats != NULL)
					{
						if (!stats->IsUnresolved() && !stats->IsResolved())
							continue;
					}
				}
				anyMyFilesBinary=TRUE;
				break;
			}
		}
	}
	return anyMyFilesBinary;
 
}
 
 
BOOL CDeltaTreeCtrl::AnyUnresolvedFiles()
{
	BOOL anyUnresolved=FALSE;
	
	if(GetSelectedCount() ==0 )
		{ return FALSE; }
 
	HTREEITEM firstItem= GetSelectedItem(0);
	CP4FileStats *stats;
	
	if(IsMyPendingChangeItem(firstItem))
	{
		for(int i=GetSelectedCount()-1; i>=0; i--)
		{
			stats= (CP4FileStats *) GetLParam(GetSelectedItem(i));
			if(stats != NULL)
			{
				if(stats->IsUnresolved())
				{
					anyUnresolved=TRUE;
					break;
				}
			}
		}
	}
	return anyUnresolved;
}
 
BOOL CDeltaTreeCtrl::AnyResolvedFiles(BOOL bList/*=FALSE*/)
{
	BOOL anyResolved=FALSE;
 
	if (bList)
		m_StringList.RemoveAll();
	
	if(GetSelectedCount() ==0 )
		{ return FALSE; }
 
	HTREEITEM firstItem= GetSelectedItem(0);
	CP4FileStats *stats;
	
	if(IsMyPendingChangeItem(firstItem))
	{
		for(int i=GetSelectedCount()-1; i>=0; i--)
		{
			stats= (CP4FileStats *) GetLParam(GetSelectedItem(i));
			if(stats != NULL)
			{
				if(stats->IsResolved())
				{
					anyResolved=TRUE;
					if (bList)
						 m_StringList.AddHead(stats->GetFullDepotPath());
					else break;
				}
			}
		}
	}
	return anyResolved;
}
 
BOOL CDeltaTreeCtrl::AnyUnresolvedFilesInChg(HTREEITEM chgitem)
{
	BOOL anyUnresolved=FALSE;
	
	CP4FileStats *stats;
	HTREEITEM item=GetChildItem(chgitem);
	while(item!=NULL)
	{
		if(IsAFile(item))
		{
			stats= (CP4FileStats *) GetLParam(item);
			if(stats != NULL)
			{
				if(stats->IsUnresolved())
				{
					anyUnresolved=TRUE;
					break;
				}
			}
		}
		item=GetNextSiblingItem(item);
	}
	return anyUnresolved;
}
 
BOOL CDeltaTreeCtrl::AnyResolvedFilesInChg(HTREEITEM chgitem)
{
	BOOL anyResolved=FALSE;
 
	CP4FileStats *stats;
	HTREEITEM item=GetChildItem(chgitem);
	while(item!=NULL)
	{
		if(IsAFile(item))
		{
			stats= (CP4FileStats *) GetLParam(item);
			if(stats != NULL)
			{
				if(stats->IsResolved())
				{
					anyResolved=TRUE;
					break;
				}
			}
		}
		item=GetNextSiblingItem(item);
	}
	return anyResolved;
}
 
BOOL CDeltaTreeCtrl::AnyMyFilesUnresolved( )
{
	BOOL anyUnresolved=FALSE;
	
	HTREEITEM change= GetChildItem(m_MyRoot);
	HTREEITEM file;
	LPARAM lParam;
 
	while(change != NULL && !anyUnresolved)
	{
		file= GetChildItem(change);	
		while(file != NULL && !anyUnresolved)
		{
			lParam=GetLParam(file);
			if(lParam > 0)
            {
				CP4FileStats *stats= (CP4FileStats *) lParam;
                ASSERT_KINDOF(CP4FileStats, stats);
				if(stats->IsUnresolved())
				{
					anyUnresolved=TRUE;
					break;
				}
            }
 
			file=GetNextSiblingItem(file);
		}
		change=GetNextSiblingItem(change);
	}
	return anyUnresolved;
}
 
BOOL CDeltaTreeCtrl::AnyMyFilesResolved(BOOL bList/*=FALSE*/)
{
	BOOL anyResolved=FALSE;
 
	if (bList)
		m_StringList.RemoveAll();
	
	HTREEITEM change= GetChildItem(m_MyRoot);
	HTREEITEM file;
	LPARAM lParam;
 
	while(change != NULL && (!anyResolved || bList))
	{
		file= GetChildItem(change);	
		while(file != NULL && (!anyResolved || bList))
		{
			lParam=GetLParam(file);
			if(lParam > 0)
            {
				CP4FileStats *stats= (CP4FileStats *) lParam;
                ASSERT_KINDOF(CP4FileStats, stats);
				if(stats->IsResolved())
				{
					anyResolved=TRUE;
					if (bList)
						 m_StringList.AddHead(stats->GetFullDepotPath());
					else break;
				}
            }
 
			file=GetNextSiblingItem(file);
		}
		change=GetNextSiblingItem(change);
	}
	return anyResolved;
}
 
 
void CDeltaTreeCtrl::OnUpdateFileAutoresolve(CCmdUI* pCmdUI) 
{
	BOOL root;
	BOOL rc = FALSE;
	if (!SERVER_BUSY() && GetSelectedCount() > 0)
	{
		HTREEITEM item = GetSelectedItem(0);
		int level = GetItemLevel(item, &root);
		if (level == 2)
			rc = ((AnyMyFilesUnresolved() || AnyMyFilesResolved())
					&& IsMyPendingChangeFile(item)
					&& IsAFile( item) );
		else if (level == 1)
			rc = (IsMyPendingChange(item) 
					&& (AnyUnresolvedFilesInChg(item) || AnyResolvedFilesInChg(item))
					&& GetSelectedCount()==1);
	}
	pCmdUI->Enable(rc);
}
 
void CDeltaTreeCtrl::OnUpdateFileResolve(CCmdUI* pCmdUI) 
{
	BOOL root;
	BOOL rc = FALSE;
	if (!SERVER_BUSY() && GetSelectedCount() > 0)
	{
		HTREEITEM item = GetSelectedItem(0);
		int level = GetItemLevel(item, &root);
		if (level == 2)
			rc = ((AnyUnresolvedFiles() || AnyResolvedFiles())
					&& IsMyPendingChangeFile(item) );
		else if (level == 1)
			rc = (IsMyPendingChange(GetSelectedItem(0))
					&& (AnyUnresolvedFilesInChg(item) || AnyResolvedFilesInChg(item))
					&& GetSelectedCount()==1);
	}
	pCmdUI->Enable(rc);
}
 
void CDeltaTreeCtrl::OnUpdateTheirFile(CCmdUI* pCmdUI) 
{
	BOOL root;
	HTREEITEM item = GetSelectedItem(0);
	if (!SERVER_BUSY() && GetSelectedCount() == 1 && GetItemLevel(item, &root) == 2)
		OnUpdateFileResolve(pCmdUI);
	else
		pCmdUI->Enable(FALSE);
}
 
void CDeltaTreeCtrl::OnFileAutoresolve() 
{
	BOOL root;
	HTREEITEM initialItem = GetSelectedItem(0);
	int level = GetItemLevel(initialItem, &root);
	if (level == 1)
	{
		SelectAllFilesInChange(initialItem, 2);
		if (GetSelectedCount() < 1)
		{
			UnselectAll();
			SetSelectState(initialItem, TRUE);
			return;
		}
		else if (GetSelectedCount() > 32000)
		{	
			AfxMessageBox(IDS_UNABLE_TO_RESOLVE_MORE_THAN_32000_FILES, MB_ICONEXCLAMATION);
			UnselectAll();
			SetSelectState(initialItem, TRUE);
			return;
		}
	}
 
	MainFrame()->DoNotAutoPoll();
 
	CAutoResolveDlg dlg;
 
	BOOL u = AnyUnresolvedFiles();
	BOOL r = AnyResolvedFiles();
	dlg.m_NoSel2Res = (GetSelectedCount() && (u || r)) ? FALSE : TRUE;
	if (!u && r)
		dlg.m_ReResolve = TRUE;
	dlg.m_SelResolved = r;
	dlg.m_AnyResolved = AnyMyFilesResolved();
	dlg.m_ResolveFromChgList = (level == 1);
	dlg.m_pDeltaTreeCtrl = this;
	SetAppearance(TRUE, FALSE, FALSE);
	InvalidateRect( NULL, FALSE );
	UpdateWindow( );
	SetSelectAtts(TVIS_SELECTED);	// Clear the flag we set in call to SetAppearance() above
 
	if (dlg.DoModal() == IDOK)
	{
		if (dlg.m_AllFiles)
			 m_StringList.RemoveAll();
		else
		{
			if ((level == 1) && r && !dlg.m_ReResolve)
			{
				SelectAllFilesInChange(initialItem, 1);
				SetAppearance(TRUE, FALSE, FALSE);
				InvalidateRect( NULL, FALSE );
				UpdateWindow( );
				SetSelectAtts(TVIS_SELECTED);	// Clear the flag we set in call to SetAppearance() above
				if (GetSelectedCount() < 1)
				{
					UnselectAll();
					SetSelectState(initialItem, TRUE);
					AddToStatus(_T("0 files resolved"), SV_COMPLETION);
					MainFrame()->ResumeAutoPoll();
					return;
				}
			}
			AssembleStringList( );
		}
 
		CCmd_AutoResolve *pCmd= new CCmd_AutoResolve;
		pCmd->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK );
		if( pCmd->Run( &m_StringList, dlg.m_ResolveType, 
						dlg.m_Preview, dlg.m_ReResolve, dlg.m_TextMerge, dlg.m_ResolveWhtSp ) )
			MainFrame()->UpdateStatus( LoadStringResource(IDS_AUTO_RESOLVING) );
		else
			delete pCmd;
	}
	if (level == 1)
	{
		UnselectAll();
		SetSelectState(initialItem, TRUE);
	}
	MainFrame()->ResumeAutoPoll();
}
 
void CDeltaTreeCtrl::OnFileResolve() 
{
	OnFileMergeResolve(FALSE);
}
 
void CDeltaTreeCtrl::OnFileMerge() 
{
	OnFileMergeResolve(TRUE);
}
 
void CDeltaTreeCtrl::OnFileMergeResolve(BOOL bRunMerge) 
{
	int r, b, havehead;
 
	if (!GetSelectedCount())
		return;
 
	m_bRunMerge = bRunMerge;
	HTREEITEM initialItem = GetSelectedItem(0);
	BOOL root;
	int level = GetItemLevel(initialItem, &root);
	if (level == 1)
	{
		SelectAllFilesInChange(initialItem, 2);
		if (GetSelectedCount() < 1)
		{
			UnselectAll();
			SetSelectState(initialItem, TRUE);
			return;
		}
		else if (GetSelectedCount() > 32000)
		{	
			AfxMessageBox(IDS_UNABLE_TO_RESOLVE_MORE_THAN_32000_FILES, MB_ICONEXCLAMATION);
			UnselectAll();
			SetSelectState(initialItem, TRUE);
			return;
		}
	}
 
	if (!IsMyPendingChangeItem(GetSelectedItem(0)))
	{
		if (level == 1)
		{
			UnselectAll();
			SetSelectState(initialItem, TRUE);
		}
		return;
	}
	SetAppearance(TRUE, FALSE, FALSE);
	InvalidateRect( NULL, FALSE );
	UpdateWindow( );
	SetSelectAtts(TVIS_SELECTED);	// Clear the flag we set in call to SetAppearance() above
 
	HTREEITEM item;
	BOOL textualMerge = FALSE;
	r = AnyResolvedFiles();
	b = AnyBinaryFiles(TRUE);
	if (b)
	{
		b = FALSE;
		textualMerge = TRUE;
		CString appName;
		for(int i=GetSelectedCount()-1; i>=0; i--)
		{
			int		baseType;
			int		storeType;
			BOOL	typeK;
			BOOL	typeW;
			BOOL	typeX;
			BOOL	typeO;
			BOOL	typeM;
			BOOL	typeL;
			BOOL	typeS;
			int		nbrrevs;
			BOOL	unknown;
			int j;
			appName.Empty();
			CString filename = GetItemText(item = GetSelectedItem(i));
			TheApp()->GetFileType(filename, baseType, storeType, typeK, typeW, typeX, 
									typeO, typeM, typeL, typeS, nbrrevs, unknown);
			if ((baseType == 1) 
			 || (baseType == 0 && (storeType == 1 || storeType == 3))
			 || (baseType == 5 && (storeType == 1 || storeType == 3)))
			{
				CP4FileStats *stats = (CP4FileStats *) GetLParam(item);
				if(stats != NULL)
				{
					if (!stats->IsUnresolved() && !stats->IsResolved())
						continue;
				}
				CString extension = GetFilesExtension(filename);
				if ((j = extension.Find(_T('#'))) != -1)
					extension = extension.Left(j);
				if(!extension.IsEmpty())
					appName= GET_P4REGPTR()->GetAssociatedMerge(extension);
				if (appName.IsEmpty())
				{
					b = TRUE;
					textualMerge = FALSE;
					break;
				}
			}
		}
	}
	if (r || b)
	{
		if (GetSelectedCount() == 1)
		{
			CP4FileStats *stats= (CP4FileStats *) GetLParam(GetSelectedItem(0));
			if(stats != NULL)
				 havehead = (stats->GetHeadRev() == stats->GetHaveRev()) ? 1 : 0;
			else havehead = 0;
		}
		else havehead = 0;
		if (r && !b && havehead && !AnyUnresolvedFiles())
		{
			m_ReResolve = TRUE;
			m_TextualMerge = FALSE;
		}
		else
		{
			CResolveFlagsDlg dlg;
 
			dlg.m_ReResolve = r;
			dlg.m_TextualMerge = b;
			if (dlg.DoModal() == IDOK)
			{
				m_ReResolve = dlg.m_ReResolve;
				m_TextualMerge = b ? dlg.m_TextualMerge : textualMerge;
			}
			else return;
		}
	}
	else
	{
		m_ReResolve = FALSE;
		m_TextualMerge = textualMerge;
	}
 
	if (level == 1)
	{
		if (AnyResolvedFiles() && !m_ReResolve)
		{
			SelectAllFilesInChange(initialItem, 1);
			SetAppearance(TRUE, FALSE, FALSE);
			InvalidateRect( NULL, FALSE );
			UpdateWindow( );
			SetSelectAtts(TVIS_SELECTED);	// Clear the flag we set in call to SetAppearance() above
			if (GetSelectedCount() < 1)
			{
				UnselectAll();
				SetSelectState(initialItem, TRUE);
				AddToStatus(_T("0 files resolved"), SV_COMPLETION);
				return;
			}
		}
		// If the server is busy because we triggered an expand of a changelist
		// and are getting the attached jobs, wait for the server to finish
		if (SERVER_BUSY())
		{
			int t=GET_P4REGPTR()->BusyWaitTime();
			do
			{
				Sleep(50);
				t -= 50;
			} while (SERVER_BUSY() && t > 0);
		}
	}
 
	m_ResolveList.RemoveAll();
	for(int i=GetSelectedCount()-1; i>=0; i--)
	{
		item = GetSelectedItem(i);
		m_ResolveList.AddHead((CObject *)item);
	}
 
	// fire up a resolve on the first item
	item = (HTREEITEM)(m_ResolveList.RemoveHead());
	ResolveItem(item);
	if (level == 1)
	{
		UnselectAll();
		SetSelectState(initialItem, TRUE);
	}
}
 
void CDeltaTreeCtrl::ResolveItem(HTREEITEM item)
{
	BOOL bHeadIsText = FALSE;
	m_ForcedResolve = FALSE;
	m_ActiveItem=item;
	CString itemStr = GetItemText(item);
	itemStr=itemStr.Left(itemStr.ReverseFind(_T('#')));  // Strip revision number
	CP4FileStats *stats = (CP4FileStats *) GetLParam(item);
	if (stats != NULL)
	{
		bHeadIsText = stats->GetHeadType().Find(_T("text")) != -1 ? TRUE : FALSE;
		if (m_ReResolve)
		{
			if (stats->IsResolved())
				m_ForcedResolve = TRUE;
		}
	}
	CCmd_Resolve *pCmd= new CCmd_Resolve;
	pCmd->Init( m_hWnd, RUN_ASYNC);
	pCmd->SetHeadIsText(bHeadIsText);
	if( pCmd->Run( itemStr, m_ForcedResolve, m_TextualMerge ) )
		MainFrame()->UpdateStatus( LoadStringResource(IDS_RESOLVE) );	
	else
		delete pCmd;
}
 
void CDeltaTreeCtrl::SelectAllFilesInChange(HTREEITEM changeitem, int resolveFlag/*=0*/)
{
	UnselectAll();
	HTREEITEM item=GetChildItem(changeitem);
	while(item!=NULL)
	{
		BOOL bOK = IsAFile(item);
		if (resolveFlag && bOK)
		{
			bOK = FALSE;
			CP4FileStats *stats = (CP4FileStats *) GetLParam(item);
			if(stats != NULL)
			{
				if (stats->IsUnresolved() || ((resolveFlag == 2) && stats->IsResolved()))
					bOK = TRUE;
			}
		}
		if(bOK)
			SetSelectState(item, TRUE);
		item=GetNextSiblingItem(item);
	}
}
 
void CDeltaTreeCtrl::OnDestroy() 
{
	// Traverse tree, deleting each item's lParam
	// Cant wait till destructor, because Treeview items
	// are deleted by common ctrl before the destructor is called
	DeleteLParams(m_MyRoot);
	if (m_OthersRoot)
	{
		DeleteLParams(m_OthersRoot);
		m_OthersRoot = NULL;
	}
	CMultiSelTreeCtrl::OnDestroy();
}
 
void CDeltaTreeCtrl::ReopenAs(LPCTSTR newtype)
{
	if(GetSelectedCount()==0)
	{
		ASSERT(0);
		return;
	}
 
	AssembleStringList( );
 
	CCmd_ListOpStat *pCmd= new CCmd_ListOpStat;
	pCmd->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK );
	if( pCmd->Run( &m_StringList, P4REOPEN, -1, newtype ) )
		MainFrame()->UpdateStatus( LoadStringResource(IDS_REOPENING_FILES) );
	else
		delete pCmd;
}
 
 
///////////////////////////////////////////////////////////////////////////////////////////////
// Support for file editing
///////////////////////////////////////////////////////////////////////////////////////////////
//
// Command UI update functions:
//		OnUpdateFileAutoedit(CCmdUI* pCmdUI) 
//
// Main Menu command handlers
//		OnFileQuickedit()		(will use associated app)
//		OnFileAutoedit()		(will start with chooser dialog)
//		----> EditFile()
//
// Context Menu command handlers
//		OnFileMRUEditor(UINT  nID)
//		OnFileNewEditor()
//		OnFileQuickedit()
//		----> EditFile()
//
// Command goes to depot window
//		EditFile()
//		----> SendMessage WM_FILEEDITTXT (or WM_FILEEDITBIN) to depot wnd, 
//						wparam= CString *path
//						lparam= 0-(MAX_MRU-1) for MRU, 
//								10 for quick edit, 
//								100 for chooser dialog
//								1000 for new editor
//
///////////////////////////////////////////////////////////////////////////////////////////////
 
 
void CDeltaTreeCtrl::OnUpdateFileAutoedit(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(MainFrame()->SetMenuIcon(pCmdUI, !SERVER_BUSY() && IsEditableFile()));	
}
 
void CDeltaTreeCtrl::OnUpdateFileAutobrowse(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(MainFrame()->SetMenuIcon(pCmdUI, !SERVER_BUSY() && IsEditableFile()));
}
 
BOOL CDeltaTreeCtrl::IsEditableFile()
{
	BOOL isEditable=FALSE;
 
	if(GetSelectedCount() == 1 && AnyMyPendingChangeFiles())
		isEditable=TRUE;
	
	return isEditable;
}
 
void CDeltaTreeCtrl::OnFileMRUEditor(UINT nID)
{
	EditFile(nID - ID_FILE_EDITOR_1, TRUE);
}
 
void CDeltaTreeCtrl::OnFileMRUBrowser(UINT nID)
{
	EditFile(nID - ID_FILE_BROWSER_1, FALSE);
}
 
void CDeltaTreeCtrl::OnFileQuickedit() 
{
	EditFile(EDIT_ASSOCVIEWER, TRUE);
}
 
void CDeltaTreeCtrl::OnFileQuickbrowse()
{
	EditFile(EDIT_ASSOCVIEWER, FALSE);
}
 
void CDeltaTreeCtrl::OnFileAutoedit() 
{
	EditFile(EDIT_CHOOSEVIEWER, TRUE);
}
 
void CDeltaTreeCtrl::OnFileNewEditor()
{
	EditFile(EDIT_FINDNEWVIEWER, TRUE);
}
 
void CDeltaTreeCtrl::OnFileNewBrowser()
{
	EditFile(EDIT_FINDNEWVIEWER, FALSE);
}
 
void CDeltaTreeCtrl::EditFile(int lparam, BOOL editing)
{
	HTREEITEM item= GetLastSelection();
	ASSERT(item!=NULL);
 
	m_Need2Edit = FALSE;
	if(item != NULL)
	{
		if(GetClientPath(item, m_ClientPath))
		{
			CP4FileStats *fs=(CP4FileStats *) GetLParam( item );
			if (editing && (IsOpenedForInteg(item) || IsOpenedForBranch(item)))
			{
				m_Msg2Send = fs->IsTextFile() ? WM_FILEEDITTXT : WM_FILEEDITBIN;
				m_Need2Edit = TRUE;
				m_SavelParam = lparam;
				OnFileOpenedit();
			}
			else
			{
				if (fs->GetMyOpenAction() == F_INTEGRATE)
					 m_Msg2Send = fs->IsTextFile() ? WM_FILEBROWSETXT : WM_FILEBROWSEBIN;
				else m_Msg2Send = fs->IsTextFile() ? WM_FILEEDITTXT : WM_FILEEDITBIN;
				::SendMessage(m_depotWnd, m_Msg2Send, (WPARAM) &m_ClientPath, lparam);
			}
		}
	}
}
 
void CDeltaTreeCtrl::OnUpdateRemoveViewer(CCmdUI* pCmdUI)
{
	BOOL b = FALSE;
	for(int i=0; i < MAX_MRU_VIEWERS; i++)
	{
		if( GET_P4REGPTR()->GetMRUViewerName(i).GetLength() > 0 )
		{
			b = TRUE;
			break;
		}
	}
	pCmdUI->Enable( b );
}
 
void CDeltaTreeCtrl::OnRemoveViewer()
{
	CRemoveViewer dlg;
	dlg.DoModal();
}
 
 
/*
	_________________________________________________________________
*/
 
BOOL CDeltaTreeCtrl::GetClientPath(HTREEITEM item, CString& clientPath)
{
    int key=0;
 
	CP4FileStats *stats= (CP4FileStats *) GetLParam( item );
    ASSERT(stats);
    ASSERT_KINDOF(CP4FileStats,stats);
 
	if(GET_SERVERLEVEL() >= 19)			// 2005.1 or later?
	{
		clientPath = stats->GetFullClientPath( );
        if( !clientPath.IsEmpty() )
            return TRUE;
	}
 
	BOOL addingFile= (stats->GetMyOpenAction() == F_ADD || stats->GetMyOpenAction() == F_BRANCH ); 
 
	// The server must be available, must be capable of returning a useable path,
	// and our attempt to get a server lock must succeed, else we bail
	if( SERVER_BUSY() || ( GET_SERVERLEVEL() < 4 && addingFile ) ||
		!GET_SERVER_LOCK(key))
    {
        return FALSE;
    }
 
	CCmd_Fstat *pCmd= new CCmd_Fstat;
	BOOL success = FALSE;
	
	CString itemStr= GetItemText(item);
	itemStr.TrimRight();
	int pound= itemStr.ReverseFind(_T('#'));
	if(pound == -1)
	{
		ASSERT(0);
		goto GetClientPathEnd;
	}
 
	itemStr = itemStr.Left( pound );
			
	//		file open for edit. we can't get the client path from the 
	//		depot window anymore since the new p4 dirs/fstat doesnt get
	//		all the files, but only those under the expanded subdirectory
	//		tree. and we cant use p4 where (see below) since p4 where
	//		returns the path of where the file would be if the server
	//		had gotten it. so the only save way of getting the client
	//		path is to call p4 fstat ( run it synchronously )
	//
	pCmd->Init(NULL, RUN_SYNC, HOLD_LOCK, key);
	if ( !PumpMessages( ) )
		goto GetClientPathEnd;
 
	pCmd->SetIncludeAddedFiles( TRUE );
	if( pCmd->Run( FALSE, itemStr, 0 ) && !pCmd->GetError() )
	{
		CObList *list = pCmd->GetFileList ( );
		ASSERT_KINDOF( CObList, list );
        ASSERT( list->GetCount() <= 1 );
		POSITION pos = list->GetHeadPosition( );
        if( pos != NULL )
        {
			CP4FileStats *stats = ( CP4FileStats * )list->GetNext( pos );
			ASSERT_KINDOF( CP4FileStats, stats );
			clientPath = stats->GetFullClientPath( );
            if( !clientPath.IsEmpty() )
                success = TRUE;
            delete stats;
		}		
	}
 
GetClientPathEnd:
    RELEASE_SERVER_LOCK(key);
	delete pCmd;
	return success;
}
 
 
/*
	_________________________________________________________________
 
	Double click action is to attempt to edit the file if its our open file
	Note that GetClientPath will fail if the server is busy
	_________________________________________________________________
*/ 
 
void CDeltaTreeCtrl::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
	CTreeCtrl::OnLButtonDblClk(nFlags, point);
	if(nFlags & (MK_CONTROL | MK_MBUTTON| MK_RBUTTON | MK_SHIFT))
		return;
 
	// find out what was hit
	TV_HITTESTINFO ht;
	ht.pt=point;
	HTREEITEM currentItem=HitTest( &ht);
 
	if( currentItem != NULL && (ht.flags & TVHT_ONITEM) && currentItem == m_LastLButtonDown)
		OnLButtonDblClk(currentItem);
}
 
void CDeltaTreeCtrl::OnLButtonDblClk(HTREEITEM currentItem) 
{
	// make a new selection new if reqd
	if(!IsSelected(currentItem))
	{
		UnselectAll();
		if(currentItem != NULL)
			SetSelectState(currentItem, TRUE);
	}
 
	if(!SERVER_BUSY() && IsEditableFile())
	{
		switch (GET_P4REGPTR()->GetDoubleClickOption())
		{
		case 0:	// Edit
		case 1:	// open
		case 2:	// open and edit
		case 3:	// view head revision
		case 4:	// sync to head revision
		default:
		{
			CString clientPath;
 
			if(GetClientPath(currentItem, clientPath))
			{
				CP4FileStats *fs=(CP4FileStats *) GetLParam( currentItem );
				if (fs->GetMyOpenAction() == F_INTEGRATE)
					 m_Msg2Send = fs->IsTextFile() ? WM_FILEBROWSETXT : WM_FILEBROWSEBIN;
				else m_Msg2Send = fs->IsTextFile() ? WM_FILEEDITTXT   : WM_FILEEDITBIN;
				::SendMessage(m_depotWnd, m_Msg2Send, (WPARAM) &clientPath, EDIT_ASSOCVIEWER);
				return;
			}
		}
 
		case 5:	// diff versus head revision
			PostMessage(WM_COMMAND, ID_FILE_DIFFHEAD, 0);
			break;
 
		case 6:	// display Properties dialogbox
			PostMessage(WM_COMMAND, ID_FILE_PROPERTIES, 0);
			break;
 
		case 7:	// display Revision History dialogbox
			PostMessage(WM_COMMAND, ID_FILE_REVISIONHISTORY, 0);
			break;
		}
	}
	else if(!HasChildren(currentItem))
	{
		BOOL underMyRoot=FALSE;
		int level = GetItemLevel(currentItem, &underMyRoot);
		if((GetLParam(currentItem) == NULL) && (level == 2))
			OnJobDescribe();
		else
			MessageBeep(MB_OK);
	}
}
 
 
/*
	_________________________________________________________________
 
	at least one file is selected, user is sure, so put all selected
	file names sans revision number in the string list.
	_________________________________________________________________
*/
 
BOOL CDeltaTreeCtrl::AssembleStringList( CStringList *list /*=NULL*/, BOOL includeAdds /*=TRUE*/ )
{
	CString itemStr;
	BOOL bFoundFileOpenedForAdd = FALSE;
 
	if (!list)
		list = &m_StringList;
 
	list->RemoveAll();
 
	for( int i = GetSelectedCount()-1; i >= 0; i--)
	{
		itemStr = GetItemText( GetSelectedItem( i ) );
		if (itemStr.Right(5) == _T("<add>"))
		{
			bFoundFileOpenedForAdd = TRUE;
			if (!includeAdds)
				continue;
		}
		int sep = itemStr.ReverseFind( _T('#') );
		if (sep != -1)
		{
			itemStr = itemStr.Left( sep );  
			list->AddHead( itemStr );
		}
	}
	return bFoundFileOpenedForAdd;
}
 
BOOL CDeltaTreeCtrl::GetSelectedFiles( CStringList *list )
{
	list->RemoveAll();
 
	HTREEITEM cItem;
	CString itemStr;
	CString clientPath;
 
	for( int i = GetSelectedCount() - 1; i >= 0; i-- )
	{
		cItem = GetSelectedItem( i );
		itemStr = GetItemText( cItem );
 
		//		if it's not a changelist, add it to the list
		//
		if( !HasChildren( cItem ) && (itemStr.ReverseFind( _T('#') ) != -1) )
		{
			if(GetClientPath(cItem, clientPath))
				list->AddHead( clientPath );
			else
				return FALSE;
		}
	}
	return TRUE;
}
 
 
/*
	_________________________________________________________________
 
	for commands that will run synchronously.
	_________________________________________________________________
*/
 
BOOL CDeltaTreeCtrl::PumpMessages( )
{
	if (MainFrame()->IsQuitting())
		return FALSE;
 
	MSG msg;
 
	while ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
	{
		//		get out if app is terminating
		//
		if ( msg.message == WM_QUIT )
			return FALSE;
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
 
	return TRUE;
}
 
 
// Support for quick copy of depot path or client path to the clipboard
//
 
void CDeltaTreeCtrl::OnUpdateEditCopy(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( GetSelectedCount()>=1 && IsMyPendingChangeFile( GetSelectedItem(0)));
}
 
void CDeltaTreeCtrl::OnUpdateEditCopyclientpath(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( GetSelectedCount()>=1 && IsMyPendingChangeFile( GetSelectedItem(0)));
}
 
void CDeltaTreeCtrl::OnUpdateEditSelectAll(CCmdUI* pCmdUI) 
{
	BOOL selectable=FALSE;
	if( GetSelectedCount() > 0 )
	{
		if( IsMyPendingChangeItem( GetSelectedItem(0)) )
			selectable= TRUE;
		else if( IsMyPendingChange( GetSelectedItem(0)) )
		{
			UINT state= CTreeCtrl::GetItemState( GetSelectedItem(0), TVIS_EXPANDED );
			if( (state & TVIS_EXPANDED) == TVIS_EXPANDED )
				selectable=TRUE;
		}
	}
	pCmdUI->Enable( selectable );
}
 
void CDeltaTreeCtrl::OnEditCopyclientpath() 
{
	CString txt;
	for(int i=-1; ++i < GetSelectedCount(); )
	{
		HTREEITEM item= GetSelectedItem(i);
		if( IsMyPendingChangeFile( item ) )
		{
			CString clientPath;
			if(GetClientPath(item, clientPath))
			{
				if (i)
					txt += _T("\r\n");
				txt += clientPath;
			}
		}
	}
 
	if (txt.IsEmpty())
		MessageBeep(MB_ICONEXCLAMATION);
	else
		CopyTextToClipboard( txt );
}
 
void CDeltaTreeCtrl::OnEditCopy() 
{
	CString txt;
	for(int i=-1; ++i < GetSelectedCount(); )
	{
		HTREEITEM item= GetSelectedItem(i);
		BOOL underMyRoot=FALSE;
		int level= GetItemLevel(item, &underMyRoot);
 
		if( level == 2 && IsAFile( item ) )
		{
			// Fetch the filename for ANY file
			CString itemStr = GetItemText( item );
			itemStr = itemStr.Left( itemStr.ReverseFind( _T('#') ) );  
			if (i)
				txt += _T("\r\n");
			txt += itemStr;
		}
	}
 
	if (txt.IsEmpty())
		MessageBeep(MB_ICONEXCLAMATION);
	else
		CopyTextToClipboard( txt );
}
 
void CDeltaTreeCtrl::OnEditSelectAll() 
{
	if( GetSelectedCount() > 0 && 
		( IsMyPendingChangeItem( GetSelectedItem(0) ) ||
		  IsMyPendingChange( GetSelectedItem(0)) ) )
	{
		HTREEITEM parent;
		if( IsMyPendingChange( GetSelectedItem(0)) )
			parent= GetSelectedItem(0);
		else
			parent= GetParentItem( GetSelectedItem(0) );
 
		UnselectAll();
		SetMultiSelect(TRUE);
		HTREEITEM child= GetChildItem( parent );
		while( child != NULL )
		{
			SetSelectState( child, TRUE );
			child= GetNextSiblingItem(child);
		}
		SetMultiSelect(FALSE);
		ShowNbrSelected();
	}
}
 
void CDeltaTreeCtrl::OnUpdateFileOpenedit(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( MainFrame()->SetMenuIcon(pCmdUI, !SERVER_BUSY() 
		&& (AnyMyInteg() || AnyMyBranch())) );	
}
 
 
void CDeltaTreeCtrl::OnFileOpenedit() 
{
	if(GetSelectedCount()==0)
	{
		ASSERT(0);
		return;
	}
 
	CString itemStr;
 
	m_StringList.RemoveAll();
 
	for( int i = GetSelectedCount()-1; i >= 0; i--)
	{
		if(IsOpenedForInteg(GetSelectedItem(i)) || IsOpenedForBranch(GetSelectedItem(i)))
		{
			itemStr = GetItemText( GetSelectedItem( i ) );
			itemStr = itemStr.Left( itemStr.ReverseFind( _T('#') ) );  
			m_StringList.AddHead( itemStr );
		}
	}
	if (m_StringList.IsEmpty())
		return;
 
	CCmd_ListOpStat *pCmd= new CCmd_ListOpStat;
	pCmd->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK );
	if( pCmd->Run( &m_StringList, P4EDIT, 0 ) )
		MainFrame()->UpdateStatus( LoadStringResource(IDS_OPENING_FILES_FOR_EDIT) );
	else
		delete pCmd;
}
 
void CDeltaTreeCtrl::OnUpdatePositionDepot(CCmdUI* pCmdUI) 
{
	BOOL underMyRoot=FALSE;
	int level = GetItemLevel(GetSelectedItem(0), &underMyRoot);
 
	int n = GetSelectedCount();
	BOOL b = pCmdUI->m_pParentMenu == MainFrame()->GetMenu();
	if (level == 1)
	{
		if (b)
			pCmdUI->SetText(LoadStringResource(IDS_FINDCHGFILESINDEPOT));
		pCmdUI->Enable( n == 1 && AnyFilesInChange(GetSelectedItem(0)));
	}
	else
	{
		if (b)
			pCmdUI->SetText(LoadStringResource(n < 2 ? IDS_FINDSELFILEINDEPOT 
													 : IDS_FINDSELFILESINDEPOT));
		pCmdUI->Enable( n >= 1 && (level == 2) && IsAFile(GetSelectedItem(0)) );
	}
}
 
//	User clicked on "Find in Depot" menu item
//	Expand the Depot Treeview to the location of that file
//
void CDeltaTreeCtrl::OnPositionDepot() 
{
	// see if it's a chglist or file(s) that's selected
	HTREEITEM initialItem = GetSelectedItem(0);
	BOOL root;
	int level = GetItemLevel(initialItem, &root);
	if (level == 1)
	{
		// a chglist is selected, so select all its files
		SelectAllFilesInChange(initialItem, 0);
		if (GetSelectedCount() < 1)
		{
			UnselectAll();
			SetSelectState(initialItem, TRUE);
			return;
		}
	}
 
	int n;
	int count = 0;
	if( (n = GetSelectedCount()) >=1 )
	{
		MainFrame()->SetAdd2ExpandItemList(TRUE);
		for (int i=-1; ++i < n; )
		{
			HTREEITEM item= GetSelectedItem(i);
			if( GetItemLevel(item, &root) == 2 && IsAFile( item ) )
			{
				// Fetch the filename for ANY file
				CString itemStr = GetItemText( item );
				itemStr = itemStr.Left( itemStr.ReverseFind( _T('#') ) );  // trim off rev# info
				MainFrame()->ExpandDepotString( itemStr, TRUE );
				while (MainFrame()->IsExpandDepotContinuing() || SERVER_BUSY())
				{
					if ( !MainFrame()->PumpMessages( ) )
						break;
					Sleep(250);
				}
				count++;
			}
		}
	}
	if (level == 1)
	{
		UnselectAll();
		SetSelectState(initialItem, TRUE);
	}
	if (count)
	{
		MainFrame()->SetAdd2ExpandItemList(FALSE);
		MainFrame()->SelectExpandItemList();
		if (MainFrame()->GetExpandItemListCount() < count)
		{
			CString txt;
			n = count - MainFrame()->GetExpandItemListCount();
			txt.FormatMessage(IDS_NOTALLFILESSELECTED_d, n, n==1 ? _T("") : _T("s"));
			TheApp()->StatusAdd( txt, SV_WARNING );
		}
	}
	else
		MessageBeep(MB_ICONEXCLAMATION);	// unexpected problem - should never happen
}
 
// this returns -1 if the change is not found or is not MY change
// if the chg is found and it is mine, its number is returned
long CDeltaTreeCtrl::PositionChgs(const CString &path, 
								  BOOL lookInMine, 
								  BOOL lookInOthers/*=TRUE*/, 
								  BOOL addToSelectionSet/*=FALSE*/)
{
	long chg;
 
	// clear the previous position request string
	m_PositionTo = _T("");
 
	// first look thru my client's changes, if requested
	if (lookInMine && ((chg = PositionToFileInChg(path, m_MyRoot,
														m_MyRoot, FALSE, addToSelectionSet)) !=-1))
		return chg;
 
	if (!lookInOthers)
		return -1;
 
	chg = -1;
	if (m_OthersRoot)
	{
		// If we get here, we didn't find it among my clients,
		// so look thru the other clients.
		// First expand the Other Clients node - which might fail,
		// and thereby trigger a p4 opened -a
		Expand(m_OthersRoot, TVE_EXPAND);
		if ((chg = PositionToFileInChg(path, m_OthersRoot, 
											 m_OthersRoot, FALSE, addToSelectionSet)) == -1)
		{
			// We didn't find it, we might have triggered a p4 opened -a, 
			// so save off the name of the thing we are seeking
			m_PositionTo = path;
		}
	}
	return chg;
}
 
void CDeltaTreeCtrl::OnUpdatePositionOtherChgs(CCmdUI* pCmdUI) 
{
	m_PositionTo.Empty();
	if (!m_InContextMenu)
		pCmdUI->SetText( LoadStringResource(IDS_POSITIONCHGS_CHGPANE) );
 
	BOOL underMyRoot=FALSE;
	BOOL b = GetSelectedCount()==1 && 
		GetItemLevel(GetSelectedItem(0), &underMyRoot) == 2 &&
		IsAFile(GetSelectedItem(0));
	if (b && GET_SERVERLEVEL() >= 19)			// 2005.1 or later?
	{
		CP4FileStats *stats= (CP4FileStats *) GetLParam(GetSelectedItem(0));
		if (stats->GetOtherOpenAction() == 0)
			b = FALSE;
	}
	pCmdUI->Enable(b);
}
 
void CDeltaTreeCtrl::OnPositionOtherChgs()
{
	m_PositionTo.Empty();
 
	if ( !IsAFile(GetSelectedItem(0)) || !m_OthersRoot )
		return;
 
	HTREEITEM file = GetSelectedItem(0);
	LPARAM lParam=GetLParam(file);
	if(lParam > 0)
    {
		HTREEITEM start = GetParentItem(file);
		HTREEITEM root  = GetParentItem(start);
		start = (root == m_MyRoot) ? m_OthersRoot 
			  : GetNextSiblingItem(start);
		if (!start)
			return;
 
		CP4FileStats *stats= (CP4FileStats *) lParam;
        ASSERT_KINDOF(CP4FileStats, stats);
		CString path = stats->GetFullDepotPath();
		// First expand the Other Clients node - which might fail,
		// and thereby trigger a p4 opened -a
		Expand(m_OthersRoot, TVE_EXPAND);
		// then try and find the file
		if (PositionToFileInChg(path, start, m_OthersRoot) == -1)
		{
			// We didn't find it, we might have triggered a p4 opened -a, 
			// so save off the name of the thing we are seeking
			m_PositionTo = path;
		}
	}
}
 
long CDeltaTreeCtrl::PositionToFileInChg(const CString &path, 
										 HTREEITEM start, HTREEITEM root, 
										 BOOL afterExpand/*=FALSE*/,
										 BOOL addToSelectionSet/*=FALSE*/)
{
	HTREEITEM change = !start || (start == root) 
		             ? GetChildItem(root) : start;
	HTREEITEM file;
	LPARAM lParam;
	BOOL bFile = FALSE;
 
	while(change != NULL)
	{
		file= GetChildItem(change);	
		while(file != NULL)
		{
			lParam=GetLParam(file);
			if(lParam > 0)
            {
				CP4FileStats *stats= (CP4FileStats *) lParam;
                ASSERT_KINDOF(CP4FileStats, stats);
				if(stats->GetFullDepotPath() == path)
				{
					Expand(root, TVE_EXPAND);
					Expand(change, TVE_EXPAND);
					if (!addToSelectionSet)
						UnselectAll();
					SetSelectState( file, TRUE );
					// set focus to pending chglist pane
					MainFrame()->SetActiveView(DYNAMIC_DOWNCAST(CView,GetParent()), TRUE);
					long chg = stats->GetOpenChangeNum();
					CString txt;
					txt.FormatMessage(chg ? IDS_FILE_FOUND_IN_CHG_d : IDS_FILE_FOUND_IN_DEFCHG, chg);
					MainFrame()->SetMessageText(txt);
					return chg;
				}
				bFile = TRUE;
            }
 
			file=GetNextSiblingItem(file);
		}
		change=GetNextSiblingItem(change);
	}
	if (bFile)
		MainFrame()->SetMessageText(LoadStringResource(afterExpand ? IDS_FILE_NOT_FOUND_IN_OTHERS 
																   : IDS_CHGFILE_NOT_FOUND));
	return -1;
}
 
 
void CDeltaTreeCtrl::OnUpdatePositionToPattern(CCmdUI* pCmdUI) 
{
	CString txt = LoadStringResource(IDS_POSITIONTOPATTERN);
	pCmdUI->SetText ( txt );
	pCmdUI->Enable(!SERVER_BUSY());
}
 
void CDeltaTreeCtrl::OnPositionToPattern() 
{
	::PostMessage(m_depotWnd, WM_COMMAND, ID_POSITIONTOPATTERN, 0);
}
 
BOOL CDeltaTreeCtrl::AnyInDefault()
{
	return GetChildItem(m_MyDefault) ? TRUE : FALSE;
}
 
BOOL CDeltaTreeCtrl::AnyNbredChg()
{
	return GetNextSiblingItem(m_MyDefault) ? TRUE : FALSE;
}
 
void CDeltaTreeCtrl::OnUpdateUserSwitchtouser(CCmdUI* pCmdUI) 
{
	BOOL underMyRoot;
 
	pCmdUI->Enable( !SERVER_BUSY() && GetSelectedCount() == 1
		&& GetItemLevel(GetSelectedItem(0), &underMyRoot) == 1
		&& !IsMyPendingChange( GetSelectedItem(0) )
		&& GetUserFromChange() != GET_P4REGPTR()->GetP4User());	
}
 
void CDeltaTreeCtrl::OnUserSwitchtouser() 
{
	BOOL underMyRoot;
 
	if ( !SERVER_BUSY() && GetSelectedCount() == 1
		&& GetItemLevel(GetSelectedItem(0), &underMyRoot) == 1)
	{
		CString user = GetUserFromChange();
		if (!user.IsEmpty())
		{
			GET_P4REGPTR()->SetP4User(user, TRUE, FALSE, FALSE);
			MainFrame()->OnPerforceOptions(FALSE, FALSE);
		}
	}
}
 
void CDeltaTreeCtrl::OnUpdateClientspecSwitch(CCmdUI* pCmdUI) 
{
	BOOL underMyRoot;
 
	pCmdUI->Enable( !SERVER_BUSY() && GetSelectedCount() == 1
		&& GetItemLevel(GetSelectedItem(0), &underMyRoot) == 1
		&& !underMyRoot);
}
 
void CDeltaTreeCtrl::OnClientspecSwitch() 
{
	BOOL underMyRoot;
 
	if ( !SERVER_BUSY() && GetSelectedCount() == 1
		&& GetItemLevel(GetSelectedItem(0), &underMyRoot) == 1
		&& !underMyRoot)
	{
		CString client = GetClientFromChange();
		if (!client.IsEmpty())
			MainFrame()->ClientSpecSwitch(client);
	}
}
 
CString CDeltaTreeCtrl::GetClientFromChange() 
{
	BOOL underMyRoot;
	TCHAR buf[2050];
	int  i;
 
	if ( GetSelectedCount() == 1
		&& GetItemLevel(GetSelectedItem(0), &underMyRoot) == 1)
	{
		TV_ITEM item;
		item.hItem=GetSelectedItem(0);
		item.mask=TVIF_TEXT;
		item.pszText = buf;
		item.cchTextMax = sizeof(buf)/sizeof(TCHAR)-1;
		if (GetItem(&item ))
		{
			CString txt = buf;
			if ((i = txt.Find(_T('@'))) != -1)
			{
				txt = txt.Right(txt.GetLength() - i - 1);
				if ((i = txt.Find(_T(' '))) != -1)
					txt = txt.Left(i);
				return txt;
			}
		}
	}
	return _T("");
}
 
CString CDeltaTreeCtrl::GetUserFromChange() 
{
	BOOL underMyRoot;
	TCHAR buf[2050];
	int  i;
 
	if ( GetSelectedCount() == 1
		&& GetItemLevel(GetSelectedItem(0), &underMyRoot) == 1)
	{
		TV_ITEM item;
		item.hItem=GetSelectedItem(0);
		item.mask=TVIF_TEXT;
		item.pszText = buf;
		item.cchTextMax = sizeof(buf)/sizeof(TCHAR)-1;
		if (GetItem(&item ))
		{
			CString txt = buf;
			if ((i = txt.Find(_T('@'))) != -1)
			{
				txt = txt.Left(i);
				if ((i = txt.ReverseFind(_T(' '))) != -1)
					txt = txt.Right(txt.GetLength() - i - 1);
				return txt;
			}
		}
	}
	return _T("");
}
 
void CDeltaTreeCtrl::OnUpdateFileInformation(CCmdUI* pCmdUI) 
{
	BOOL root;
	BOOL enable= (!SERVER_BUSY() && GetSelectedCount() == 1 &&
					GetItemLevel(GetSelectedItem(0), &root)== 2 && 
					IsAFile( GetSelectedItem(0)) );
	if( enable )
	{
		CP4FileStats *fs= (CP4FileStats *) GetLParam( GetSelectedItem(0) );
		if( fs->GetHaveRev() <= 1 &&
			( fs->GetMyOpenAction() == F_ADD || fs->GetMyOpenAction() == F_BRANCH ) )
			enable= FALSE;
	}
	pCmdUI->Enable( enable );
}
 
void CDeltaTreeCtrl::OnFileInformation() 
{
	HTREEITEM item=GetLastSelection();
	CString itemStr= GetItemText(item);
	itemStr.TrimRight();
	int pound= itemStr.ReverseFind(_T('#'));
	if(pound == -1)
	{
		ASSERT(0);
		return;
	}
 
	itemStr = itemStr.Left( pound );
 
	m_StringList.RemoveAll();
	m_StringList.AddHead(itemStr);
	
	CCmd_Opened *pCmd= new CCmd_Opened;
	pCmd->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK, 0);
	pCmd->SetAlternateReplyMsg( WM_P4FILEINFORMATION );
 
	if( pCmd->Run( TRUE, FALSE, -1, &m_StringList ) )
		MainFrame()->UpdateStatus( LoadStringResource(IDS_REQUESTING_FILE_INFORMATION) );
	else
		delete pCmd;
}
 
LRESULT CDeltaTreeCtrl::OnP4FileInformation( WPARAM wParam, LPARAM lParam )
{
	CCmd_Opened *pCmd= (CCmd_Opened *) wParam;
	
	m_StringList.RemoveAll();
	if(!pCmd->GetError())
	{
		CString thisuser=GET_P4REGPTR()->GetMyID();
				
		// Initialize the file info dialog
		CFileInfoDlg *dlg = new CFileInfoDlg(this);
 
		CString itemStr = *pCmd->GetDepotPath();
 
		if (itemStr.IsEmpty())
		{
			HTREEITEM item=GetLastSelection();
			itemStr= GetItemText(item);
			itemStr.TrimRight();
			int pound= itemStr.ReverseFind(_T('#'));
			if(pound == -1)
			{
				ASSERT(0);
				return -1;
			}
 
			itemStr = itemStr.Left( pound );
		}
		dlg->m_DepotPath = itemStr;
 
		int key= pCmd->GetServerKey();
		CCmd_Fstat *pCmd2= new CCmd_Fstat;
		
		pCmd2->Init(NULL, RUN_SYNC, HOLD_LOCK, key);
		if ( !PumpMessages( ) )
			goto CantGetFStat;
 
		pCmd2->SetIncludeAddedFiles( TRUE );
		if( pCmd2->Run( FALSE, itemStr, 0 ) && !pCmd2->GetError() )
		{
			CObList *list = pCmd2->GetFileList ( );
			ASSERT_KINDOF( CObList, list );
			ASSERT( list->GetCount() <= 1 );
			POSITION pos = list->GetHeadPosition( );
			if( pos != NULL )
			{
				CP4FileStats *stats = ( CP4FileStats * )list->GetNext( pos );
				ASSERT_KINDOF( CP4FileStats, stats );
				dlg->m_ClientPath = stats->GetFullClientPath( );
				if(dlg->m_ClientPath.GetLength() == 0)
					dlg->m_ClientPath= LoadStringResource(IDS_NOT_IN_CLIENT_VIEW);
				
				dlg->m_HeadRev.Format(_T("%ld"), stats->GetHeadRev());
				dlg->m_HaveRev.Format(_T("%ld"), stats->GetHaveRev());
				
				dlg->m_HeadAction= stats->GetActionStr(stats->GetHeadAction());
				dlg->m_HeadChange.Format(_T("%ld"), stats->GetHeadChangeNum());
				dlg->m_HeadType= stats->GetHeadType();
				dlg->m_ModTime= stats->GetFormattedHeadTime();
				dlg->m_FileSize= stats->GetFileSize();
 
				// Check for open/lock by this user
				if(stats->IsMyLock())
					dlg->m_LockedBy= thisuser;
				
				delete stats;
			}
			else dlg->m_ClientPath= LoadStringResource(IDS_NOT_IN_CLIENT_VIEW);
		}
 
CantGetFStat:
		RELEASE_SERVER_LOCK(key);
		delete pCmd2;
 
		CObList *list= pCmd->GetList();
		ASSERT_KINDOF(CObList, list);
 
        POSITION pos= list->GetHeadPosition();
		while(pos != NULL)
		{
			CP4FileStats *fs= (CP4FileStats *) list->GetNext(pos);
			
			CString str, strUser, strAction;
 
			strUser= fs->GetOtherUsers();
			if( fs->IsMyOpen() && strUser.IsEmpty() )
			{
				strUser= thisuser;
				strAction= fs->GetActionStr(fs->GetMyOpenAction());
			}
			else
				strAction= fs->GetActionStr(fs->GetOtherOpenAction());
 
			if( fs->GetOpenChangeNum() == 0 )
                str.FormatMessage(IDS_CHANGE_DEFAULT_USER_s, strUser);
            else
                str.FormatMessage(IDS_CHANGE_n_USER_s, fs->GetOpenChangeNum(), strUser);
            str +=  _T(" (") + strAction + _T(")");
 
			if( fs->IsOtherLock() )
				str += LoadStringResource(IDS_STAR_LOCKED);
			
			dlg->m_StrList.AddHead( str );
			
			delete fs;
		}
		// Display the info
		if (!dlg->Create(IDD_FILE_INFORMATION, this))	// display the description dialog box
		{
			dlg->DestroyWindow();	// some error! clean up
			delete dlg;
		}
	}
 
	MainFrame()->ClearStatus();
	delete pCmd;
	
	return 0;
}
 
LRESULT CDeltaTreeCtrl::OnP4EndFileInformation( WPARAM wParam, LPARAM lParam )
{
	CFileInfoDlg *dlg = (CFileInfoDlg *)lParam;
	dlg->DestroyWindow();
	return TRUE;
}
 
void CDeltaTreeCtrl::OnSetFlyoverMessage(HTREEITEM currentItem)
{
	if( !GET_P4REGPTR()->ShowClientPath() || GET_SERVERLEVEL() < 19)	// earlier than 2005.1
		return;
 
	ASSERT( currentItem != NULL );
    LPARAM lParam= GetLParam(currentItem);
   
    // Bail out if its a changelist or a job
    if( lParam <= 0 )
    {
        ShowNbrSelected();
    }
    else
    {
		if( IsMyPendingChangeFile( currentItem ) )
		{
			CP4FileStats *fs= (CP4FileStats *) lParam;
			CString msg = fs->GetFullClientPath();
			if (msg.IsEmpty())
			{
				GetClientPath(currentItem, msg);
				fs->SetClientPath(msg);
			}
			if (!msg.IsEmpty())
			{
				CString itemStr = GetItemText(currentItem);
				CString type;
				int		baseType;
				int		storeType;
				BOOL	typeK = FALSE;
				BOOL	typeW = FALSE;
				BOOL	typeX = FALSE;
				BOOL	typeO = FALSE;
				BOOL	typeM = FALSE;
				BOOL	typeL = FALSE;
				BOOL	typeS = FALSE;
				int		nbrrevs = 1;
				BOOL	unknown = FALSE;
 
				// convert the GetItemText() string to 5 flags
				TheApp()->GetFileType(itemStr, baseType, storeType,
											typeK, typeW, typeX, typeO, 
											typeM, typeL, typeS, nbrrevs, unknown);
				// determine the base file type
				switch(baseType)
				{
				case 0:
					type = _T("  <text");
					break;
				case 1:
					type = _T("  <binary");
					break;
				case 2:    
					type = _T("  <symlink");
					break;
				case 3:
					type = _T("  <resource");
					break;
				case 4:
					type = _T("  <apple");
					break;
				case 5:
					type = _T("  <unicode");
					break;
				case 6:
					type = _T("  <utf16");
					break;
				default:
					type = _T("  <unknown");
					break;
				}
				// determine storage type - if it's the default for the base type, do nothing
				switch(storeType)
				{
				case 1:					// +C
					if (baseType != 1)
						type += LoadStringResource(IDS_comma_FULL_COMPRESSED_VERSION_STORED);
					break;
				case 2:					// +D
					if (baseType != 0)
						type += LoadStringResource(IDS_comma_RCS_DELTAS_STORED);
					break;
				case 3:					// +F
					type += LoadStringResource(IDS_comma_FULL_FILE_STORED_PER_REV);
					break;
				default:
					break;
				}
				// Warning: if more of these modifier types are added, we may need to
				// shorten these strings so that all will fit in the status bar window.
				// Already there is a possible overflow if the local path name is long!
				if (typeO)
					type += LoadStringResource(IDS_comma_LIMITED_RCS_KEYWORD_EXPANSION);
				else if (typeK)
					type += LoadStringResource(IDS_comma_RCS_KEYWORD_EXPANSION);
				if (typeW)
					type += LoadStringResource(IDS_comma_ALWAYS_WRITABLE);
				if (typeX)
					type += LoadStringResource(IDS_comma_EXECUTABLE);
				if (typeL)
					type += LoadStringResource(IDS_comma_LOCKED);
				if (typeS)
				{
					if (nbrrevs < 2)
						type += LoadStringResource(IDS_comma_ONLY_HEAD_REV_STORED);
					else
					{
						CString str;
						str.FormatMessage(IDS_comma_ONLY_n_REVS_STORED, nbrrevs);
						type += str;
					}
				}
				if (unknown)
					type += LoadStringResource(IDS_PLUS_UNKNOWN);
				type += _T(">");
				if (type != LoadStringResource(IDS_ONLY_UNKNOWN))
					msg += type;
 
				if (fs->GetMyOpenAction() > 0)
					msg += _T("<") + fs->GetActionStr( fs->GetMyOpenAction() ) + _T(">");
 
				if( fs->IsUnresolved() )
					msg += LoadStringResource(IDS_UNRESOLVED);
				if(fs->IsMyLock())
					msg += LoadStringResource(IDS_LOCKED);
 
				if((fs->GetOtherOpens() > 0) || fs->IsOtherLock())
				{
					msg += LoadStringResource(IDS_OTHERUSER);
					if(fs->GetOtherOpens() > 0)
                    {
                        CString otherAction;
                        otherAction.FormatMessage(IDS_OPENFOR_s, 
							fs->GetActionStr(fs->GetOtherOpenAction()));
						msg += otherAction + _T(" by ") + fs->GetOtherUsers();
                    }
					if(fs->IsOtherLock())
						msg += _T(" ") + LoadStringResource(IDS_LOCKED);
				}
 
				// write the local path and the file type to the status bar
				MainFrame()->SetMessageText(msg);
			}
			else
				MainFrame()->SetMessageText(LoadStringResource(IDS_FILE_NOT_IN_CLIENT_VIEW));
		}
		else
	        MainFrame()->SetMessageText(LoadStringResource(IDS_FOR_HELP_PRESS_F1));
    }
}
 
int CDeltaTreeCtrl::CreateNewChangeList(int key, CString *description/*=NULL*/, BOOL autoOK/*=FALSE*/)
{
	BOOL bReleaseLock;
	if (!key)
	{
		if(SERVER_BUSY() || !GET_SERVER_LOCK(key))
		{
			ASSERT(0);
			return -1;
		}
		bReleaseLock = TRUE;
	}
	else
		bReleaseLock = FALSE;
	m_NewChgNbr = -1;
	m_NewDesc.Empty();
	CCmd_Describe *pCmd = new CCmd_Describe;
	pCmd->Init( NULL, RUN_SYNC, HOLD_LOCK, key );
	BOOL cmdStarted= pCmd->Run( P4CHANGE_SPEC, NULL );
	if(cmdStarted && !pCmd->GetError())
	{
		// if we are passed a description, insert it
		if (description && *description)
		{
			int i;
			CString cmdDesc = pCmd->GetDescription();
			if ((i = cmdDesc.Find(CCmd_EditSpec::g_blankDesc)) != -1)
			{
				cmdDesc = cmdDesc.Left(i) + *description + cmdDesc.Mid(i + lstrlen(CCmd_EditSpec::g_blankDesc));
				pCmd->SetDescription(cmdDesc);
				m_NewDesc = *description;
			}
		}
		// we create a dummy CCmd_EditSpec; it is never run,
		// it just hold the lock's key and receives the new chglist number
		CCmd_EditSpec callingCmd;
		callingCmd.Init( NULL, RUN_SYNC, HOLD_LOCK, key );
		callingCmd.SetSpecIn(pCmd->GetDescription());
		callingCmd.PreprocessChgSpec();
 
		CP4SpecSheet SpecSheet;
		SpecSheet.m_P4SpecDlg.SetCallingCommand(&callingCmd);
		SpecSheet.m_P4SpecDlg.SetSpec(callingCmd.GetSpecIn(), pCmd->GetSpecStr(), 
														P4CHANGE_SPEC, FALSE);
		SpecSheet.m_P4SpecDlg.SetChangeParms(FALSE, FALSE, FALSE, FALSE, FALSE, autoOK);
		if (SpecSheet.DoModal() == IDOK)
		{
			m_NewChgNbr = callingCmd.GetNewChangeNum();
			m_NewDesc   = callingCmd.GetChangeDesc();
		}
		else
		{
			m_NewChgNbr = -1;
			m_NewDesc.Empty();
		}
	}
	delete pCmd;
	if (bReleaseLock)
		RELEASE_SERVER_LOCK(key);
	return m_NewChgNbr;
}
 
void CDeltaTreeCtrl::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
	MainFrame()->WaitAWhileToPoll( );
	CMultiSelTreeCtrl::OnVScroll(nSBCode, nPos, pScrollBar);
}
 
void CDeltaTreeCtrl::OnUpdateViewUpdate(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!SERVER_BUSY() && !MainFrame()->IsModlessUp());
}
 
void CDeltaTreeCtrl::OnViewUpdate() 
{
	// somewhat unexpected maybe, but refreshing the pending changes view
	// actually just sends a request to the depot view for a full refresh
	::PostMessage(m_depotWnd, WM_COMMAND, ID_VIEW_UPDATE_LEFT, 0);
}
 
void CDeltaTreeCtrl::OnPerforceOptions()
{
	MainFrame()->OnPerforceOptions(TRUE, FALSE, IDS_PAGE_CHANGELIST);
}
 
void CDeltaTreeCtrl::OnTheirFindInDepot()
{
	ASSERT(GetSelectedCount() == 1);
	AssembleStringList( );
	CCmd_AutoResolve *pCmd= new CCmd_AutoResolve;
	pCmd->Init( m_hWnd, RUN_ASYNC );
	pCmd->SetAlternateReplyMsg( WM_THEIRFINDINDEPOT );
	if( pCmd->Run( &m_StringList, 0, TRUE, TRUE, FALSE, 0 ) )
		MainFrame()->UpdateStatus( LoadStringResource(IDS_FINDING_THEIR_FILE) );
	else
		delete pCmd;
}
 
LRESULT CDeltaTreeCtrl::OnP4TheirFindInDepot(WPARAM wParam, LPARAM lParam)
{
	CCmd_AutoResolve *pCmd= (CCmd_AutoResolve *) wParam;
 
	if( !pCmd->GetError() && !MainFrame()->IsQuitting() )
	{
		CStringList *list= pCmd->GetList();
		if (list->GetCount())
		{
			int i;
			CString theirStr = list->GetHead();
			if ((i = theirStr.Find( _T(" - vs "))) != -1)
			{
				theirStr = theirStr.Mid(i + sizeof(_T(" - vs "))/sizeof(TCHAR) -1 );
				theirStr.TrimLeft();
				theirStr = theirStr.Left( theirStr.ReverseFind( _T('#') ) );  // trim off rev# info
				MainFrame()->ExpandDepotString( theirStr, TRUE );
			}
		}
	}
	MainFrame()->ClearStatus();
	delete pCmd;
	return 0;
}
 
void CDeltaTreeCtrl::OnTheirHistory()
{
	ASSERT(GetSelectedCount() == 1);
	AssembleStringList( );
	CCmd_AutoResolve *pCmd= new CCmd_AutoResolve;
	pCmd->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK );
	pCmd->SetAlternateReplyMsg( WM_THEIRHISTORY );
	if( pCmd->Run( &m_StringList, 0, TRUE, TRUE, FALSE, 0 ) )
		MainFrame()->UpdateStatus( LoadStringResource(IDS_FINDING_THEIR_FILE) );
	else
		delete pCmd;
}
 
LRESULT CDeltaTreeCtrl::OnP4TheirHistory(WPARAM wParam, LPARAM lParam)
{
	CCmd_AutoResolve *pCmd= (CCmd_AutoResolve *) wParam;
 
	if( !pCmd->GetError() && !MainFrame()->IsQuitting() )
	{
		CStringList *list= pCmd->GetList();
		if (list->GetCount())
		{
			int i;
			int rev = -1;
			CString theirStr = list->GetHead();
			if ((i = theirStr.Find( _T(" - vs "))) != -1)
			{
				theirStr = theirStr.Mid(i + sizeof(_T(" - vs "))/sizeof(TCHAR) -1 );
				theirStr.TrimLeft();
				i = theirStr.Find( _T('#') );
				if (i != -1)
				{
					rev = _ttoi(theirStr.Right(theirStr.GetLength() - i - 1));
					if (!rev)
						rev = -1;
					theirStr = theirStr.Left(i);  // trim off rev# info
				}
				CCmd_History *pCmd2= new CCmd_History;
				pCmd2->Init( m_depotWnd, RUN_ASYNC, LOSE_LOCK, pCmd->GetServerKey());
				pCmd2->SetInitialRev(rev, theirStr);
				pCmd2->SetCallingWnd(m_hWnd);
				if( pCmd2->Run(theirStr) )
				{
					MainFrame()->UpdateStatus( LoadStringResource(IDS_REQUESTING_HISTORY) );
				}
				else
				{
					delete pCmd2;
					pCmd->ReleaseServerLock();
				}
			}
			else
				pCmd->ReleaseServerLock();
		}
		else
			pCmd->ReleaseServerLock();
	}
	else
		pCmd->ReleaseServerLock();
	MainFrame()->ClearStatus();
	delete pCmd;
	return 0;
}
 
void CDeltaTreeCtrl::OnTheirProperties()
{
	ASSERT(GetSelectedCount() == 1);
	AssembleStringList( );
	CCmd_AutoResolve *pCmd= new CCmd_AutoResolve;
	pCmd->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK );
	pCmd->SetAlternateReplyMsg( WM_THEIRPROPERTIES );
	if( pCmd->Run( &m_StringList, 0, TRUE, TRUE, FALSE, 0 ) )
		MainFrame()->UpdateStatus( LoadStringResource(IDS_FINDING_THEIR_FILE) );
	else
		delete pCmd;
}
 
LRESULT CDeltaTreeCtrl::OnP4TheirProperties(WPARAM wParam, LPARAM lParam)
{
	CCmd_AutoResolve *pCmd= (CCmd_AutoResolve *) wParam;
 
	if( !pCmd->GetError() && !MainFrame()->IsQuitting() )
	{
		CStringList *list= pCmd->GetList();
		if (list->GetCount())
		{
			int i;
			CString theirStr = list->GetHead();
			if ((i = theirStr.Find( _T(" - vs "))) != -1)
			{
				theirStr = theirStr.Mid(i + sizeof(_T(" - vs "))/sizeof(TCHAR) -1 );
				theirStr.TrimLeft();
				if ((i = theirStr.Find(_T('#'))) != -1)
					theirStr = theirStr.Left(i);  // trim off rev# info
				m_StringList.RemoveAll();
				m_StringList.AddHead(theirStr);
				
				CCmd_Opened *pCmd2= new CCmd_Opened;
				pCmd2->Init( m_hWnd, RUN_ASYNC, HOLD_LOCK, pCmd->GetServerKey());
				pCmd2->SetAlternateReplyMsg( WM_P4FILEINFORMATION );
				pCmd2->SetDepotPath(theirStr);
				if( pCmd2->Run( TRUE, FALSE, -1, &m_StringList ) )
					MainFrame()->UpdateStatus( LoadStringResource(IDS_REQUESTING_FILE_INFORMATION) );
				else
				{
					delete pCmd2;
					pCmd->ReleaseServerLock();
				}
			}
			else
				pCmd->ReleaseServerLock();
		}
		else
			pCmd->ReleaseServerLock();
	}
	else
		pCmd->ReleaseServerLock();
	MainFrame()->ClearStatus();
	delete pCmd;
	return 0;
}
 
void CDeltaTreeCtrl::CantDoItRightNow(int type)
{
	CString msg;
	msg.FormatMessage(IDS_CANTEDITCHG_INPROGRESS, LoadStringResource(type));
	AddToStatus( msg, SV_WARNING );
}
 
void CDeltaTreeCtrl::OnUpdateSelectChanged(CCmdUI* pCmdUI) 
{
	BOOL selectable=FALSE;
	if( GET_SERVERLEVEL() >= 19 )
	{
		int cnt;
		BOOL underMyRoot;
		HTREEITEM curitem = GetSelectedItem(0);
		if( (cnt = GetSelectedCount()) == 1 && IsMyPendingChange( curitem ))
		{
			selectable=TRUE;
		}
		else if (cnt > 0 && GetItemLevel( curitem, &underMyRoot ) == 2 
			  && underMyRoot && IsAFile( curitem ) )
		{
			selectable=TRUE;
		}
	}
	pCmdUI->Enable( selectable );
}
 
void CDeltaTreeCtrl::OnSelectChanged()
{
	SelectChgUnchg(TRUE);
}
 
void CDeltaTreeCtrl::OnSelectUnchanged()
{
	SelectChgUnchg(FALSE);
}
 
// returns TRUE if any file(s) selected
BOOL CDeltaTreeCtrl::SelectChgUnchg(BOOL bChged, int *totfiles/*=NULL*/)
{
	BOOL b = FALSE;
	if (totfiles)
	   *totfiles = 0;
	BOOL underMyRoot;
	HTREEITEM curitem = GetSelectedItem(0);
	if( GetItemLevel(curitem, &underMyRoot) == 2 && underMyRoot && IsAFile(curitem) )
	{
		UnselectAll();
		SetSelectState( GetParentItem(curitem), TRUE );
	}
	if( GetSelectedCount() == 1 && IsMyPendingChange( GetSelectedItem(0) ) )
	{
		SET_BUSYCURSOR();
		MainFrame()->UpdateStatus(LoadStringResource(IDS_DIFFFILES));
 
		HTREEITEM parent = GetSelectedItem(0);
 
		UnselectAll();
		SetMultiSelect(TRUE);
 
		UINT state= CTreeCtrl::GetItemState( curitem, TVIS_EXPANDED );
		if( (state & TVIS_EXPANDED) != TVIS_EXPANDED )
			CTreeCtrl::Expand( curitem, TVE_EXPAND );
 
		Error e;
		CP4Command *pcmd = new CP4Command;
		CGuiClient *client = pcmd->GetClient();
		client->SetTrans();
		client->Init(&e);
		if( e.Test() )
		{
			delete pcmd;
			return FALSE;
		}
 
		HTREEITEM child= GetChildItem( parent );
		while( child != NULL )
		{
			LPARAM lParam=GetLParam(child);
			if(lParam > 0)
            {
				BOOL chg = FALSE;
				CP4FileStats *stats = (CP4FileStats *) lParam;
				if (stats->GetMyOpenAction() == F_ADD || stats->GetMyOpenAction() == F_BRANCH)
					chg = TRUE;
				else if (!TheApp()->digestIsSame(stats, FALSE, client)
					  || stats->GetType() != stats->GetHeadType())
					chg = TRUE;
				if (chg	== bChged)
				{
					SetSelectState( child, TRUE );
					b = TRUE;
				}
				if (totfiles)
					++*totfiles;
			}
			child= GetNextSiblingItem(child);
		}
		delete pcmd;
		SetMultiSelect(FALSE);
		if (!b)
		{
			if (!totfiles)
				MessageBeep(0);
			SetSelectState( parent, TRUE );
			MainFrame()->SetMessageText(LoadStringResource(bChged ? IDS_NOFILESCHGED : IDS_ALLFILESCHGED));
		}
		else
			ShowNbrSelected();
		SetCursor(LoadCursor(NULL, IDC_ARROW));
	}
	MainFrame()->ClearStatus();
	return b;
}
 
LRESULT CDeltaTreeCtrl::CallOnUpdateFilterClearview(WPARAM wParam, LPARAM lParam)
{
	OnUpdateFilterClearview((CCmdUI *)lParam);
	return 0;
}
 
void CDeltaTreeCtrl::OnUpdateFilterClearview(CCmdUI* pCmdUI) 
{
	pCmdUI->SetText(LoadStringResource(IDS_FILTER_PCO_CLEARVIEW));
	pCmdUI->Enable(MainFrame()->SetMenuIcon(pCmdUI, !SERVER_BUSY() && 
		GET_P4REGPTR()->GetEnablePendingChgsOtherClients() &&
		(GET_P4REGPTR()->FilterPendChgsByMyClient()
//		|| m_FilteredByClient || m_FilteredByUser
		)));
}
 
void CDeltaTreeCtrl::OnUpdateFilterSetview(CCmdUI* pCmdUI) 
{
	pCmdUI->SetText(LoadStringResource(IDS_FILTER_PCO_SETVIEW));
	pCmdUI->Enable( MainFrame()->SetMenuIcon(pCmdUI, !SERVER_BUSY()) && 
		GET_P4REGPTR()->GetEnablePendingChgsOtherClients());
}
 
void CDeltaTreeCtrl::OnFilterSetview()
{
	COldChgFilterDlg dlg;
 
	// initialize filter vars
//	dlg.m_useClient = m_FilteredByClient;
//	dlg.m_client = m_ClientFilter;
//	dlg.m_useUser = m_FilteredByUser;
//	dlg.m_user = m_UserFilter;
	dlg.m_includeIntegrations = FALSE;
	dlg.m_bPending = TRUE;
 
	// get selected files from depot view and convert to string
	CStringList selected;
    ::SendMessage(m_depotWnd, WM_GETSELLIST, (WPARAM) &selected, 0);
	CString selectedTxt;
	POSITION pos = selected.GetHeadPosition();
	int i;
	for(i=0; pos != NULL; i++)
	{
		CString sel = selected.GetNext(pos);
		selectedTxt += sel + _T(" ");
		dlg.m_selected.AddTail(sel);
	}
	selectedTxt.TrimRight();
	dlg.m_selectedFiles = selectedTxt;
 
	// make a radio button selection based on various strings
	i = GET_P4REGPTR()->FilterPendChgsByMyClient();
	if (i == 0)
		dlg.m_filterFiles = 0;
	else if (i == 1)
		dlg.m_filterFiles = 1;
	else
	{
		CString currentTxt = GET_P4REGPTR()->FilterPendChgsByPath();
		if(currentTxt.IsEmpty() || (GET_SERVERLEVEL() < 21))
			dlg.m_filterFiles = 0;
		else
		{
			if(currentTxt == selectedTxt)
				dlg.m_filterFiles = 3;
			else
				dlg.m_filterFiles = 2;
		}
	}
 
	if(dlg.DoModal() == IDCANCEL)
		return;
 
#if 0
	// get client and user filter settings
	m_FilteredByClient = dlg.m_useClient;
	GET_P4REGPTR()->SetFilteredByClient(m_FilteredByClient);
	if(m_FilteredByClient)
	{
        m_ClientFilter = dlg.m_client;
		GET_P4REGPTR()->SetClientFilter(m_ClientFilter);
	}
 
	m_FilteredByUser = dlg.m_useUser;
	GET_P4REGPTR()->SetFilteredByUser(m_FilteredByUser);
	if(m_FilteredByUser)
	{
		m_UserFilter = dlg.m_user;
		GET_P4REGPTR()->SetUserFilter(m_UserFilter);
	}
#endif
 
	// get the filter view
	switch(dlg.m_filterFiles)
	{
	case 0:	// all files
		GET_P4REGPTR()->SetFilterPendChgsByMyClient(0);
		break;
	case 1:	// my client files
		GET_P4REGPTR()->SetFilterPendChgsByMyClient(1);
		break;
	case 2:	// filespec
	 {
		// convert filespec into view stringlist
		CString filespec = dlg.m_filespec;
		if (!filespec.IsEmpty())
		{
			GET_P4REGPTR()->SetFilterPendChgsByMyClient(2);
			GET_P4REGPTR()->SetFilterPendChgsByPath(filespec);
			GET_P4REGPTR()->AddMRUChgFilter( filespec );	// save as most recently used in Reg
		}
		break;
	 }
	case 3:	// selected files
	  {
		CString filterView;
		POSITION pos = selected.GetHeadPosition();
		while (pos != NULL)
		{
			CString str = selected.GetNext(pos);
			if (dlg.m_UseClientSyntax)
			{
				// user wants to convert to client syntax
				CCmd_Where *pCmd1 = new CCmd_Where;
				pCmd1->Init(NULL, RUN_SYNC);
				if ( pCmd1->Run(str) && !pCmd1->GetError() 
				  && pCmd1->GetClientFiles()->GetCount() )
				{
					CStringList * list = pCmd1->GetClientFiles();
					POSITION pos2 = list->GetHeadPosition();
					while (pos2 != NULL)
						filterView += list->GetNext(pos2) + _T(' ');
				}
				else	// p4 where failed - use depot syntax after all
					filterView += str + _T(' ');
				delete pCmd1;
			}
			else
				filterView += str + _T(' ');
		}
		filterView.TrimRight();
		if (!filterView.IsEmpty())
		{
			GET_P4REGPTR()->SetFilterPendChgsByMyClient(2);
			GET_P4REGPTR()->SetFilterPendChgsByPath(filterView);
			GET_P4REGPTR()->AddMRUChgFilter( filterView );	// save as most recently used in Reg
		}
		break;
	  }
	}
	OnViewUpdate();
}
 
void CDeltaTreeCtrl::OnFilterClearview()
{
	GET_P4REGPTR()->SetFilterPendChgsByMyClient(0);
	OnViewUpdate();
}
 
void CDeltaTreeCtrl::OnUpdateAddBookmark(CCmdUI* pCmdUI) 
{
	BOOL root;
	BOOL rc = FALSE;
	if (!SERVER_BUSY() && GetSelectedCount() == 1)
	{
		HTREEITEM item;
		if (GetItemLevel((item = GetSelectedItem(0)), &root) == 2 && IsAFile(item))
			rc = TRUE;
	}
	pCmdUI->Enable(rc);
}
 
void CDeltaTreeCtrl::OnAddBookmark() 
{
	BOOL root;
	HTREEITEM item;
 
	if (GetSelectedCount() != 1
	 || GetItemLevel((item = GetSelectedItem(0)), &root) != 2 
	 || !IsAFile(item))
	{
		ASSERT(0);
		return;
	}
	int j;
	CString txt = GetItemText(item);
	if (txt.GetAt(0) == _T('/') && ((j = txt.ReverseFind(_T('#'))) != -1))
		txt = txt.Left(j);
	::SendMessage(m_depotWnd, WM_ADDBOOKMARK, 0, (LPARAM)(&txt));
}