windows-xp/Source/XPSP1/NT/shell/ext/cscui/statdlg.cpp

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) Microsoft Corporation, 1997 - 1999
//
//  File:       statdlg.cpp
//
//--------------------------------------------------------------------------

#include "pch.h"
#pragma hdrstop

#include "statdlg.h"
#include "resource.h"
#include "folder.h"
#include "cscst.h"
#include "options.h"
#include "fopendlg.h"
#include "msgbox.h"
#include "strings.h"

// Global used for IsDialogMessage processing
HWND g_hwndStatusDlg = NULL;

CStatusDlg::CStatusDlg(
    HINSTANCE hInstance,
    LPCTSTR pszText,
    eSysTrayState eState,
    Modes mode            // Optional.  Default is MODE_NORMAL
    ) : m_hInstance(hInstance),
        m_hwndDlg(NULL),
        m_hwndLV(NULL),
        m_himl(NULL),
        m_mode(mode),
        m_bExpanded(true),
        m_bSortAscending(true),
        m_iLastColSorted(-1),
        m_eSysTrayState(eState),
        m_cyExpanded(0),
        m_pszText(StrDup(pszText)) 
{ 

}

CStatusDlg::~CStatusDlg(
    void
    ) 
{ 
    if (NULL != m_pszText)
    {
        LocalFree(m_pszText);
    }
}

int
CStatusDlg::Create(
    HWND hwndParent,
    LPCTSTR pszText,
    eSysTrayState eState,
    Modes mode
    )
{
    int iResult = 0;
    CStatusDlg *pdlg = new CStatusDlg(g_hInstance, pszText, eState, mode);
    if (pdlg)
    {
        iResult = pdlg->Run(hwndParent);
        if (!iResult)
            delete pdlg;
        // else pdlg is automatically deleted when the dialog is closed
    }
    return iResult;
}

//
// Run the status dialog as a modeless dialog.
// Activates an existing instance if one is available.
//
int
CStatusDlg::Run(
    HWND hwndParent
    )
{
    //
    // First activate an existing instance if one is already running.
    //
    int iResult = 0;
    TCHAR szDlgTitle[MAX_PATH];
    LoadString(m_hInstance, IDS_STATUSDLG_TITLE, szDlgTitle, ARRAYSIZE(szDlgTitle));

    m_hwndDlg = FindWindow(NULL, szDlgTitle);
    if (NULL != m_hwndDlg && IsWindow(m_hwndDlg) && IsWindowVisible(m_hwndDlg))
    {
        SetForegroundWindow(m_hwndDlg);
    }
    else
    {
        //
        // Otherwise create a new dialog.
        // We need to use CreateDialog rather than DialogBox because
        // sometimes the dialog is hidden.  DialogBox doesn't allow us to
        // change the visibility attributed defined in the dialog template.
        //
        m_hwndDlg = CreateDialogParam(m_hInstance,
                                      MAKEINTRESOURCE(IDD_CSCUI_STATUS),
                                      hwndParent,
                                      DlgProc,
                                      (LPARAM)this);
        if (NULL != m_hwndDlg)
        {
            MSG msg;

            ShowWindow(m_hwndDlg, MODE_NORMAL == m_mode ? SW_NORMAL : SW_HIDE);
            UpdateWindow(m_hwndDlg);

            // We don't need a message loop here. We're on systray's main
            // thread which has a message pump.

            iResult = 1;
        }
    }
    g_hwndStatusDlg = m_hwndDlg;
    return iResult;
}



void
CStatusDlg::Destroy(
    void
    )
{
    if (NULL != m_hwndDlg)
        DestroyWindow(m_hwndDlg);
    g_hwndStatusDlg = NULL;
}



INT_PTR CALLBACK 
CStatusDlg::DlgProc(
    HWND hwnd, 
    UINT uMsg, 
    WPARAM wParam, 
    LPARAM lParam
    )
{
    CStatusDlg *pThis = (CStatusDlg *)GetWindowLongPtr(hwnd, DWLP_USER);

    BOOL bResult = FALSE;
    switch(uMsg)
    {
        case WM_INITDIALOG:
        {
            pThis = (CStatusDlg *)lParam;
            SetWindowLongPtr(hwnd, DWLP_USER, (LONG_PTR)pThis);
            pThis->m_hwndDlg = hwnd;
            bResult = pThis->OnInitDialog(wParam, lParam);
            break;
        }

        case WM_COMMAND:
            if (NULL != pThis)
                bResult = pThis->OnCommand(wParam, lParam);
            break;

        case WM_NOTIFY:
            bResult = pThis->OnNotify(wParam, lParam);
            break;

        case WM_DESTROY:
            pThis->OnDestroy();
            break;
    }
    return bResult;
}


