Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

739 lines
20 KiB

/*****************************************************************************
*
* opened.cpp
*
* View the list of opened files and pending changes.
*
*****************************************************************************/
#include "sdview.h"
/*****************************************************************************
*
* OpenedEntry
*
* We list the changes in descending numerical order, except that
* "default" goes at the top of the list (rather than at the bottom,
* which is what StrToInt would've given us).
*
*****************************************************************************/
MakeStringFormat(ChangeList)
MakeStringFormat(PendingOp)
class OpenedEntry : public TreeItem {
public:
OpenedEntry(ChangeList clChange, LPCTSTR pszComment);
OpenedEntry(PendingOp opOp, LPCTSTR pszFile);
OpenedEntry() { }
void SetComment(LPCTSTR pszComment) { _scComment = pszComment; }
void SetFullDescription(LPCTSTR pszFullDescription) { _scFullDescription = pszFullDescription; }
LRESULT GetDispInfo(NMTREELIST *pdi, int iColumn);
LRESULT GetInfoTip(NMTREELIST *pdi);
LPCTSTR GetChange() const { return _scChange; }
LPCTSTR GetComment() const { return _scComment; }
int GetOp() const { return _iOp; }
UINT GetSortKey() const { return _uiSort; }
BOOL IsAddLike() const { return _iOp == OP_ADD || _iOp == OP_BRANCH; }
BOOL IsDelLike() const { return _iOp == OP_DELETE; }
BOOL HasComment() const { return !_scComment.IsEmpty(); }
static UINT ComputeSortKey(LPCTSTR pszChange)
{ return (UINT)StrToInt(pszChange) - 1; }
static UINT SortKey_DefaultChange() { return (UINT)0-1; }
private:
void GetImage(NMTREELIST *ptl);
private:
UINT _uiSort; // Sort key
int _iOp; // Checkin operation
StringCache _scChange; // Change number or operation
StringCache _scComment; // Checkin comment or path
StringCache _scFullDescription; // Full checkin description
};
OpenedEntry::OpenedEntry(ChangeList clChange, LPCTSTR pszComment)
: _scChange(clChange)
, _uiSort(ComputeSortKey(clChange))
, _iOp(OP_EDIT)
, _scComment(pszComment)
{
}
OpenedEntry::OpenedEntry(PendingOp opOp, LPCTSTR pszComment)
: _scChange(opOp)
, _iOp(ParseOp(opOp))
, _scComment(pszComment)
{
}
void OpenedEntry::GetImage(NMTREELIST *ptl)
{
if (_iOp > 0) {
ptl->iSubItem = c_rgleim[_iOp]._iImage;
} else {
ptl->iSubItem = 0;
}
}
LRESULT OpenedEntry::GetDispInfo(NMTREELIST *ptl, int iColumn)
{
switch (iColumn) {
case -1: GetImage(ptl); break;
case 0: ptl->pszText = _scChange; break;
case 1: ptl->pszText = _scComment; break;
}
return 0;
}
LRESULT OpenedEntry::GetInfoTip(NMTREELIST *ptl)
{
ptl->pszText = _scFullDescription;
return 0;
}
/*****************************************************************************
*
* class COpened
*
*****************************************************************************/
class COpened : public TLFrame, public BGTask {
friend DWORD CALLBACK COpened_ThreadProc(LPVOID lpParameter);
protected:
LRESULT HandleMessage(UINT uiMsg, WPARAM wParam, LPARAM lParam);
private:
enum {
OM_INITIALIZED = WM_APP
};
typedef TLFrame super;
LRESULT ON_WM_CREATE(UINT uiMsg, WPARAM wParam, LPARAM lParam);
LRESULT ON_WM_SETCURSOR(UINT uiMsg, WPARAM wParam, LPARAM lParam);
LRESULT ON_WM_COMMAND(UINT uiMsg, WPARAM wParam, LPARAM lParam);
LRESULT ON_WM_INITMENU(UINT uiMsg, WPARAM wParam, LPARAM lParam);
LRESULT ON_WM_NOTIFY(UINT uiMsg, WPARAM wParam, LPARAM lParam);
LRESULT ON_OM_INITIALIZED(UINT uiMsg, WPARAM wParam, LPARAM lParam);
private: /* Helpers */
COpened() : TLFrame(new OpenedEntry)
{
SetAcceleratorTable(MAKEINTRESOURCE(IDA_OPENED));
}
OpenedEntry *OEGetCurSel() { return SAFECAST(OpenedEntry*, TLGetCurSel()); }
LRESULT _FillChildren(OpenedEntry *pleRoot, LPCTSTR pszRootPath);
LRESULT _OnItemActivate(OpenedEntry *ple);
LRESULT _OnGetContextMenu(OpenedEntry *ple);
BOOL _IsViewFileLogEnabled(OpenedEntry *ple);
LRESULT _ViewFileLog(OpenedEntry *ple);
void _AdjustMenu(HMENU hmenu, OpenedEntry *ple, BOOL fContextMenu);
int _GetChangeNumber(OpenedEntry *ple);
int _GetBugNumber(OpenedEntry *ple);
static DWORD CALLBACK s_BGInvoke(LPVOID lpParam);
DWORD _BGInvoke();
LPCTSTR _BGParse(StringCache *pscUser);
void _BGGetChanges(LPCTSTR pszUser);
void _BGFillInChanges();
OpenedEntry *_BGFindChange(LPCTSTR pszChange, BOOL fCreate);
void _BGGetOpened(LPCTSTR pszArgs, LPCTSTR pszUser);
BOOL _IsChangeHeader(OpenedEntry *ple)
{ return ple && ple->Parent() == _tree.GetRoot(); }
BOOL _IsChangeFile(OpenedEntry *ple)
{ return ple && ple->Parent() != _tree.GetRoot(); }
private:
};
LRESULT COpened::ON_WM_CREATE(UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
LRESULT lres;
static const LVFCOLUMN c_rgcol[] = {
{ 15 ,IDS_COL_CHANGE ,LVCFMT_LEFT },
{ 60 ,IDS_COL_COMMENT ,LVCFMT_LEFT },
{ 0 ,0 ,0 },
};
lres = super::HandleMessage(uiMsg, wParam, lParam);
if (lres == 0 &&
_tree.GetRoot() &&
SetWindowMenu(MAKEINTRESOURCE(IDM_OPENED)) &&
CreateChild(LVS_REPORT | LVS_SINGLESEL | LVS_SHOWSELALWAYS |
LVS_NOSORTHEADER,
LVS_EX_LABELTIP | LVS_EX_HEADERDRAGDROP |
LVS_EX_INFOTIP | LVS_EX_FULLROWSELECT) &&
AddColumns(c_rgcol) &&
BGStartTask(s_BGInvoke, this)) {
SetWindowText(_hwnd, TEXT("sdv opened"));
} else {
lres = -1;
}
return lres;
}
int COpened::_GetBugNumber(OpenedEntry *ple)
{
if (_IsChangeFile(ple)) {
ple = SAFECAST(OpenedEntry *, ple->Parent());
}
if (ple) {
return ParseBugNumber(ple->GetComment());
} else {
return 0;
}
}
int COpened::_GetChangeNumber(OpenedEntry *ple)
{
if (_IsChangeFile(ple)) {
ple = SAFECAST(OpenedEntry *, ple->Parent());
}
if (ple) {
return StrToInt(ple->GetChange());
} else {
return 0;
}
}
BOOL COpened::_IsViewFileLogEnabled(OpenedEntry *ple)
{
if (!_IsChangeFile(ple)) {
return FALSE; // not even a file!
}
//
// Some of the ops create files so there's nothing to see.
//
if (ple->IsAddLike()) {
return FALSE;
}
return TRUE;
}
LRESULT COpened::_ViewFileLog(OpenedEntry *poe)
{
if (!_IsViewFileLogEnabled(poe)) {
return 0;
}
Substring ss;
if (Parse(TEXT("$P"), poe->GetComment(), &ss)) {
String str;
str << TEXT("-#") << ss._pszMax << TEXT(" ") << ss;
LaunchThreadTask(CFileLog_ThreadProc, str);
}
return 0;
}
LRESULT COpened::ON_WM_SETCURSOR(UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
return BGFilterSetCursor(super::HandleMessage(uiMsg, wParam, lParam));
}
LRESULT COpened::ON_WM_COMMAND(UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
int iChange, iBug;
switch (GET_WM_COMMAND_ID(wParam, lParam)) {
case IDM_VIEWFILEDIFF:
return _OnItemActivate(OEGetCurSel());
case IDM_VIEWBUG:
iBug = _GetBugNumber(OEGetCurSel());
if (iBug) {
OpenBugWindow(_hwnd, iBug);
}
break;
case IDM_VIEWFILELOG:
_ViewFileLog(OEGetCurSel());
break;
}
return super::HandleMessage(uiMsg, wParam, lParam);
}
void COpened::_AdjustMenu(HMENU hmenu, OpenedEntry *ple, BOOL fContextMenu)
{
AdjustBugMenu(hmenu, _GetBugNumber(ple), fContextMenu);
BOOL fEnable = _IsViewFileLogEnabled(ple);
EnableDisableOrRemoveMenuItem(hmenu, IDM_VIEWFILELOG, fEnable, fContextMenu);
fEnable = _IsChangeFile(ple);
EnableDisableOrRemoveMenuItem(hmenu, IDM_VIEWFILEDIFF, fEnable, fContextMenu);
MakeMenuPretty(hmenu);
}
LRESULT COpened::ON_WM_INITMENU(UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
_AdjustMenu(RECAST(HMENU, wParam), OEGetCurSel(), FALSE);
return 0;
}
LRESULT COpened::_OnGetContextMenu(OpenedEntry *ple)
{
HMENU hmenu = LoadPopupMenu(MAKEINTRESOURCE(IDM_OPENED_POPUP));
if (hmenu) {
_AdjustMenu(hmenu, ple, TRUE);
}
return RECAST(LRESULT, hmenu);
}
LRESULT COpened::_OnItemActivate(OpenedEntry *ple)
{
if (_IsChangeFile(ple)) {
//
// Map the full depot path to a local file so we can pass it
// to windiff. We can't use "sd diff" because that will fail
// on a borrowed enlistment.
//
String strLocal;
if (MapToLocalPath(ple->GetComment(), strLocal)) {
Substring ss;
if (Parse(TEXT("$p"), strLocal, &ss)) {
String str;
str << TEXT("windiff ");
if (ple->IsAddLike()) {
str << TEXT("nul ");
} else {
str << QuoteSpaces(ple->GetComment());
}
str << TEXT(" ");
if (ple->IsDelLike()) {
str << TEXT("nul ");
} else {
str << QuoteSpaces(ss.Finalize());
}
SpawnProcess(str);
}
}
}
return 0;
}
LRESULT COpened::ON_WM_NOTIFY(UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
NMTREELIST *ptl = RECAST(NMTREELIST*, lParam);
OpenedEntry *ple;
switch (ptl->hdr.code) {
case TLN_GETDISPINFO:
ple = SAFECAST(OpenedEntry*, ptl->pti);
if (ptl->iSubItem < 0) {
return ple->GetDispInfo(ptl, ptl->iSubItem);
} else if (ptl->iSubItem < 2) {
return ple->GetDispInfo(ptl, ptl->iSubItem);
} else {
ASSERT(0); // invalid column
return 0;
}
case TLN_ITEMACTIVATE:
ple = SAFECAST(OpenedEntry*, ptl->pti);
return _OnItemActivate(ple);
case TLN_GETINFOTIP:
ple = SAFECAST(OpenedEntry*, ptl->pti);
return ple->GetInfoTip(ptl);
case TLN_DELETEITEM:
ple = SAFECAST(OpenedEntry*, ptl->pti);
delete ple;
return 0;
case TLN_GETCONTEXTMENU:
ple = SAFECAST(OpenedEntry*, ptl->pti);
return _OnGetContextMenu(ple);
}
return super::HandleMessage(uiMsg, wParam, lParam);
}
LRESULT COpened::ON_OM_INITIALIZED(UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
_tree.Expand(_tree.GetRoot());
//
// Also expand the first changelist since it's usually what
// you are interested in.
//
TreeItem *pti = _tree.GetRoot()->FirstChild();
if (pti) {
_tree.Expand(pti);
}
return 0;
}
LRESULT
COpened::HandleMessage(UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
switch (uiMsg) {
FW_MSG(WM_CREATE);
FW_MSG(WM_SETCURSOR);
FW_MSG(WM_COMMAND);
FW_MSG(WM_INITMENU);
FW_MSG(WM_NOTIFY);
FW_MSG(OM_INITIALIZED);
}
return super::HandleMessage(uiMsg, wParam, lParam);
}
//
// A private helper class that captures the parsing state machine.
//
class PendingChangesParseState
{
public:
PendingChangesParseState() : _poeCurrent(NULL), _poeInsertAfter(NULL) { }
OpenedEntry *GetCurrent() const { return _poeCurrent; }
void Flush(Tree& tree)
{
if (_poeCurrent) {
//
// Trim the trailing CRLF off the last line of the full
// description.
//
_strFullDescription.Chomp();
_poeCurrent->SetFullDescription(_strFullDescription);
tree.RedrawItem(_poeCurrent);
_poeCurrent = NULL;
}
_fHaveComment = FALSE;
_strFullDescription.Reset();
}
void AddEntry(Tree &tree, String& str, Substring *rgss)
{
OpenedEntry *poe = new OpenedEntry(ChangeList(rgss[0].Finalize()), // Change
NULL); // Comment
if (poe) {
if (tree.Insert(poe, tree.GetRoot(), _poeInsertAfter)) {
_poeInsertAfter = _poeCurrent = poe;
} else {
delete poe;
}
}
}
void SetEntry(OpenedEntry *poe)
{
_poeCurrent = poe;
}
void AddLine(const String& str)
{
_strFullDescription << str;
}
//
// We cannot use the CommentParser because we don't have a Dev
// column; besides, we don't want to handle proxy checkins here.
// Show the real unfiltered checkin comment.
//
void AddComment(LPTSTR psz)
{
if (_fHaveComment) return;
if (!_poeCurrent) return;
//
// Ignore leading spaces.
//
while (*psz == TEXT('\t') || *psz == TEXT(' ')) psz++;
//
// Skip blank description lines.
//
if (*psz == TEXT('\0')) return;
//
// Use the first nonblank comment line as the text and toss the rest.
//
// Change all tabs to spaces because listview doesn't like tabs.
//
ChangeTabsToSpaces(psz);
_poeCurrent->SetComment(psz);
_fHaveComment = TRUE;
}
private:
BOOL _fHaveComment;
OpenedEntry*_poeCurrent;
OpenedEntry*_poeInsertAfter;
String _strFullDescription;
};
DWORD CALLBACK COpened::s_BGInvoke(LPVOID lpParam)
{
COpened *self = RECAST(COpened *, lpParam);
return self->_BGInvoke();
}
//
// Returns unparsed string (or NULL)
// and puts user name in pscUser.
//
//
LPCTSTR COpened::_BGParse(StringCache *pscUser)
{
/*
* Parse the switches as best we can.
*
*/
GetOpt opt(TEXT("u"), _pszQuery);
for (;;) {
switch (opt.NextSwitch()) {
case TEXT('u'):
*pscUser = opt.GetValue();
break;
case TEXT('\0'):
goto L_switch; // two-level break
default:
// Caller will display help for us
return NULL;
}
}
L_switch:;
if (pscUser->IsEmpty()) {
*pscUser = GlobalSettings.GetUserName();
}
String str;
str << TEXT("sdv opened -u ") << *pscUser;
SetWindowText(_hwnd, str);
/*
* The rest goes to "sd opened".
*/
return opt.GetTokenizer().Unparsed();
}
void COpened::_BGGetChanges(LPCTSTR pszUser)
{
LPCTSTR pszClient = GlobalSettings.GetClientName();
UINT cchClient = lstrlen(pszClient);
String str;
str << TEXT("changes -l -s pending");
if (GlobalSettings.IsVersion(1, 60)) {
str << TEXT(" -u ") << QuoteSpaces(pszUser);
}
SDChildProcess proc(str);
IOBuffer buf(proc.Handle());
PendingChangesParseState state;
while (buf.NextLine(str)) {
Substring rgss[4]; // changeno, date, domain\userid, client
if (Parse(TEXT("Change $d on $D by $u@$w"), str, rgss)) {
state.Flush(_tree);
if (rgss[3].Length() == cchClient &&
StrCmpNI(rgss[3].Start(), pszClient, cchClient) == 0) {
state.AddLine(str);
state.AddEntry(_tree, str, rgss);
}
} else if (state.GetCurrent()) {
state.AddLine(str);
if (str[0] == TEXT('\t')) {
str.Chomp();
state.AddComment(str);
}
}
}
state.Flush(_tree);
}
OpenedEntry *COpened::_BGFindChange(LPCTSTR pszChange, BOOL fCreate)
{
UINT uiKey = OpenedEntry::ComputeSortKey(pszChange);
OpenedEntry *poeInsertAfter = NULL;
OpenedEntry *poe = SAFECAST(OpenedEntry *, _tree.GetRoot()->FirstChild());
if (poe == PTI_ONDEMAND) {
poe = NULL;
}
while (poe) {
if (poe->GetSortKey() == uiKey) {
return poe;
}
if (poe->GetSortKey() < uiKey) {
break;
}
poeInsertAfter = poe;
poe = SAFECAST(OpenedEntry *, poe->NextSibling());
}
//
// Create it if necessary. (We always create "default".)
//
if (fCreate || StrCmp(pszChange, TEXT("default")) == 0) {
poe = new OpenedEntry(ChangeList(pszChange), NULL);
if (poe) {
if (_tree.Insert(poe, _tree.GetRoot(), poeInsertAfter)) {
return poe;
}
delete poe;
}
}
return NULL;
}
void COpened::_BGGetOpened(LPCTSTR pszArgs, LPCTSTR pszUser)
{
String str, strOrig;
str << TEXT("opened ") << pszArgs;
SDChildProcess proc(str);
IOBuffer buf(proc.Handle());
while (buf.NextLine(str)) {
Substring rgss[6]; // path, version, op, changeno, type, user
LPTSTR pszRest = Parse(TEXT("$P#$d - $w "), str, rgss);
if (pszRest) {
strOrig = str;
rgss[1].Finalize(); // End of revision (path#version)
//
// Parsing is such sweet sorrow.
//
// "default change" but "change 1234".
//
LPTSTR pszRest2;
if ((pszRest2 = Parse(TEXT("change $d $w"), pszRest, &rgss[3])) ||
(pszRest2 = Parse(TEXT("$w change $w"), pszRest, &rgss[3]))) {
*pszRest2++ = TEXT('\0'); // relies on the fact that we didn't chomp
if (Parse(TEXT("by $p"), pszRest2, &rgss[5])) {
// Some nondefault user, how about that
rgss[5].Finalize();
} else {
// Default user
rgss[5].SetStart(GlobalSettings.GetUserName());
}
if (lstrcmpi(rgss[5].Start(), pszUser) == 0) {
OpenedEntry *poeParent = _BGFindChange(rgss[3].Finalize(), pszArgs[0]);
if (poeParent) {
OpenedEntry *poe = new OpenedEntry(PendingOp(rgss[2].Finalize()),
rgss[0].Start());
if (poe) {
if (_tree.Insert(poe, poeParent, PTI_APPEND)) {
strOrig.Chomp();
poe->SetFullDescription(strOrig);
} else {
delete poe;
}
}
}
}
}
}
}
}
void COpened::_BGFillInChanges()
{
String str;
str << TEXT("describe -s ");
BOOL fAnyChanges = FALSE;
OpenedEntry *poe = SAFECAST(OpenedEntry *, _tree.GetRoot()->FirstChild());
if (poe == PTI_ONDEMAND) {
poe = NULL;
}
while (poe) {
if (poe->GetSortKey() != OpenedEntry::SortKey_DefaultChange() &&
!poe->HasComment()) {
str << poe->GetChange() << TEXT(" ");
fAnyChanges = TRUE;
}
poe = SAFECAST(OpenedEntry *, poe->NextSibling());
}
if (fAnyChanges) {
SDChildProcess proc(str);
IOBuffer buf(proc.Handle());
PendingChangesParseState state;
while (buf.NextLine(str)) {
Substring rgss[4]; // changeno, domain\userid, client, date
if (Parse(TEXT("Change $d by $u@$w on $D"), str, rgss)) {
state.Flush(_tree);
state.AddLine(str);
OpenedEntry *poe = _BGFindChange(rgss[0].Finalize(), FALSE);
state.SetEntry(poe);
} else if (state.GetCurrent()) {
if (str[0] == TEXT('A')) { // "Affected files"
state.Flush(_tree);
} else {
state.AddLine(str);
if (str[0] == TEXT('\t')) {
str.Chomp();
state.AddComment(str);
}
}
}
}
state.Flush(_tree);
}
}
DWORD COpened::_BGInvoke()
{
StringCache scUser;
LPCTSTR pszUnparsed = _BGParse(&scUser);
if (pszUnparsed) {
// If no parameters, then go hunt down all the changelists
// so we can find the empty ones, too. Otherwise, we will
// figure them out as we see the results of "sd opened".
if (!*pszUnparsed) {
_BGGetChanges(scUser);
}
_BGGetOpened(pszUnparsed, scUser);
PostMessage(_hwnd, OM_INITIALIZED, 0, 0);
_BGFillInChanges();
} else {
Help(_hwnd, TEXT("#opene"));
PostMessage(_hwnd, WM_CLOSE, 0, 0);
}
BGEndTask();
return 0;
}
DWORD CALLBACK COpened_ThreadProc(LPVOID lpParameter)
{
return FrameWindow::RunThread(new COpened, lpParameter);
}