windows-nt/Source/XPSP1/NT/sdktools/sdv/opened.cpp

/*****************************************************************************
 *
 *  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);
}