//
// WM_INITDIALOG handler.
//
BOOL
CStatusDlg::OnInitDialog(
    WPARAM wParam,
    LPARAM lParam
    )
{
    TCHAR szScratch[MAX_PATH];
    BOOL bResult = TRUE;
    RECT rcExpanded;
    CConfig& config = CConfig::GetSingleton();

    m_hwndLV = GetDlgItem(m_hwndDlg, IDC_LV_STATUSDLG);
    //
    // Center the dialog on the desktop before contraction.
    //
    CenterWindow(m_hwndDlg, GetDesktopWindow());
    //
    // Start with the dialog not expanded.
    //
    GetWindowRect(m_hwndDlg, &rcExpanded);
    m_cyExpanded = rcExpanded.bottom - rcExpanded.top;
    //
    // Set the cached "expanded" member to be the opposite of the user's
    // preference for expansion.  ExpandDialog will only change the
    // expanded state if it's different from the current state.
    //
    m_bExpanded = !UserLikesDialogExpanded();
    ExpandDialog(!m_bExpanded);
    //
    // Disable buttons as necessary.
    //
    if (config.NoCacheViewer())
        EnableWindow(GetDlgItem(m_hwndDlg, IDC_BTN_VIEWFILES), FALSE);
    if (config.NoConfigCache())
        EnableWindow(GetDlgItem(m_hwndDlg, IDC_BTN_SETTINGS), FALSE);
    //
    // Initialize the message text.
    //
    SetWindowText(GetDlgItem(m_hwndDlg, IDC_TXT_STATUSDLG), m_pszText ? m_pszText : TEXT(""));
    //
    // Turn on checkboxes for column 0.
    //
    EnableListviewCheckboxes(true);
    //
    // Create the imagelist.
    //
    m_himl = CreateImageList();
    if (NULL != m_himl)
        ListView_SetImageList(m_hwndLV, m_himl, LVSIL_SMALL);
    //
    // Create the listview columns.
    //
    CreateListColumns();
    //
    // Fill the listview.
    //
    FillListView();

    if (MODE_AUTOSYNC == m_mode)
    {
        //
        // The dialog is being invoked for it's synchronize function only.
        // The dialog will not be displayed but we'll invoke the synchronize 
        // function just as if it had been displayed.  This feature is used 
        // by the systray context menu to ensure we get the same synchronize 
        // behavior if the action is invoked through either the dialog or 
        // the systray context menu.
        //
        PostMessage(m_hwndDlg, WM_COMMAND, IDOK, 0);
    }
    else
    {
        //
        // Since we're a child of the hidden systray window we need to force ourselves
        // to the forground.
        //
        SetForegroundWindow(m_hwndDlg);
    }

    return bResult;
}


//
// WM_DESTROY handler.
//
BOOL
CStatusDlg::OnDestroy(
    void
    )
{
    RememberUsersDialogSizePref(m_bExpanded);
    DestroyLVEntries();

    //
    // Destroy the CStatusDlg object
    //
    delete this;

    //
    // Image list is automatically destroyed by the listview in comctl32.
    //
    return FALSE;
}


//
// WM_COMMAND handler.
//
BOOL
CStatusDlg::OnCommand(
    WPARAM wParam,
    LPARAM lParam
    )
{
    BOOL bResult = TRUE;
    switch(LOWORD(wParam))
    {
        case IDOK:
            SynchronizeServers();
            // Fall through and destroy the dialog
        case IDCANCEL:
        case IDCLOSE:
            Destroy();
            break;
            
        case IDC_BTN_VIEWFILES:
            COfflineFilesFolder::Open();
            break;

        case IDC_BTN_SETTINGS:
            COfflineFilesSheet::CreateAndRun(g_hInstance, GetDesktopWindow(), &g_cRefCount);
            break;

        case IDC_BTN_DETAILS:
            ExpandDialog(!m_bExpanded);
            break;

        default:
            bResult = FALSE;
            break;  
    }
    return bResult;
}


//
// WM_NOTIFY handler.
//
BOOL
CStatusDlg::OnNotify(
    WPARAM wParam,
    LPARAM lParam
    )
{
    BOOL bResult = TRUE;
  //int idCtl    = int(wParam);
    LPNMHDR pnm  = (LPNMHDR)lParam;

    switch(pnm->code)
    {
        case LVN_GETDISPINFO:
            OnLVN_GetDispInfo((LV_DISPINFO *)lParam);
            break;

        case LVN_COLUMNCLICK:
            OnLVN_ColumnClick((NM_LISTVIEW *)lParam);
            break;

        default:
            bResult = FALSE;
            break;
    }
    return bResult;
}

//
// LVN_GETDISPINFO handler.
//
void
CStatusDlg::OnLVN_GetDispInfo(
    LV_DISPINFO *plvdi
    )
{
    LVEntry *pEntry = (LVEntry *)plvdi->item.lParam;
    if (LVIF_TEXT & plvdi->item.mask)
    {
        static TCHAR szText[MAX_PATH];
        szText[0] = TEXT('\0');
        switch(plvdi->item.iSubItem)
        {
            case iLVSUBITEM_SERVER:
                lstrcpyn(szText, pEntry->Server(), ARRAYSIZE(szText));
                break;
                
            case iLVSUBITEM_STATUS:
                pEntry->GetStatusText(szText, ARRAYSIZE(szText));
                break;

            case iLVSUBITEM_INFO:
                pEntry->GetInfoText(szText, ARRAYSIZE(szText));
                break;
        }
        plvdi->item.pszText = szText;
    }
    if (LVIF_IMAGE & plvdi->item.mask)
    {
        plvdi->item.iImage = pEntry->GetImageIndex();
    }
}

//
// LVN_COLUMNCLICK handler.
//
void
CStatusDlg::OnLVN_ColumnClick(
    NM_LISTVIEW *pnmlv
    )
{
    if (m_iLastColSorted != pnmlv->iSubItem)
    {
        m_bSortAscending = true;
        m_iLastColSorted = pnmlv->iSubItem;
    }
    else
    {
        m_bSortAscending = !m_bSortAscending;
    }

    ListView_SortItems(m_hwndLV, CompareLVItems, LPARAM(this));
}


//
// Create the server listview columns.
//
void
CStatusDlg::CreateListColumns(
    void
    )
{
    //
    // Clear out the listview and header.
    //
    ListView_DeleteAllItems(m_hwndLV);
    HWND hwndHeader = ListView_GetHeader(m_hwndLV);
    if (NULL != hwndHeader)
    {
        while(0 < Header_GetItemCount(hwndHeader))
            ListView_DeleteColumn(m_hwndLV, 0);
    }

    //
    // Create the header titles.
    //
    TCHAR szServer[80] = {0};
    TCHAR szStatus[80] = {0};
    TCHAR szInfo[80]   = {0};
    LoadString(m_hInstance, IDS_STATUSDLG_HDR_SERVER, szServer, ARRAYSIZE(szServer));
    LoadString(m_hInstance, IDS_STATUSDLG_HDR_STATUS, szStatus, ARRAYSIZE(szStatus));
    LoadString(m_hInstance, IDS_STATUSDLG_HDR_INFO,   szInfo,   ARRAYSIZE(szInfo));

    RECT rcList;
    GetClientRect(m_hwndLV, &rcList);
    int cxLV = rcList.right - rcList.left;

#define LVCOLMASK (LVCF_FMT | LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM)

    LV_COLUMN rgCols[] = { 
         { LVCOLMASK, LVCFMT_LEFT, cxLV/4, szServer, 0, iLVSUBITEM_SERVER },
         { LVCOLMASK, LVCFMT_LEFT, cxLV/4, szStatus, 0, iLVSUBITEM_STATUS },
         { LVCOLMASK, LVCFMT_LEFT, cxLV/2, szInfo,   0, iLVSUBITEM_INFO   }
                         };
    //
    // Add the columns to the listview.
    //
    for (INT i = 0; i < ARRAYSIZE(rgCols); i++)
    {
        ListView_InsertColumn(m_hwndLV, i, &rgCols[i]);
    }
}



//
// Populate the listview.
//
void
CStatusDlg::FillListView(
    void
    )
{
    DWORD dwStatus;
    DWORD dwPinCount;
    DWORD dwHintFlags;
    FILETIME ft;
    WIN32_FIND_DATA fd;

    CCscFindHandle hFind = CacheFindFirst(NULL, &fd, &dwStatus, &dwPinCount, &dwHintFlags, &ft);
    if (hFind.IsValid())
    {
        LPTSTR pszServer = fd.cFileName;
        LPTSTR pszEnd;
        LVEntry *pEntry;
        CSCSHARESTATS stats;
        do
        {
            //
            // Exclude the following:
            //   1. Directories.
            //   2. Files marked as "locally deleted".
            //
            // NOTE:  The filtering done by this function must be the same as 
            //        in several other places throughout the CSCUI code.
            //        To locate these, search the source for the comment
            //        string CSCUI_ITEM_FILTER.
            //
            const DWORD fExclude = SSEF_LOCAL_DELETED | 
                                   SSEF_DIRECTORY;

            CSCGETSTATSINFO si = { fExclude,
                                   SSUF_NONE,
                                   false,      // No access info reqd (faster).
                                   false };     

            if (_GetShareStatisticsForUser(fd.cFileName, &si, &stats) && 
                (0 < stats.cTotal || stats.bOffline))
            {
                bool bReplacedBackslash = false;
                //
                // Extract the server name from the share name returned by CSC.
                //
                while(*pszServer && TEXT('\\') == *pszServer)
                    pszServer++;
                pszEnd = pszServer;
                while(*pszEnd && TEXT('\\') != *pszEnd)
                    pszEnd++;
                if (TEXT('\\') == *pszEnd)
                {
                    *pszEnd = TEXT('\0');
                    bReplacedBackslash = true;
                }
                //
                // Find an existing server entry.  If none found, create a new one.
                //
                if (NULL == (pEntry = FindLVEntry(pszServer)))
                {
                    bool bConnectable = boolify(SendToSystray(CSCWM_ISSERVERBACK, 0, (LPARAM)fd.cFileName));
                    pEntry = CreateLVEntry(pszServer, bConnectable);
                }
                if (NULL != pEntry)
                {
                    if (bReplacedBackslash)
                        *pszEnd = TEXT('\\');

                    //
                    // If we're running in "normal" mode, we 
                    // can't trust the share's "modified offline" bit.
                    // Use the info we got by scanning the cache.
                    // If we're running in "autosync" mode, we can just
                    // use the share's "modified offline" indicator.
                    // If something is truly modified offline, the bit
                    // will be set.
                    //
                    if (MODE_NORMAL == m_mode)
                    {
                        dwStatus &= ~FLAG_CSC_SHARE_STATUS_MODIFIED_OFFLINE;
                        if (0 < stats.cModified)
                            dwStatus |= FLAG_CSC_SHARE_STATUS_MODIFIED_OFFLINE;
                    }
                    //
                    // Add this share and it's statistics to the 
                    // server's list entry.
                    //
                    pEntry->AddShare(fd.cFileName, stats, dwStatus);
                }
            }
        }
        while(CacheFindNext(hFind, &fd, &dwStatus, &dwPinCount, &dwHintFlags, &ft));
        //
        // Remove those servers that the user won't be interested in.
        // Also place a checkmark next to those servers that are available
        // for reconnection.
        //
        PrepListForDisplay();
    }
}


//
// Build the image list used by the server listview.
//
HIMAGELIST
CStatusDlg::CreateImageList(
    void
    )
{
    HIMAGELIST himl = NULL;

    //
    // Note:  The order of these icon ID's in this array must match with the
    //        iIMAGELIST_ICON_XXXXX enumeration.
    //        The enum values represent the image indices in the image list.
    //
    static const struct IconDef
    {
        LPTSTR szName;
        HINSTANCE hInstance;

    } rgIcons[] = { 
                    { MAKEINTRESOURCE(IDI_SERVER),         m_hInstance },
                    { MAKEINTRESOURCE(IDI_SERVER_OFFLINE), m_hInstance },
                    { MAKEINTRESOURCE(IDI_CSCINFORMATION), m_hInstance },
                    { MAKEINTRESOURCE(IDI_CSCWARNING),     m_hInstance }
                  };
    //
    // Create the image lists for the listview.
    //
    int cxIcon = GetSystemMetrics(SM_CXSMICON);
    int cyIcon = GetSystemMetrics(SM_CYSMICON);

    himl = ImageList_Create(cxIcon,
                            cyIcon,
                            ILC_MASK, 
                            ARRAYSIZE(rgIcons), 
                            10);
    if (NULL != himl)
    {
        for (UINT i = 0; i < ARRAYSIZE(rgIcons); i++)
        {
            HICON hIcon = (HICON)LoadImage(rgIcons[i].hInstance, 
                                           rgIcons[i].szName,
                                           IMAGE_ICON,
                                           cxIcon,
                                           cyIcon,
                                           0);
            if (NULL != hIcon)
            {
                ImageList_AddIcon(himl, hIcon);
                DestroyIcon(hIcon);
            }
        }
        ImageList_SetBkColor(himl, CLR_NONE);  // Transparent background.
    }

    return himl;
}


void
CStatusDlg::EnableListviewCheckboxes(
    bool bEnable
    )
{    
    DWORD dwStyle    = ListView_GetExtendedListViewStyle(m_hwndLV);
    DWORD dwNewStyle = bEnable ? (dwStyle | LVS_EX_CHECKBOXES) :
                                 (dwStyle & ~LVS_EX_CHECKBOXES);
                                 
    ListView_SetExtendedListViewStyle(m_hwndLV, dwNewStyle);
}


//
// The "Details" button changes it's title depending on 
// the dialog state (expanded or not).
//
void
CStatusDlg::UpdateDetailsBtnTitle(
    void
    )
{
    TCHAR szBtnTitle[80];
    int idsBtnTitle = IDS_OPENDETAILS;
    if (m_bExpanded)
        idsBtnTitle = IDS_CLOSEDETAILS;

    LoadString(m_hInstance, idsBtnTitle, szBtnTitle, ARRAYSIZE(szBtnTitle));
    SetWindowText(GetDlgItem(m_hwndDlg, IDC_BTN_DETAILS), szBtnTitle);
}

//
// Expand or contract the dialog vertically.
// When expanded, the server listview is made visible along
// with the "Settings..." and "View Files..." buttons.
//
void 
CStatusDlg::ExpandDialog(
    bool bExpand
    )
{
    if (bExpand != m_bExpanded)
    {
        CConfig& config = CConfig::GetSingleton();
        //
        // Table describing enable/disable state of controls in the lower part
        // of the dialog that are displayed when the dialog is expanded.
        //
        struct
        {
            UINT idCtl;
            bool bEnable;

        } rgidExpanded[] = { { IDC_LV_STATUSDLG,  bExpand },
                             { IDC_BTN_SETTINGS,  bExpand && !config.NoConfigCache() },
                             { IDC_BTN_VIEWFILES, bExpand && !config.NoCacheViewer() }
                           };

        RECT rcDlg;
        GetWindowRect(m_hwndDlg, &rcDlg);
        if (!bExpand)
        {
            //
            // Closing details.
            //
            RECT rcSep;
            GetWindowRect(GetDlgItem(m_hwndDlg, IDC_SEP_STATUSDLG), &rcSep);
            rcDlg.bottom = rcSep.top;
        }
        else
        {
            //
            // Opening details.
            //
            rcDlg.bottom = rcDlg.top + m_cyExpanded;
        }

        //
        // If the dialog is not expanded, we want to disable all of the
        // "tabbable" items in the hidden part so they don't participate
        // in the dialog's tab order.  Note that the "Settings" and
        // "View Files" buttons also have a policy setting involved in
        // the enabling logic.
        //
        for (int i = 0; i < ARRAYSIZE(rgidExpanded); i++)
        {
            EnableWindow(GetDlgItem(m_hwndDlg, rgidExpanded[i].idCtl), rgidExpanded[i].bEnable);
        }

        SetWindowPos(m_hwndDlg,
                     NULL,
                     rcDlg.left,
                     rcDlg.top,
                     rcDlg.right - rcDlg.left,
                     rcDlg.bottom - rcDlg.top,
                     SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);

        m_bExpanded = bExpand;
        UpdateDetailsBtnTitle();
    }
}




//
// Queries the HKCU reg data to see if the user closed the dialog
// expanded or not expanded last time the dialog was used.
// Returns:  true = expanded, false = not expanded.
//
bool
CStatusDlg::UserLikesDialogExpanded(
    void
    )
{
    DWORD dwExpanded = 0;
    HKEY hkey;
    DWORD dwStatus = RegOpenKeyEx(HKEY_CURRENT_USER,
                                  REGSTR_KEY_OFFLINEFILES,
                                  0,
                                  KEY_QUERY_VALUE,
                                  &hkey);
    if (ERROR_SUCCESS == dwStatus)
    {
        DWORD dwType;
        DWORD cbData = sizeof(DWORD);
        RegQueryValueEx(hkey,
                        REGSTR_VAL_EXPANDSTATUSDLG,
                        NULL,
                        &dwType,
                        (LPBYTE)&dwExpanded,
                        &cbData);
        RegCloseKey(hkey);
    }
    return !!dwExpanded;
}


//
// Stores the current state of the status dialog in per-user
// reg data.  Used next time the dialog is opened so that if the
// user likes the dialog expanded, it opens expanded.
//
void
CStatusDlg::RememberUsersDialogSizePref(
    bool bExpanded
    )
{
    HKEY hkey;
    DWORD dwStatus = RegOpenKeyEx(HKEY_CURRENT_USER,
                                  REGSTR_KEY_OFFLINEFILES,
                                  0,
                                  KEY_SET_VALUE,
                                  &hkey);

    if (ERROR_SUCCESS == dwStatus)
    {
        DWORD cbData = sizeof(DWORD);
        DWORD dwExpanded = DWORD(bExpanded);
        RegSetValueEx(hkey,
                      REGSTR_VAL_EXPANDSTATUSDLG,
                      0,
                      REG_DWORD,
                      (CONST BYTE *)&dwExpanded,
                      cbData);

        RegCloseKey(hkey);
    }
}



//
// Build a list of share names for synchronization and
// reconnect.
//
HRESULT 
CStatusDlg::BuildFilenameList(
    CscFilenameList *pfnl
    )
{
    LVEntry *pEntry;
    LVITEM item;

    int cEntries = ListView_GetItemCount(m_hwndLV);
    for (int i = 0; i < cEntries; i++)
    {
        if (ListView_GetCheckState(m_hwndLV, i))
        {
            //
            // Server has checkmark so we add it's
            // shares to the filename list.
            //
            item.mask     = LVIF_PARAM;
            item.iItem    = i;
            item.iSubItem = 0;
            if (ListView_GetItem(m_hwndLV, &item))
            {
                pEntry = (LVEntry *)item.lParam;
                int cShares = pEntry->GetShareCount();
                for (int iShare = 0; iShare < cShares; iShare++)
                {
                    LPCTSTR pszShare = pEntry->GetShareName(iShare);
                    if (NULL != pszShare)
                    {
                        if (!pfnl->AddFile(pszShare, TRUE))
                            return E_OUTOFMEMORY;
                    }
                }
            }
        }
    }
    return NOERROR;
}


//
// Synchronize all of the checked servers from the listview and
// reconnect them.
//
HRESULT
CStatusDlg::SynchronizeServers(
    void
    )
{
    HRESULT hr = NOERROR;
    const bool bSkipTheSync = BST_CHECKED == IsDlgButtonChecked(m_hwndDlg, IDC_CBX_STATUSDLG);
    
    if (::IsSyncInProgress())
    {
        CscMessageBox(m_hwndDlg, 
                      MB_OK | MB_ICONINFORMATION, 
                      m_hInstance, 
                      bSkipTheSync ? IDS_CANTRECONN_SYNCINPROGRESS : IDS_CANTSYNC_SYNCINPROGRESS);
    }
    else
    {
        //
        // First build the FilenameList containing shares to sync.
        //
        CscFilenameList fnl;
        hr = BuildFilenameList(&fnl);
        if (SUCCEEDED(hr))
        {
            if (bSkipTheSync)
            {
                //
                // User has checked "reconnect without sync" checkbox.
                // Therefore, we skip the sync and go straight to reconnect.
                //
                hr = ReconnectServers(&fnl, TRUE, FALSE);
                if (S_OK == hr)
                {
                    PostToSystray(CSCWM_UPDATESTATUS, STWM_STATUSCHECK, 0);
                }

            }
            else
            {
                const DWORD dwUpdateFlags = CSC_UPDATE_STARTNOW |
                                            CSC_UPDATE_SELECTION |
                                            CSC_UPDATE_REINT |
                                            CSC_UPDATE_NOTIFY_DONE |
                                            CSC_UPDATE_SHOWUI_ALWAYS |
                                            CSC_UPDATE_RECONNECT;
                //
                // Syncing is an asynchronous operation involving
                // mobsync.exe.  The code in CscUpdateCache will check for open
                // files and notify the user.  When the sync is done, it will
                // transition everything in the file list to online mode.
                //
                hr = CscUpdateCache(dwUpdateFlags, &fnl);
            }
        }
    }
    return hr;
}


//
// Create an entry for the listview.
// Returns ptr to new entry on success.  NULL on failure.
//
CStatusDlg::LVEntry *
CStatusDlg::CreateLVEntry(
    LPCTSTR pszServer,
    bool bConnectable
    )
{
    LVEntry *pEntry = new LVEntry(m_hInstance, pszServer, bConnectable);
    if (NULL != pEntry)
    {
        LVITEM item;
        item.mask     = LVIF_PARAM | LVIF_TEXT | LVIF_IMAGE;
        item.lParam   = (LPARAM)pEntry;
        item.iItem    = ListView_GetItemCount(m_hwndLV);
        item.iSubItem = 0;
        item.pszText  = LPSTR_TEXTCALLBACK;
        item.iImage   = I_IMAGECALLBACK;
        if (-1 == ListView_InsertItem(m_hwndLV, &item))
        {
            delete pEntry;
            pEntry = NULL;
        }
    }
    return pEntry;
}

//
// Find an entry in the listview using the servername as the key.
// Return ptr to entry on success.  NULL on failure.
//
CStatusDlg::LVEntry *
CStatusDlg::FindLVEntry(
    LPCTSTR pszServer
    )
{
    LVEntry *pEntry = NULL;
    LVITEM item;

    int cEntries = ListView_GetItemCount(m_hwndLV);
    for (int i = 0; i < cEntries; i++)
    {
        item.mask     = LVIF_PARAM;
        item.iItem    = i;
        item.iSubItem = 0;
        if (ListView_GetItem(m_hwndLV, &item))
        {
            pEntry = (LVEntry *)item.lParam;
            //
            // This comparison must be case-INSENSITIVE.  Entries
            // in the CSC database are on a "\\server\share" basis and
            // are at the mercy of what was passed in through the CSC APIs.
            // Therefore, the database can contain "\\Foo\bar" and
            // "\\foo\bar2".  We must treat "Foo" and "foo" as the single
            // server they represent.
            //
            if (0 == lstrcmpi(pEntry->Server(), pszServer))
                break;
            pEntry = NULL;
        }
    }
    return pEntry;
}

//
// Clear out the listview.  Ensures all listview item objects
// are destroyed.
//
void
CStatusDlg::DestroyLVEntries(
    void
    )
{
    LVITEM item;

    int cEntries = ListView_GetItemCount(m_hwndLV);
    for (int i = 0; i < cEntries; i++)
    {
        item.mask     = LVIF_PARAM;
        item.iItem    = i;
        item.iSubItem = 0;
        if (ListView_GetItem(m_hwndLV, &item))
        {
            delete (LVEntry *)item.lParam;
            if (ListView_DeleteItem(m_hwndLV, i))
            {
                i--;
                cEntries--;
            }
        }
    }
}

//
// Determine if a listview entry should remain visible in the listview.
// Currently we include servers that currently connected through the 
// network redirector and are offline OR those that are dirty.
// 
bool
CStatusDlg::ShouldIncludeLVEntry(
    const CStatusDlg::LVEntry& entry
    )
{
    DWORD dwCscStatus;
    entry.GetStats(NULL, &dwCscStatus);

    return (FLAG_CSC_SHARE_STATUS_DISCONNECTED_OP & dwCscStatus) || 
           (FLAG_CSC_SHARE_STATUS_MODIFIED_OFFLINE & dwCscStatus);
}


//
// Determine if a checkmark should be placed next to an item in 
// the listview.
//
bool
CStatusDlg::ShouldCheckLVEntry(
    const CStatusDlg::LVEntry& entry
    )
{
    return true;
}


//
// Remove all entries not to be displayed from the listview.
// Initially we create LV entries for each server in the CSC cache.  
// After all servers have been entered and their statistics tallied,
// we call PrepListForDisplay to remove the ones that the
// user won't want to see.
// 
void
CStatusDlg::PrepListForDisplay(
    void
    )
{
    LVEntry *pEntry;
    LVITEM item;

    int cEntries = ListView_GetItemCount(m_hwndLV);
    for (int i = 0; i < cEntries; i++)
    {
        item.mask     = LVIF_PARAM;
        item.iItem    = i;
        item.iSubItem = 0;
        if (ListView_GetItem(m_hwndLV, &item))
        {
            pEntry = (LVEntry *)item.lParam;
            if (ShouldIncludeLVEntry(*pEntry))
            {
                ListView_SetCheckState(m_hwndLV, i, ShouldCheckLVEntry(*pEntry));
            }
            else
            {
                delete pEntry;
                if (ListView_DeleteItem(m_hwndLV, i))
                {
                    i--;
                    cEntries--;
                }
            }
        }
    }
}


//
// Listview item comparison callback.
//
int CALLBACK 
CStatusDlg::CompareLVItems(
    LPARAM lParam1, 
    LPARAM lParam2,
    LPARAM lParamSort
    )
{
    CStatusDlg *pdlg = reinterpret_cast<CStatusDlg *>(lParamSort);
    CStatusDlg::LVEntry *pEntry1 = reinterpret_cast<CStatusDlg::LVEntry *>(lParam1);
    CStatusDlg::LVEntry *pEntry2 = reinterpret_cast<CStatusDlg::LVEntry *>(lParam2);
    int diff = 0;
    TCHAR szText[2][MAX_PATH];

    //
    // This array controls the comparison column IDs used when
    // values for the selected column are equal.  These should
    // remain in order of the iLVSUBITEM_xxxxx enumeration with
    // respect to the first element in each row.
    //
    static const int rgColComp[3][3] = { 
        { iLVSUBITEM_SERVER, iLVSUBITEM_STATUS, iLVSUBITEM_INFO   },
        { iLVSUBITEM_STATUS, iLVSUBITEM_SERVER, iLVSUBITEM_INFO   },
        { iLVSUBITEM_INFO,   iLVSUBITEM_SERVER, iLVSUBITEM_STATUS }
                                       };
    int iCompare = 0;
    while(0 == diff && iCompare < ARRAYSIZE(rgColComp))
    {
        switch(rgColComp[pdlg->m_iLastColSorted][iCompare++])
        {
            case iLVSUBITEM_SERVER:
                lstrcpyn(szText[0], pEntry1->Server(), ARRAYSIZE(szText[0]));
                lstrcpyn(szText[1], pEntry2->Server(), ARRAYSIZE(szText[1]));
                break;

            case iLVSUBITEM_STATUS:
                pEntry1->GetStatusText(szText[0], ARRAYSIZE(szText[0]));
                pEntry2->GetStatusText(szText[1], ARRAYSIZE(szText[1]));
                break;

            case iLVSUBITEM_INFO:
                pEntry1->GetInfoText(szText[0], ARRAYSIZE(szText[0]));
                pEntry2->GetInfoText(szText[1], ARRAYSIZE(szText[1]));
                break;

            default:
                //
                // If you hit this, you need to update this function
                // to handle the new column you've added to the listview.
                //
                *szText[0] = TEXT('\0');
                *szText[1] = TEXT('\0');
                TraceAssert(false);
                break;
        }
        //
        // This comparison should be case-sensitive since it is controlling
        // sort order of display columns.
        //
        diff = lstrcmp(szText[0], szText[1]);
    }

    return pdlg->m_bSortAscending ? diff : -1 * diff;
}



const TCHAR CStatusDlg::LVEntry::s_szBlank[] = TEXT("");
//
// There are 3 binary conditions that control the selection of the entry 
// display information.  Therefore we can use a simple 8-element map of string resource
// IDs and icon image list indices to determine the correct display information
// string for the corresponding LV entry state.  GetDispInfoIndex() is called
// to retrieve the index for a particular LVEntry.
//
const CStatusDlg::LVEntry::DispInfo 
CStatusDlg::LVEntry::s_rgDispInfo[] = {                                                                   // online available modified
    { IDS_SHARE_STATUS_OFFLINE, IDS_SHARE_INFO_UNAVAIL,     CStatusDlg::iIMAGELIST_ICON_SERVER_OFFLINE }, //    0       0         0      
    { IDS_SHARE_STATUS_OFFLINE, IDS_SHARE_INFO_UNAVAIL_MOD, CStatusDlg::iIMAGELIST_ICON_SERVER_OFFLINE }, //    0       0         1
    { IDS_SHARE_STATUS_OFFLINE, IDS_SHARE_INFO_AVAIL,       CStatusDlg::iIMAGELIST_ICON_SERVER_BACK    }, //    0       1         0
    { IDS_SHARE_STATUS_OFFLINE, IDS_SHARE_INFO_AVAIL_MOD,   CStatusDlg::iIMAGELIST_ICON_SERVER_BACK    }, //    0       1         1 
    { IDS_SHARE_STATUS_ONLINE,  IDS_SHARE_INFO_BLANK,       CStatusDlg::iIMAGELIST_ICON_SERVER         }, //    1       0         0
    { IDS_SHARE_STATUS_ONLINE,  IDS_SHARE_INFO_DIRTY,       CStatusDlg::iIMAGELIST_ICON_SERVER_DIRTY   }, //    1       0         1
    { IDS_SHARE_STATUS_ONLINE,  IDS_SHARE_INFO_BLANK,       CStatusDlg::iIMAGELIST_ICON_SERVER         }, //    1       1         0
    { IDS_SHARE_STATUS_ONLINE,  IDS_SHARE_INFO_DIRTY,       CStatusDlg::iIMAGELIST_ICON_SERVER_DIRTY   }  //    1       1         1
    };

CStatusDlg::LVEntry::LVEntry(
    HINSTANCE hInstance,
    LPCTSTR pszServer,
    bool bConnectable
    ) : m_hInstance(hInstance),
        m_pszServer(StrDup(pszServer)),
        m_dwCscStatus(0),
        m_hdpaShares(DPA_Create(4)),
        m_bConnectable(bConnectable),
        m_iDispInfo(-1)
{
    m_stats.cTotal    = 0;
    m_stats.cPinned   = 0;
    m_stats.cModified = 0;
    m_stats.cSparse   = 0;

    if (NULL == m_pszServer)
        m_pszServer = const_cast<LPTSTR>(s_szBlank);
}


CStatusDlg::LVEntry::~LVEntry(
    void
    )
{
    if (s_szBlank != m_pszServer && NULL != m_pszServer)
    {
        LocalFree(m_pszServer);
    }
    if (NULL != m_hdpaShares)
    {
        int cShares = DPA_GetPtrCount(m_hdpaShares);
        for (int i = 0; i < cShares; i++)
        {
            LPTSTR psz = (LPTSTR)DPA_GetPtr(m_hdpaShares, i);
            if (NULL != psz)
            {
                LocalFree(psz);
            }
        }
        DPA_Destroy(m_hdpaShares);
    }
}


bool
CStatusDlg::LVEntry::AddShare(
    LPCTSTR pszShare,
    const CSCSHARESTATS& s,
    DWORD dwCscStatus
    )
{
    bool bResult = false;
    if (NULL != m_hdpaShares)
    {
        LPTSTR pszCopy = StrDup(pszShare);
        if (NULL != pszCopy)
        {
            if (-1 != DPA_AppendPtr(m_hdpaShares, pszCopy))
            {
                m_stats.cTotal    += s.cTotal;
                m_stats.cPinned   += s.cPinned;
                m_stats.cModified += s.cModified;
                m_stats.cSparse   += s.cSparse;

                m_dwCscStatus |= dwCscStatus;

                bResult = true;
            }
            else
            {
                LocalFree(pszCopy);
            }
        }
    }
    return bResult;
}


int 
CStatusDlg::LVEntry::GetShareCount(
    void
    ) const
{
    if (NULL != m_hdpaShares)
        return DPA_GetPtrCount(m_hdpaShares);
    return 0;
}


LPCTSTR 
CStatusDlg::LVEntry::GetShareName(
    int iShare
    ) const
{
    if (NULL != m_hdpaShares)
        return (LPCTSTR)DPA_GetPtr(m_hdpaShares, iShare);
    return NULL;
}


void 
CStatusDlg::LVEntry::GetStats(
    CSCSHARESTATS *ps,
    DWORD *pdwCscStatus
    ) const
{
    if (NULL != ps)
        *ps = m_stats;
    if (NULL != pdwCscStatus)
        *pdwCscStatus = m_dwCscStatus;
}

//
// Determines the index into s_rgDispInfo[] for obtaining display information
// for the LV entry.
//
int
CStatusDlg::LVEntry::GetDispInfoIndex(
    void
    ) const
{
    if (-1 == m_iDispInfo)
    {
        m_iDispInfo = 0;

        if (IsModified())
            m_iDispInfo |= DIF_MODIFIED;

        if (!IsOffline())
            m_iDispInfo |= DIF_ONLINE;

        if (IsConnectable())
            m_iDispInfo |= DIF_AVAILABLE;
    }
    return m_iDispInfo;
}


//
// Retrieve the entry's text for the "Status" column in the listview.
//
void 
CStatusDlg::LVEntry::GetStatusText(
    LPTSTR pszStatus, 
    int cchStatus
    ) const
{
    UINT idsStatusText = s_rgDispInfo[GetDispInfoIndex()].idsStatusText;
    LoadString(m_hInstance, idsStatusText, pszStatus, cchStatus);
}


//
// Retrieve entry's text for the "Information" column in the listview.
//
void 
CStatusDlg::LVEntry::GetInfoText(
    LPTSTR pszInfo, 
    int cchInfo
    ) const
{
    int iInfoText = GetDispInfoIndex();
    int idsInfoText = s_rgDispInfo[iInfoText].idsInfoText;
    if (iInfoText & DIF_MODIFIED)
    {
        //
        // Info text has embedded modified file count.
        // Requires a little more work.
        //
        TCHAR szTemp[MAX_PATH];
        INT_PTR rgcModified[] = { m_stats.cModified };
        LoadString(m_hInstance, idsInfoText, szTemp, ARRAYSIZE(szTemp));
        FormatMessage(FORMAT_MESSAGE_FROM_STRING |
                      FORMAT_MESSAGE_ARGUMENT_ARRAY,
                      szTemp,
                      0,
                      0,
                      pszInfo,
                      cchInfo,
                      (va_list *)rgcModified);
    }
    else
    {
        LoadString(m_hInstance, idsInfoText, pszInfo, cchInfo);
    }
}


//
// Retrieve entry's imagelist index for the image displayed next to the
// entry in the listview.
//
int
CStatusDlg::LVEntry::GetImageIndex(
    void
    ) const
{
    return s_rgDispInfo[GetDispInfoIndex()].iImage;
}


//
// Wrapper for CSCTransitionServerOnline
//
//
// CAUTION!
//
// TransitionShareOnline is called from ReconnectServers (below) which
// means we may be running in either explorer or mobsync.  It's also
// called directly from the systray code when auto-reconnecting a
// server.
//
// 1. Be careful with SendMessage, since it may go out of process. Note that
// STDBGOUT uses SendMessage.
// 2. Be careful not to do anything that could cause a transition to offline,
// which results in a SendMessage from WinLogon, which deadlocks if we are
// running on the systray thread (the recipient of the SendMessage).
// For example, use SHSimpleIDListFromFindData instead of ILCreateFromPath.
//
BOOL
TransitionShareOnline(LPCTSTR pszShare,
                      BOOL  bShareIsAlive,  // TRUE skips CheckShareOnline
                      BOOL  bCheckSpeed,    // FALSE skips slow link check
                      DWORD dwPathSpeed)    // Used if (bShareIsAlive && bCheckSpeed)
{
    BOOL bShareTransitioned = FALSE;
    DWORD dwShareStatus;

    if (!pszShare || !*pszShare)
        return FALSE;

    //
    // Protect against calling CSCCheckShareOnline & CSCTransitionServerOnline
    // for shares that are already online. In particular, CSCCheckShareOnline
    // establishes a net connection so it can be slow.
    //
    // This also means that we call CSCTransitionServerOnline for only one
    // share on a given server, since all shares transition online/offline
    // at the same time.
    //
    if (CSCQueryFileStatus(pszShare, &dwShareStatus, NULL, NULL)
        && (FLAG_CSC_SHARE_STATUS_DISCONNECTED_OP & dwShareStatus))
    {
        //
        // Only try to transition the server online if the share is
        // truly available on the net.  Otherwise we'll put the server online
        // and the next call for net resources on that server will cause a net
        // timeout.
        //
        if (!bShareIsAlive)
        {
            bShareIsAlive = CSCCheckShareOnlineEx(pszShare, &dwPathSpeed);
            if (!bShareIsAlive)
            {
                DWORD dwErr = GetLastError();
                if (ERROR_ACCESS_DENIED == dwErr ||
                    ERROR_LOGON_FAILURE == dwErr)
                {
                    // The share is reachable, but we don't have valid
                    // credentials.  We don't have a valid path speed,
                    // so the best we can do is assume fast link.
                    //
                    // Currently, this function is always called with
                    // bShareIsAlive and bCheckSpeed both TRUE or both FALSE
                    // so it doesn't make any difference.  Could change in
                    // the future, though.
                    //
                    bShareIsAlive = TRUE;
                    bCheckSpeed = FALSE;
                }
            }
        }
        if (bShareIsAlive)
        {
            //
            // Also, for auto-reconnection, we only transition if not on a
            // slow link.
            //
            if (!bCheckSpeed || !_PathIsSlow(dwPathSpeed))
            {
                //
                // Transition to online
                //
                STDBGOUT((2, TEXT("Transitioning server \"%s\" to online"), pszShare));
                if (CSCTransitionServerOnline(pszShare))
                {
                    STDBGOUT((1, TEXT("Server \"%s\" reconnected."), pszShare));
                    LPTSTR pszTemp;
                    if (LocalAllocString(&pszTemp, pszShare))
                    {
	                //
                        // Strip the path to only the "\\server" part.
                        //
                        PathStripToRoot(pszTemp);
                        PathRemoveFileSpec(pszTemp);
                        SendCopyDataToSystray(PWM_REFRESH_SHELL, StringByteSize(pszTemp), pszTemp);
                        LocalFreeString(&pszTemp);
                    }
                    bShareTransitioned = TRUE;
                }
                else
                {
                    STDBGOUT((1, TEXT("Error %d reconnecting \"%s\""), GetLastError(), pszShare));
                }
            }
            else
            {
                STDBGOUT((1, TEXT("Path to \"%s\" is SLOW.  No reconnect."), pszShare));
            }
        }
        else
        {
            STDBGOUT((1, TEXT("Unable to connect to \"%s\".  No reconnect."), pszShare));
        }
    }

    return bShareTransitioned;
}


//
// CAUTION!
//
// ReconnectServers is called from both the Status Dialog (explorer) and
// the sync update handler (mobsync.exe). Any communication with systray
// must be done in a process-safe manner.
//
// See comments for TransitionShareOnline above.
//
HRESULT
ReconnectServers(CscFilenameList *pfnl,
                 BOOL bCheckForOpenFiles,
                 BOOL bCheckSpeed)          // FALSE skips slow link check
{
    if (pfnl)
    {
        CscFilenameList::ShareIter si = pfnl->CreateShareIterator();
        CscFilenameList::HSHARE hShare;
        BOOL bRefreshShell = FALSE;

        if (bCheckForOpenFiles)
        {
            //
            // First scan the shares to see if any have open files.
            //
            while(si.Next(&hShare))
            {
                DWORD dwShareStatus;
                if (CSCQueryFileStatus(pfnl->GetShareName(hShare), &dwShareStatus, NULL, NULL))
                {
                    if ((FLAG_CSC_SHARE_STATUS_FILES_OPEN & dwShareStatus) &&
                        (FLAG_CSC_SHARE_STATUS_DISCONNECTED_OP & dwShareStatus))
                    {
                        if (IDOK != OpenFilesWarningDialog())
                        {
                            return S_FALSE; // User cancelled.
                        }

                        break;
                    }
                }
            }
            si.Reset();
        }

        //
        // Walk through the list, transitioning everything to online.
        //
        while(si.Next(&hShare))
        {
            if (TransitionShareOnline(pfnl->GetShareName(hShare), FALSE, bCheckSpeed, 0))
                bRefreshShell = TRUE;
        }
    }

    return S_OK;
}