windows-xp/Source/XPSP1/NT/shell/ext/brfcase/filesync/syncui/twin.c

//---------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation 1993-1994
//
// File: twin.c
//
//  This file contains special twin handling functions.
//
//   (Even though we've moved to a briefcase metaphor,
//    we still refer to twins internally...)
//
// History:
//  08-06-93 ScottH     Transferred from twin code
//
//---------------------------------------------------------------------------


#include "brfprv.h"         // common headers

#include "res.h"
#include "recact.h"


// APPCOMPAT: due to a compiler bug, we need to declare this structure
// as a 1-element array because it has pointers to functions in it
// and it is in another datasegment.
VTBLENGINE g_vtblEngine[1] = { { 0 } };    // per-instance v-table

#define GetFunction(rgtable, name, type)     \
    ((rgtable).##name = (type)GetProcAddress((rgtable).hinst, #name)); \
ASSERT((rgtable).##name)

#ifdef DEBUG
#define SzTR(tr)    #tr,
#endif

#define MAX_RANGE       0x7fff

// Recitem dwUser values
#define RIU_CHANGED     1
#define RIU_SKIP        2
#define RIU_SHOWSTATUS  3


/*----------------------------------------------------------
Purpose: Compare two structures by folder name
Returns: -1 if <, 0 if ==, 1 if >
Cond:    --
*/
int CALLBACK _export NCompareFolders(
                                     LPVOID lpv1,
                                     LPVOID lpv2,
                                     LPARAM lParam)      // One of: CMP_RECNODES, CMP_FOLDERTWINS
{
    switch (lParam)
    {
    case CMP_RECNODES:
        return lstrcmpi(((PRECNODE)lpv1)->pcszFolder, ((PRECNODE)lpv2)->pcszFolder);
        
    case CMP_FOLDERTWINS:
        return lstrcmpi(((PCFOLDERTWIN)lpv1)->pcszOtherFolder, ((PCFOLDERTWIN)lpv2)->pcszOtherFolder);
        
    default:
        ASSERT(0);      // should never get here
    }
    return 0;
}


//---------------------------------------------------------------------------
// Choose side functions
//---------------------------------------------------------------------------


#ifdef DEBUG

/*----------------------------------------------------------
Purpose: Dump a CHOOSESIDE structure
Returns: --
Cond:    --
*/
void PRIVATE ChooseSide_Dump(
                             PCHOOSESIDE pchside)
{
    BOOL bDump;
    TCHAR szBuf[MAXMSGLEN];
    
    ASSERT(pchside);
    
#define szDumpLabel     TEXT("             *** ")
#define szDumpMargin    TEXT("                 ")
    
    ENTEREXCLUSIVE();
    {
        bDump = IsFlagSet(g_uDumpFlags, DF_CHOOSESIDE);
    }
    LEAVEEXCLUSIVE();
    
    if (bDump)
    {
        wsprintf(szBuf, TEXT("%s.pszFolder = {%s}\r\n"), (LPTSTR)szDumpLabel, pchside->pszFolder);
        OutputDebugString(szBuf);
        
        wsprintf(szBuf, TEXT("%s.dwFlags = 0x%lx\r\n"), (LPTSTR)szDumpMargin, pchside->dwFlags);
        OutputDebugString(szBuf);
        
        wsprintf(szBuf, TEXT("%s.nRank = %ld\r\n"), (LPTSTR)szDumpMargin, pchside->nRank);
        OutputDebugString(szBuf);
    }
    
#undef szDumpLabel
#undef szDumpMargin
}


/*----------------------------------------------------------
Purpose: Dump a CHOOSESIDE list
Returns: --
Cond:    --
*/
void PUBLIC ChooseSide_DumpList(
                                HDSA hdsa)
{
    BOOL bDump;
    TCHAR szBuf[MAXMSGLEN];
    
    ASSERT(hdsa);
    
#define szDumpLabel     TEXT("Dump CHOOSESIDE list: ")
    
    ENTEREXCLUSIVE();
    {
        bDump = IsFlagSet(g_uDumpFlags, DF_CHOOSESIDE);
    }
    LEAVEEXCLUSIVE();
    
    if (bDump)
    {
        int i;
        int cel = DSA_GetItemCount(hdsa);
        PCHOOSESIDE pchside;
        
        wsprintf(szBuf, TEXT("%s.count = %lu\r\n"), (LPTSTR)szDumpLabel, cel);
        OutputDebugString(szBuf);
        
        if (NULL != (pchside = DSA_GetItemPtr(hdsa, 0)))
        {
            if (IsFlagSet(pchside->dwFlags, CSF_INSIDE))
                OutputDebugString(TEXT("Rank for inside\r\n"));
            else
                OutputDebugString(TEXT("Rank for outside\r\n"));
        }
        
        for (i = 0; i < cel; i++)
        {
            pchside = DSA_GetItemPtr(hdsa, i);
            
            ChooseSide_Dump(pchside);
        }
    }
    
#undef szDumpLabel
}

#endif


/*----------------------------------------------------------
Purpose: Initialize an array of CHOOSESIDE elements from a 
recitem list.  Array is unsorted.

  Returns: --
  
    Cond:    The contents of the array are safe as long as the 
    recitem list lives.
    
*/
void PUBLIC ChooseSide_InitAsFile(
                                  HDSA hdsa,
                                  PRECITEM pri)
{
    CHOOSESIDE chside;
    PRECNODE prn;
    
    ASSERT(hdsa);
    ASSERT(pri);
    
    DSA_DeleteAllItems(hdsa);
    
    // All entries start with these values
    chside.dwFlags = 0;
    chside.nRank = 0;
    
    // Add each recnode
    for (prn = pri->prnFirst; prn; prn = prn->prnNext)
    {
        chside.htwin = (HTWIN)prn->hObjectTwin;
        chside.hvid = prn->hvid;
        chside.pszFolder = prn->pcszFolder;
        chside.prn = prn;
        
        DSA_InsertItem(hdsa, 0x7fff, &chside);
    }
}


/*----------------------------------------------------------
Purpose: Create an array of CHOOSESIDE elements from a recitem
list.  Array is unsorted.

  Returns: standard result
  
    Cond:    The contents of the array are safe as long as the 
    recitem list lives.
    
*/
HRESULT PUBLIC ChooseSide_CreateAsFile(
                                       HDSA * phdsa,
                                       PRECITEM pri)
{
    HRESULT hres;
    HDSA hdsa;
    
    ASSERT(phdsa);
    ASSERT(pri);
    
    hdsa = DSA_Create(sizeof(CHOOSESIDE), (int)pri->ulcNodes);
    if (hdsa)
    {
        ChooseSide_InitAsFile(hdsa, pri);
        hres = NOERROR;
    }
    else
        hres = E_OUTOFMEMORY;
    
    *phdsa = hdsa;
    
    return hres;
}


/*----------------------------------------------------------
Purpose: Create an empty array of CHOOSESIDE elements.

  Returns: standard result
  Cond:    --
*/
HRESULT PUBLIC ChooseSide_CreateEmpty(
                                      HDSA * phdsa)
{
    HRESULT hres;
    HDSA hdsa;
    
    ASSERT(phdsa);
    
    hdsa = DSA_Create(sizeof(CHOOSESIDE), 4);
    if (hdsa)
    {
        hres = NOERROR;
    }
    else
        hres = E_OUTOFMEMORY;
    
    *phdsa = hdsa;
    
    return hres;
}


/*----------------------------------------------------------
Purpose: Create an array of CHOOSESIDE elements from a foldertwin
list.  Array is unsorted.

  Returns: standard result
  
    Cond:    The contents of the array are safe as long as the 
    foldertwin list lives.
    
*/
HRESULT PUBLIC ChooseSide_CreateAsFolder(
                                         HDSA * phdsa,
                                         PFOLDERTWINLIST pftl)
{
    HRESULT hres;
    HDSA hdsa;
    CHOOSESIDE chside;
    
    ASSERT(pftl);
    
    hdsa = DSA_Create(sizeof(chside), (int)pftl->ulcItems);
    if (hdsa)
    {
        PCFOLDERTWIN pft;
        LPCTSTR pszFolderLast = NULL;
        
        // All entries start with these values
        chside.dwFlags = CSF_FOLDER;
        chside.nRank = 0;
        chside.prn = NULL;
        
        // Special case the source folder
        chside.htwin = (HTWIN)pftl->pcftFirst->hftSrc;
        chside.hvid = pftl->pcftFirst->hvidSrc;
        chside.pszFolder = pftl->pcftFirst->pcszSrcFolder;
        
        // (Don't care if this fails)
        DSA_InsertItem(hdsa, 0x7fff, &chside);
        
        // Add the other folders (duplicates skipped)
        for (pft = pftl->pcftFirst; pft; pft = pft->pcftNext)
        {
            // Duplicate?
            if (pszFolderLast && IsSzEqual(pszFolderLast, pft->pcszOtherFolder))
                continue;   // Yes (hack: the engine gives us a sorted list)
            
            chside.htwin = (HTWIN)pft->hftOther;
            chside.hvid = pft->hvidOther;
            chside.pszFolder = pft->pcszOtherFolder;
            
            DSA_InsertItem(hdsa, 0x7fff, &chside);
            
            pszFolderLast = pft->pcszOtherFolder;
        }
        *phdsa = hdsa;
        hres = NOERROR;
    }
    else
        hres = E_OUTOFMEMORY;
    
    return hres;
}


/*----------------------------------------------------------
Purpose: Reset the ranks

  Returns: --
  Cond:    --
*/
void PRIVATE ChooseSide_ResetRanks(
                                   HDSA hdsa)
{
    int i;
    int cel;
    
    ASSERT(hdsa);
    
    cel = DSA_GetItemCount(hdsa);
    for (i = 0; i < cel; i++)
    {
        PCHOOSESIDE pchside = DSA_GetItemPtr(hdsa, i);
        
        pchside->nRank = 0;
    }
}


/*----------------------------------------------------------
Purpose: Determine ranks based on whether each element in the
array is inside the briefcase.

  Returns: --
  Cond:    --
*/
void PRIVATE ChooseSide_RankForInside(
                                      HDSA hdsa,
                                      LPCTSTR pszBrfPath,      // Root path of briefcase
                                      LPCTSTR pszFolder)       // If NULL, choose best outside element
{
    int i;
    int cel;
    int cchLast = 0;
    PCHOOSESIDE pchsideLast;
    
    ASSERT(hdsa);
    ASSERT(pszBrfPath);
    ASSERT(pszFolder);
    ASSERT(PathIsPrefix(pszBrfPath, pszFolder));
    
    cel = DSA_GetItemCount(hdsa);
    for (i = 0; i < cel; i++)
    {
        PCHOOSESIDE pchside = DSA_GetItemPtr(hdsa, i);
        
        DEBUG_CODE( SetFlag(pchside->dwFlags, CSF_INSIDE); )
            
        // Is this item inside this briefcase?
        if (PathIsPrefix(pszBrfPath, pchside->pszFolder))
            pchside->nRank++;       // Yes
        
        // Is this item inside this folder?
        if (PathIsPrefix(pszFolder, pchside->pszFolder))
        {
            int cch = lstrlen(pchside->pszFolder);
            
            pchside->nRank++;       // Yes; even better
            
            if (0 == cchLast)
            {
                cchLast = cch;
                pchsideLast = pchside;
            }
            else 
            {
                // Is this path deeper than the last prefix-matching path?
                // (the path closer to the top is better)
                if (cch > cchLast)
                {
                    // Yes; demote this one 
                    pchside->nRank--;
                }
                else
                {
                    // No; demote previous one
                    ASSERT(pchsideLast);
                    pchsideLast->nRank--;
                    
                    cchLast = cch;
                    pchsideLast = pchside;
                }
            }
        }
    }
}


/*----------------------------------------------------------
Purpose: Determine ranks based on whether each element in the
array is outside the briefcase.

  Returns: --
  Cond:    --
*/
void PRIVATE ChooseSide_RankForOutside(
                                       HDSA hdsa,
                                       LPCTSTR pszBrfPath)      // Root path of briefcase
{
    int i;
    int cel;
    
    ASSERT(hdsa);
    ASSERT(pszBrfPath);
    
    cel = DSA_GetItemCount(hdsa);
    for (i = 0; i < cel; i++)
    {
        PCHOOSESIDE pchside = DSA_GetItemPtr(hdsa, i);
        
        DEBUG_CODE( ClearFlag(pchside->dwFlags, CSF_INSIDE); )
            
        // Is this item NOT in this briefcase?
        if ( !PathIsPrefix(pszBrfPath, pchside->pszFolder) )
        {
            // Yes
            int nDriveType = DRIVE_UNKNOWN;
            int ndrive = PathGetDriveNumber(pchside->pszFolder);
            
            if (-1 != ndrive)
            {
                nDriveType = DriveType(ndrive);
            }
            
            pchside->nRank += 2;
            
            if (IsFlagClear(pchside->dwFlags, CSF_FOLDER))
            {
                // Is the file unavailable?
                if (RNS_UNAVAILABLE == pchside->prn->rnstate ||
                    FS_COND_UNAVAILABLE == pchside->prn->fsCurrent.fscond)
                {
                    // Yes; demote
                    pchside->nRank--;
                }
            }
            else
            {
                // Is the folder unavailable?
                FOLDERTWINSTATUS uStatus;
                
                Sync_GetFolderTwinStatus((HFOLDERTWIN)pchside->htwin, NULL, 0, 
                    &uStatus);
                if (FTS_UNAVAILABLE == uStatus)
                {
                    // Yes; demote
                    pchside->nRank--;
                }
            }
            
            // Rank on locality of disk (the closer the better)
            if (DRIVE_REMOVABLE == nDriveType || DRIVE_CDROM == nDriveType)
                ;                       // Floppy/removable (do nothing)
            else if (PathIsUNC(pchside->pszFolder) || IsNetDrive(ndrive))
                pchside->nRank++;       // Net
            else
                pchside->nRank += 2;    // Fixed disk
        }
    }
}


/*----------------------------------------------------------
Purpose: Choose the element with the highest rank.

  Returns: TRUE if any element distinguished itself
  
    Cond:    --
*/
BOOL PRIVATE ChooseSide_GetBestRank(
                                    HDSA hdsa,
                                    PCHOOSESIDE * ppchside)
{
    BOOL bRet;
    int i;
    int cel;
    int nRankCur = 0;       // (start at 0 since 0 is not good enough to pass muster)
    DEBUG_CODE( BOOL bDbgDup = FALSE; )
        
        ASSERT(hdsa);
    ASSERT(ppchside);
    
    *ppchside = NULL;
    
    cel = DSA_GetItemCount(hdsa);
    for (i = 0; i < cel; i++)
    {
        PCHOOSESIDE pchside = DSA_GetItemPtr(hdsa, i);
        
#ifdef DEBUG
        if (0 < nRankCur && nRankCur == pchside->nRank)
            bDbgDup = TRUE;
#endif
        
        if (nRankCur < pchside->nRank)
        {
            *ppchside = pchside;
            nRankCur = pchside->nRank;
            
            DEBUG_CODE( bDbgDup = FALSE; )      // Reset
        }
    }
    
#ifdef DEBUG
    // We shouldn't get duplicate highest ranks
    if (bDbgDup)
    {
        // Dump the chooseside list if there are duplicate highest ranks
        ChooseSide_DumpList(hdsa);
    }
    ASSERT(FALSE == bDbgDup);
#endif
    
    bRet = 0 < nRankCur;
    ASSERT(bRet && *ppchside || !bRet && !*ppchside);
    
    return bRet;
}


/*----------------------------------------------------------
Purpose: Get the best candidate element (inside or outside).
If the pszFolder is NULL, this function gets the best
outside path.  

  Returns: TRUE if an element was found
  
    Cond:    --
*/
BOOL PUBLIC ChooseSide_GetBest(
                               HDSA hdsa,
                               LPCTSTR pszBrfPath,      // Root path of briefcase
                               LPCTSTR pszFolder,       // If NULL, choose best outside element
                               PCHOOSESIDE * ppchside)
{
    ASSERT(hdsa);
    ASSERT(0 < DSA_GetItemCount(hdsa));
    ASSERT(pszBrfPath);
    ASSERT(ppchside);
    
    ChooseSide_ResetRanks(hdsa);
    
    // Are we ranking for inside paths?
    if (pszFolder)
    {
        // Yes; inside wins
        ChooseSide_RankForInside(hdsa, pszBrfPath, pszFolder);
    }
    else
    {
        // No; outside wins
        ChooseSide_RankForOutside(hdsa, pszBrfPath);
    }
    
    return ChooseSide_GetBestRank(hdsa, ppchside);
}


/*----------------------------------------------------------
Purpose: Get the next best candidate element (inside or outside).
ChooseSide_GetBest must have been previously called.

  Returns: TRUE if an element was found
  
    Cond:    --
*/
BOOL PUBLIC ChooseSide_GetNextBest(
                                   HDSA hdsa,
                                   PCHOOSESIDE * ppchside)
{
    PCHOOSESIDE pchside;
    
    ASSERT(hdsa);
    ASSERT(0 < DSA_GetItemCount(hdsa));
    ASSERT(ppchside);
    
    // Get the best rank and reset it
    ChooseSide_GetBestRank(hdsa, &pchside);
    pchside->nRank = 0;
    
    // Now get the next best rank
    return ChooseSide_GetBestRank(hdsa, ppchside);
}


/*----------------------------------------------------------
Purpose: Frees an array of CHOOSESIDE elements.

  Returns: --
  Cond:    --
*/
void PUBLIC ChooseSide_Free(
                            HDSA hdsa)
{
    if (hdsa)
    {
        DSA_Destroy(hdsa);
    }
}


//---------------------------------------------------------------------------
// 
//---------------------------------------------------------------------------


/*----------------------------------------------------------
Purpose: Determine which node is inside and outside a briefcase.

  This function takes a list of recnodes and determines
  which node is "inside" a briefcase and which one is
  "outside" a briefcase.  "Inside" means the file exists 
  somewhere underneath the briefcase path indicated by 
  atomBrf.  "Outside" is anywhere else (but may be in 
  a different briefcase as well).
  
    Returns: --
    Cond:    --
*/
HRESULT PUBLIC Sync_GetNodePair(
                                PRECITEM pri,
                                LPCTSTR pszBrfPath,
                                LPCTSTR pszInsideDir,            // Which folder inside the briefcase to consider
                                PRECNODE  * pprnInside,
                                PRECNODE  * pprnOutside)     
{
    HRESULT hres;
    HDSA hdsa;
    
    ASSERT(pri);
    ASSERT(pszBrfPath);
    ASSERT(pszInsideDir);
    ASSERT(pprnInside);
    ASSERT(pprnOutside);
    ASSERT(PathIsPrefix(pszBrfPath, pszInsideDir));
    
    hres = ChooseSide_CreateAsFile(&hdsa, pri);
    if (SUCCEEDED(hres))
    {
        PCHOOSESIDE pchside;
        
        // Get inside folder
        if (ChooseSide_GetBest(hdsa, pszBrfPath, pszInsideDir, &pchside))
        {
            *pprnInside = pchside->prn;
        }
        else
        {
            ASSERT(0);
            *pprnInside = NULL;
            hres = E_FAIL;
        }
        
        // Get outside folder
        if (ChooseSide_GetBest(hdsa, pszBrfPath, NULL, &pchside))
        {
            *pprnOutside = pchside->prn;
        }
        else
        {
            ASSERT(0);
            *pprnOutside = NULL;
            hres = E_FAIL;
        }
        
#ifdef DEBUG
        
        if (SUCCEEDED(hres) && IsFlagSet(g_uDumpFlags, DF_PATHS))
        {
            TRACE_MSG(TF_ALWAYS, TEXT("Choosing pairs: %s and %s"), (*pprnInside)->pcszFolder,
                (*pprnOutside)->pcszFolder);
        }
        
#endif
        
        ChooseSide_Free(hdsa);
    }
    else
    {
        *pprnInside = NULL;
        *pprnOutside = NULL;
    }
    return hres;
}



/*----------------------------------------------------------
Purpose: Checks if we've loaded the sync engine
Returns: TRUE if loaded
Cond:    --
*/
BOOL PUBLIC Sync_IsEngineLoaded()
{
    BOOL bRet;
    
    ENTEREXCLUSIVE();
    {
        bRet = g_vtblEngine[0].hinst != NULL;
    }
    LEAVEEXCLUSIVE();
    
    return bRet;
}


/*----------------------------------------------------------
Purpose: Load the SYNCENG.DLL and initialize the v-table.
Returns: TRUE on success
Cond:    --
*/
BOOL PUBLIC Sync_QueryVTable(void)
{
    BOOL bRet = TRUE;
    HINSTANCE hinst;
    
    ENTEREXCLUSIVE();
    {
        hinst = g_vtblEngine[0].hinst;
    }
    LEAVEEXCLUSIVE();
    
    // We want to assure that the engine is loaded the same
    //  number of times that SYNCUI is (by a process).  This prevents
    //  Kernel from nuking the engine prematurely (if a
    //  process is terminated).
    //
    // We go thru these hoops simply because SYNCUI does not
    //  load SYNCENG immediately upon PROCESS_ATTACH.  We wait
    //  until we *really* need to load it the first time.
    //  Once we finally do load it, we need to keep the load
    //  count current.
    //
    // Kernel frees SYNCUI and SYNCENG for us.
    //
    if (NULL == hinst)
    {
        VTBLENGINE vtbl;
        
        DEBUG_CODE( TRACE_MSG(TF_GENERAL, TEXT("Loading %s (cProcess = %d)"),
            (LPCTSTR)c_szEngineDLL, g_cProcesses); )
            
            ZeroInit(&vtbl, sizeof(VTBLENGINE));
        
        // Don't be in the critical section when we load the DLL
        // or call GetProcAddress, since our LibMain can block on
        // this critical section.
        ASSERT_NOT_EXCLUSIVE();
        
        hinst = LoadLibrary(c_szEngineDLL);
        
        if ( ISVALIDHINSTANCE(hinst) )
        {
            // We are loading for the first time.  Fill the vtable.
            //
            vtbl.hinst = hinst;
            
            // Get all the function addresses
            //
            GetFunction(vtbl, OpenBriefcase, OPENBRIEFCASEINDIRECT);
            GetFunction(vtbl, SaveBriefcase, SAVEBRIEFCASEINDIRECT);
            GetFunction(vtbl, CloseBriefcase, CLOSEBRIEFCASEINDIRECT);
            GetFunction(vtbl, ClearBriefcaseCache, CLEARBRIEFCASECACHEINDIRECT);
            GetFunction(vtbl, DeleteBriefcase, DELETEBRIEFCASEINDIRECT);
            GetFunction(vtbl, GetOpenBriefcaseInfo, GETOPENBRIEFCASEINFOINDIRECT);
            GetFunction(vtbl, FindFirstBriefcase, FINDFIRSTBRIEFCASEINDIRECT);
            GetFunction(vtbl, FindNextBriefcase, FINDNEXTBRIEFCASEINDIRECT);
            GetFunction(vtbl, FindBriefcaseClose, FINDBRIEFCASECLOSEINDIRECT);
            
            GetFunction(vtbl, AddObjectTwin, ADDOBJECTTWININDIRECT);
            GetFunction(vtbl, AddFolderTwin, ADDFOLDERTWININDIRECT);
            GetFunction(vtbl, ReleaseTwinHandle, RELEASETWINHANDLEINDIRECT);
            GetFunction(vtbl, DeleteTwin, DELETETWININDIRECT);
            GetFunction(vtbl, GetObjectTwinHandle, GETOBJECTTWINHANDLEINDIRECT);
            GetFunction(vtbl, IsFolderTwin, ISFOLDERTWININDIRECT);
            GetFunction(vtbl, CreateFolderTwinList, CREATEFOLDERTWINLISTINDIRECT);
            GetFunction(vtbl, DestroyFolderTwinList, DESTROYFOLDERTWINLISTINDIRECT);
            GetFunction(vtbl, GetFolderTwinStatus, GETFOLDERTWINSTATUSINDIRECT);
            GetFunction(vtbl, IsOrphanObjectTwin, ISORPHANOBJECTTWININDIRECT);
            GetFunction(vtbl, CountSourceFolderTwins, COUNTSOURCEFOLDERTWINSINDIRECT);
            GetFunction(vtbl, AnyTwins, ANYTWINSINDIRECT);
            
            GetFunction(vtbl, CreateTwinList, CREATETWINLISTINDIRECT);
            GetFunction(vtbl, DestroyTwinList, DESTROYTWINLISTINDIRECT);
            GetFunction(vtbl, AddTwinToTwinList, ADDTWINTOTWINLISTINDIRECT);
            GetFunction(vtbl, AddAllTwinsToTwinList, ADDALLTWINSTOTWINLISTINDIRECT);
            GetFunction(vtbl, RemoveTwinFromTwinList, REMOVETWINFROMTWINLISTINDIRECT);
            GetFunction(vtbl, RemoveAllTwinsFromTwinList, REMOVEALLTWINSFROMTWINLISTINDIRECT);
            
            GetFunction(vtbl, CreateRecList, CREATERECLISTINDIRECT);
            GetFunction(vtbl, DestroyRecList, DESTROYRECLISTINDIRECT);
            GetFunction(vtbl, ReconcileItem, RECONCILEITEMINDIRECT);
            GetFunction(vtbl, BeginReconciliation, BEGINRECONCILIATIONINDIRECT);
            GetFunction(vtbl, EndReconciliation, ENDRECONCILIATIONINDIRECT);
            
            GetFunction(vtbl, IsPathOnVolume, ISPATHONVOLUMEINDIRECT);
            GetFunction(vtbl, GetVolumeDescription, GETVOLUMEDESCRIPTIONINDIRECT);
        }
        else
        {
            bRet = FALSE;
        }
        
        ENTEREXCLUSIVE();
        {
            g_vtblEngine[0] = vtbl;
        }
        LEAVEEXCLUSIVE();
    }
    
    return bRet;
}


/*----------------------------------------------------------
Purpose: Free the engine DLL if it is loaded
Returns: --
Cond:    --
*/
void PUBLIC Sync_ReleaseVTable()
{
    HINSTANCE hinst;
    
    ENTEREXCLUSIVE();
    {
        hinst = g_vtblEngine[0].hinst;
    }
    LEAVEEXCLUSIVE();
    
    if (NULL != hinst)
    {
        DEBUG_CODE( TRACE_MSG(TF_GENERAL, TEXT("Freeing %s (cProcess = %d)"),
            (LPCTSTR)c_szEngineDLL, g_cProcesses); )
            
            // We must call FreeLibrary() on the sync engine even during a
            //  PROCESS_DETACH.  We may be getting detached from a process even
            //  though the process isn't being terminated.  If we don't unload
            //  the sync engine now, it won't be unloaded until the process is
            //  terminated.
            //
            FreeLibrary(hinst);
        
        ENTEREXCLUSIVE();
        {
            ZeroInit(&g_vtblEngine[0], sizeof(VTBLENGINE));
        }
        LEAVEEXCLUSIVE();
    }
    
#ifdef DEBUG
    
    ENTEREXCLUSIVE();
    {
        ASSERT(g_vtblEngine[0].hinst == NULL);
    }
    LEAVEEXCLUSIVE();
    
#endif
}


/*----------------------------------------------------------
Purpose: Set the last sync error.
Returns: same twinresult
Cond:    --
*/
TWINRESULT PUBLIC Sync_SetLastError(
                                    TWINRESULT tr)
{
    ENTEREXCLUSIVE();
    {
        ASSERTEXCLUSIVE();
        
        MySetTwinResult(tr);
    }
    LEAVEEXCLUSIVE();
    
    return tr;
}


/*----------------------------------------------------------
Purpose: Get the last sync error.
Returns: twinresult
Cond:    --
*/
TWINRESULT PUBLIC Sync_GetLastError()
{
    TWINRESULT tr;
    
    ENTEREXCLUSIVE();
    {
        ASSERTEXCLUSIVE();
        
        tr = MyGetTwinResult();
    }
    LEAVEEXCLUSIVE();
    
    return tr;
}


/*----------------------------------------------------------
Purpose: Returns the number of recitems that would require 
some reconciliation.

  Returns: see above
  Cond:    --
*/
ULONG PUBLIC CountActionItems(
                              PRECLIST prl)
{
    PRECITEM pri;
    ULONG ulc;
    
    for (pri = prl->priFirst, ulc = 0; pri; pri = pri->priNext)
    {
        if (IsFileRecItem(pri) &&
            RIU_SKIP != pri->dwUser &&
            RIA_NOTHING != pri->riaction &&
            RIA_BROKEN_MERGE != pri->riaction)
        {
            ulc++;
            pri->dwUser = RIU_SHOWSTATUS;
        }
    }
    
    
    return ulc;
}


/*----------------------------------------------------------
Purpose: Displays appropriate error message on update errors
Returns: --
Cond:    --
*/
void PRIVATE HandleUpdateErrors(
                                HWND hwndOwner,
                                HRESULT hres,
                                UINT uFlags)        // RF_*
{
    // Is this an update while adding files?
    if (IsFlagSet(uFlags, RF_ONADD))
    {
        // Yes
        static SETbl const c_rgseUpdateOnAdd[] = {
            // The out of memory message should be handled by caller
            { E_TR_DEST_OPEN_FAILED,    IDS_ERR_ADD_READONLY,    MB_WARNING },
            { E_TR_DEST_WRITE_FAILED,   IDS_ERR_ADD_FULLDISK,    MB_WARNING },
            { E_TR_UNAVAILABLE_VOLUME,  IDS_ERR_ADD_UNAVAIL_VOL, MB_WARNING },
            { E_TR_SRC_OPEN_FAILED,     IDS_ERR_ADD_SOURCE_FILE, MB_WARNING },
        };
        
        SEMsgBox(hwndOwner, IDS_CAP_ADD, hres, c_rgseUpdateOnAdd, ARRAYSIZE(c_rgseUpdateOnAdd));
    }
    else
    {
        // No
        static SETbl const c_rgseUpdate[] = {
            { E_TR_OUT_OF_MEMORY,       IDS_OOM_UPDATE,         MB_ERROR },
            { E_TR_DEST_OPEN_FAILED,    IDS_ERR_READONLY,       MB_INFO },
            { E_TR_DEST_WRITE_FAILED,   IDS_ERR_FULLDISK,       MB_WARNING },
            { E_TR_UNAVAILABLE_VOLUME,  IDS_ERR_UPD_UNAVAIL_VOL,MB_WARNING },
            { E_TR_FILE_CHANGED,        IDS_ERR_FILE_CHANGED,   MB_INFO },
            { E_TR_SRC_OPEN_FAILED,     IDS_ERR_SOURCE_FILE,    MB_WARNING },
        };
        
        SEMsgBox(hwndOwner, IDS_CAP_UPDATE, hres, c_rgseUpdate, ARRAYSIZE(c_rgseUpdate));
    }
}


typedef struct tagPROGPARAM
{
    HWND hwndProgress;
    WORD wPosMax;
    WORD wPosBase;
    WORD wPosPrev;
    BOOL bSkip;
} PROGPARAM, * PPROGPARAM;

/*----------------------------------------------------------
Purpose: Status procedure that is called during a single 
ReconcileItem call.

  Returns: varies
  Cond:    --
*/
BOOL CALLBACK RecStatusProc(
                            RECSTATUSPROCMSG msg,
                            LPARAM lParam,
                            LPARAM lParamUser)
{
    BOOL bRet;
    PRECSTATUSUPDATE prsu = (PRECSTATUSUPDATE)lParam;
    PPROGPARAM pprogparam = (PPROGPARAM)lParamUser;
    HWND hwndProgress = pprogparam->hwndProgress;
    WORD wPos;
    
    bRet = !UpdBar_QueryAbort(hwndProgress);
    
    switch (msg)
    {
    case RS_BEGIN_COPY:
    case RS_DELTA_COPY:
    case RS_END_COPY:
    case RS_BEGIN_MERGE:
    case RS_DELTA_MERGE:
    case RS_END_MERGE:
#ifdef NEW_REC
    case RS_BEGIN_DELETE:
    case RS_DELTA_DELETE:
    case RS_END_DELETE:
#endif
        TRACE_MSG(TF_PROGRESS, TEXT("Reconcile progress = %lu of %lu"), prsu->ulProgress, prsu->ulScale);
        ASSERT(prsu->ulProgress <= prsu->ulScale);
        
        if (0 < prsu->ulScale && !pprogparam->bSkip)
        {
            wPos = LOWORD(LODWORD( (((__int64)pprogparam->wPosMax * prsu->ulProgress) / prsu->ulScale) ));
            
            TRACE_MSG(TF_PROGRESS, TEXT("Max wPos = %u,  new wPos = %u,  old wPos = %u"), 
                pprogparam->wPosMax, wPos, pprogparam->wPosPrev);
            
            if (wPos > pprogparam->wPosPrev && wPos < pprogparam->wPosMax)
            {
                WORD wPosReal = pprogparam->wPosBase + wPos;
                
                TRACE_MSG(TF_PROGRESS, TEXT("Setting real position = %u"), wPosReal);
                
                UpdBar_SetPos(hwndProgress, wPosReal);
                pprogparam->wPosPrev = wPos;
            }
        }
        break;
        
    default:
        ASSERT(0);
        break;
    }
    
    return bRet;
}


/*----------------------------------------------------------
Purpose: Decides the description string while updating.  The
string is something like "Copying from 'Foo' to 'Bar'"
or "Merging files in 'Foo' and 'Bar'"

  Returns: string in pszBuf
  
    Cond:    --
*/
void PRIVATE DecideDescString(
                              LPCTSTR pszBrfPath,
                              PRECITEM pri,
                              LPTSTR pszBuf,
                              int cbBuf,
                              LPTSTR pszPathBuf)
{
    HRESULT hres;
    RA_ITEM * pitem;
    
    ASSERT(pszBrfPath);
    ASSERT(pri);
    ASSERT(pszBuf);
    
    hres = RAI_CreateFromRecItem(&pitem, pszBrfPath, pri);
    if (SUCCEEDED(hres))
    {
        UINT ids;
        LPTSTR pszMsg;
        LPCTSTR pszFrom;
        LPCTSTR pszTo;
        
        lstrcpy(pszPathBuf, pitem->siInside.pszDir);
        PathAppend(pszPathBuf, pitem->pszName);
        
        switch (pitem->uAction)
        {
        case RAIA_TOOUT:
            ids = IDS_UPDATE_Copy;
            pszFrom = PathFindFileName(pitem->siInside.pszDir);
            pszTo = PathFindFileName(pitem->siOutside.pszDir);
            break;
            
        case RAIA_TOIN:
            ids = IDS_UPDATE_Copy;
            pszFrom = PathFindFileName(pitem->siOutside.pszDir);
            pszTo = PathFindFileName(pitem->siInside.pszDir);
            break;
            
        case RAIA_MERGE:
            ids = IDS_UPDATE_Merge;
            // (Arbitrary)
            pszFrom = PathFindFileName(pitem->siInside.pszDir);
            pszTo = PathFindFileName(pitem->siOutside.pszDir);
            break;
            
        case RAIA_DELETEOUT:
            ids = IDS_UPDATE_Delete;
            pszFrom = PathFindFileName(pitem->siOutside.pszDir);
            pszTo = NULL;
            break;
            
        case RAIA_DELETEIN:
            ids = IDS_UPDATE_Delete;
            pszFrom = PathFindFileName(pitem->siInside.pszDir);
            pszTo = NULL;
            break;
            
        default:
            ASSERT(0);
            ids = 0;
            break;
        }
        
        if (ConstructMessage(&pszMsg, g_hinst, MAKEINTRESOURCE(ids), 
            pszFrom, pszTo))
        {
            lstrcpyn(pszBuf, pszMsg, cbBuf);
            GFree(pszMsg);
        }
        else
            *pszBuf = 0;
    }
    else
        *pszBuf = 0;
}


/*----------------------------------------------------------
Purpose: Reconcile a given reclist

  Returns: standard result
  Cond:    --
*/
HRESULT PUBLIC Sync_ReconcileRecList(
                                     PRECLIST prl,       // ptr to reclist
                                     LPCTSTR pszBrfPath,
                                     HWND hwndProgress,
                                     UINT uFlags)        // RF_*
{
    HRESULT hres;
    
    if (prl)
    {
        HWND hwndOwner = GetParent(hwndProgress);
        HWND hwndStatusText = UpdBar_GetStatusWindow(hwndProgress);
        TCHAR szPath[MAX_PATH];
        TCHAR sz[MAXBUFLEN];
        TWINRESULT tr;
        PRECITEM pri;
        PROGPARAM progparam;
        ULONG ulcItems;
        WORD wDelta;
        
        DEBUG_CODE( Sync_DumpRecList(TR_SUCCESS, prl, TEXT("Updating")); )
            
        hres = NOERROR;     // assume success
        
        // Grab the mutex to delay any further calculation in any
        // Briefcase views' secondary threads until we're done 
        // processing here.
        Delay_Own();
        
        // Determine the range of the progress bar
        UpdBar_SetRange(hwndProgress, MAX_RANGE);
        
        ulcItems = CountActionItems(prl);
        if (0 < ulcItems)
            wDelta = (WORD)(MAX_RANGE / ulcItems);
        else
            wDelta = 0;
        
        progparam.hwndProgress = hwndProgress;
        
        // Start updating
        Sync_BeginRec(prl->hbr);
        
        ulcItems = 0;           
        for (pri = prl->priFirst; pri; pri = pri->priNext)
        {
            // Did the user explicitly skip this recitem or
            // is this a broken merge?
            if (RIU_SKIP == pri->dwUser ||
                RIA_BROKEN_MERGE == pri->riaction)
            {
                // Yes; don't call ReconcileItem
                continue;
            }
            
            // Is something going to be done to this recitem?
            if (RIU_SHOWSTATUS == pri->dwUser)
            {
                // Yes; update the name of the file we're updating
                UpdBar_SetName(hwndProgress, pri->pcszName);
                DecideDescString(pszBrfPath, pri, sz, ARRAYSIZE(sz), szPath);
                UpdBar_SetDescription(hwndProgress, sz);
                
                ASSERT(0 < wDelta);
                progparam.wPosBase = (WORD)(wDelta * ulcItems);
                progparam.wPosMax = wDelta;
                progparam.wPosPrev = 0;
                progparam.bSkip = FALSE;
            }
            else
            {
                progparam.bSkip = TRUE;
            }
            
            // Call ReconcileItem even for nops, so the recnode states
            // will be updated by the engine.
            tr = Sync_ReconcileItem(pri, RecStatusProc, (LPARAM)&progparam, 
                RI_FL_FEEDBACK_WINDOW_VALID, hwndProgress, hwndStatusText);
            if (TR_SUCCESS != tr &&
                IsFileRecItem(pri))     // ignore folder recitem errors
            {
                // On some conditions, stop updating completely
                hres = HRESULT_FROM_TR(tr);
                
                switch (hres)
                {
                case E_TR_OUT_OF_MEMORY:
                case E_TR_RH_LOAD_FAILED: {
                    // Couldn't load the merge handler.  Tell the user but
                    // continue on...
                    int id = MsgBox(hwndOwner, 
                        MAKEINTRESOURCE(IDS_ERR_NO_MERGE_HANDLER), 
                        MAKEINTRESOURCE(IDS_CAP_UPDATE),
                        NULL,
                        MB_WARNING | MB_OKCANCEL,
                        PathGetDisplayName(szPath, sz));
                    
                    if (IDOK == id)
                        break;      // continue updating other files
                                          }
                    
                    goto StopUpdating;
                    
                case E_TR_DELETED_TWIN:
                    // Allow the updating to continue.
                    break;
                    
                case E_TR_DEST_OPEN_FAILED:
                case E_TR_FILE_CHANGED:
                    if (IsFlagClear(uFlags, RF_ONADD))
                    {
                        // Allow the updating to continue.  Remember the
                        // latest error for the end.
                        break;
                    }
                    // Fall thru
                    //   |   |
                    //   v   v
                    
                default:
                    goto StopUpdating;
                }
            }
            
            // Was something done to this recitem?
            if (RIU_SHOWSTATUS == pri->dwUser)
            {
                // Yes; update the progress bar
                UpdBar_SetPos(hwndProgress, (WORD)(wDelta * ++ulcItems));
            }
            
            // Check if the Cancel button was pressed
            if (UpdBar_QueryAbort(hwndProgress))
            {
                hres = E_ABORT;
                break;
            }
        }
        
StopUpdating:
        if (FAILED(hres))
        {
            Sync_DumpRecItem(tr, pri, NULL);
            HandleUpdateErrors(hwndOwner, hres, uFlags);
            
            if (IsFlagSet(uFlags, RF_ONADD))
            {
                // Hack: since the caller also handles some error messages,
                // return a generic failure code to prevent repeated
                // error messages.
                hres = E_FAIL;
            }
        }
        // Were there any items at all?
        else if (0 == prl->ulcItems)
        {
            // No
            MsgBox(hwndOwner, MAKEINTRESOURCE(IDS_MSG_NoMatchingFiles), 
                MAKEINTRESOURCE(IDS_CAP_UPDATE), NULL, MB_INFO);
        }
        
        Sync_EndRec(prl->hbr);
        
        Delay_Release();
    }
    else
        hres = E_INVALIDARG;
    
    return hres;
}
    
    
/*----------------------------------------------------------
Purpose: Status procedure that is called during a single 
ReconcileItem call.

Returns: varies
Cond:    --
*/
BOOL CALLBACK CreateRecListProc(
                                CREATERECLISTPROCMSG msg,
                                LPARAM lParam,
                                LPARAM lParamUser)
{
    return !AbortEvt_Query((PABORTEVT)lParamUser);
}
  
  
/*----------------------------------------------------------
Purpose: Creates a reclist and optionally shows a progress
bar during the creation.

  Returns: standard result
  Cond:    --
*/
HRESULT PUBLIC Sync_CreateRecListEx(
                                    HTWINLIST htl,
                                    PABORTEVT pabortevt,
                                    PRECLIST * pprl)
{
    TWINRESULT tr;
    
    ASSERT(pprl);
    
    tr = Sync_CreateRecList(htl, CreateRecListProc, (LPARAM)pabortevt, pprl);
    return HRESULT_FROM_TR(tr);
}


/*----------------------------------------------------------
Purpose: Return true if the file or folder is a twin.

  There are some cases when this function cannot successfully
  determine this unless the caller first tells it explicitly 
  whether the object is a file or folder.  Otherwise this
  function will attempt to determine this on its own.
  
    Returns: S_OK if it is a twin
    S_FALSE if it is not
    any other is an error
    
      Cond:    --
*/
HRESULT PUBLIC Sync_IsTwin(
                           HBRFCASE hbrfcase,
                           LPCTSTR pszPath,
                           UINT uFlags)        // SF_* flags
{
    HRESULT hres;
    TWINRESULT tr;
    
    ASSERT(pszPath);
    
    // The caller may already know whether this is a twin or not.
    // Remind him.
    if (IsFlagSet(uFlags, SF_ISTWIN))
        return S_OK;
    else if (IsFlagSet(uFlags, SF_ISNOTTWIN))
        return S_FALSE;
    
    // Is this a folder?
    if (IsFlagSet(uFlags, SF_ISFOLDER) ||
        PathIsDirectory(pszPath))
    {
        // Yes; is it a twin?
        BOOL bRet;
        
        tr = Sync_IsFolder(hbrfcase, pszPath, &bRet);
        if (TR_SUCCESS == tr)
        {
            // Yes/no
            hres = bRet ? S_OK : S_FALSE;
        }
        else
        {
            // Error
            hres = HRESULT_FROM_TR(tr);
        }
    }
    else
    {
        // No
        HOBJECTTWIN hot;
        TCHAR szDir[MAX_PATH];
        
        lstrcpy(szDir, pszPath);
        PathRemoveFileSpec(szDir);
        tr = Sync_GetObject(hbrfcase, szDir, PathFindFileName(pszPath), &hot);
        if (TR_SUCCESS == tr)
        {
            // Is it a twin?
            if (NULL != hot)
            {
                // Yes
                Sync_ReleaseTwin(hot);
                hres = S_OK;
            }
            else
            {
                // No; (no need to release a null handle)
                hres = S_FALSE;
            }
        }
        else
        {
            // Error
            hres = HRESULT_FROM_TR(tr);
        }
    }
    
    return hres;
}


/*----------------------------------------------------------
Purpose: Create a reclist with everything in it.

  Returns: standard result
  
    Cond:    Caller must destroy the reclist
*/
HRESULT PUBLIC Sync_CreateCompleteRecList(
                                          HBRFCASE hbrf,
                                          PABORTEVT pabortevt,
                                          PRECLIST * pprl)
{
    HRESULT hres = E_OUTOFMEMORY;
    HTWINLIST htl;
    
    ASSERT(pprl);
    
    *pprl = NULL;
    
    if (TR_SUCCESS == Sync_CreateTwinList(hbrf, &htl))
    {
        Sync_AddAllToTwinList(htl);
        
        hres = Sync_CreateRecListEx(htl, pabortevt, pprl);
        Sync_DestroyTwinList(htl);
    }
    
    return hres;
}


/*----------------------------------------------------------
Purpose: Add a twin to the twinlist given the pathname.  If the
pathname is not a twin, we don't add it.

  Returns: TRUE on success, even when this isn't a twin
  
    Cond:    Caller must destroy the folder list if lplpftl is not NULL
*/
BOOL PUBLIC Sync_AddPathToTwinList(
                                   HBRFCASE hbrf,
                                   HTWINLIST htl,
                                   LPCTSTR lpcszPath,               // Path
                                   PFOLDERTWINLIST  * lplpftl)  // May be NULL
{
    BOOL bRet = FALSE;
    
    ASSERT(lpcszPath);
    ASSERT(htl);
    
    if (lplpftl)
        *lplpftl = NULL;
    
    if (lpcszPath)
    {
        if (PathIsDirectory(lpcszPath))
        {
            BOOL fIsTwin = FALSE;
            PFOLDERTWINLIST lpftl;
            
            // We only want to return false if we couldn't mark something
            //  that should have been marked.  If this isn't a twin,
            //  we still succeed.
            
            bRet = TRUE;
            
            Sync_IsFolder(hbrf, lpcszPath, &fIsTwin);
            if (fIsTwin)        // Is this actually twinned?
            {
                // This is a folder twin.  Add to reclist "the folder way".
                //
                if (Sync_CreateFolderList(hbrf, lpcszPath, &lpftl) != TR_SUCCESS)
                    bRet = FALSE;
                else
                {
                    PCFOLDERTWIN lpcfolder;
                    
                    ASSERT(lpftl->pcftFirst);
                    
                    // only mark the ones that aren't in other briefcases
                    //
                    lpcfolder = lpftl->pcftFirst;
                    while (lpcfolder)
                    {
                        Sync_AddToTwinList(htl, lpcfolder->hftOther);
                        
                        lpcfolder = lpcfolder->pcftNext;
                    }
                    
                    if (lplpftl)
                        *lplpftl = lpftl;
                    else
                        Sync_DestroyFolderList(lpftl);
                }
            }
        }
        else
        {
            HOBJECTTWIN hot = NULL;
            TCHAR szDir[MAX_PATH];
            
            // Add the twins to the reclist "the object way"
            //
            lstrcpy(szDir, lpcszPath);
            PathRemoveFileSpec(szDir);
            Sync_GetObject(hbrf, szDir, PathFindFileName(lpcszPath), &hot);
            
            if (hot)                // Is this actually a twin?
            {
                // yep
                Sync_AddToTwinList(htl, hot);
                Sync_ReleaseTwin(hot);
            }
            if (lplpftl)
                *lplpftl = NULL;
            bRet = TRUE;
        }
    }
    
    return bRet;
}


/*----------------------------------------------------------
Purpose: Asks the user to confirm splitting one or more files.

  Returns: IDYES or IDNO
  Cond:    --
*/
int PRIVATE ConfirmSplit(
                         HWND hwndOwner,
                         LPCTSTR pszPath,
                         UINT cFiles)
{
    int idRet;
    
    ASSERT(pszPath);
    ASSERT(1 <= cFiles);
    
    // Multiple files?
    if (1 < cFiles)
    {
        // Yes
        idRet = MsgBox(hwndOwner, 
            MAKEINTRESOURCE(IDS_MSG_ConfirmMultiSplit), 
            MAKEINTRESOURCE(IDS_CAP_ConfirmMultiSplit), 
            LoadIcon(g_hinst, MAKEINTRESOURCE(IDI_SPLIT_MULT)), 
            MB_QUESTION,
            cFiles);
    }
    else
    {
        // No
        UINT ids;
        UINT idi;
        TCHAR szName[MAX_PATH];
        
        if (PathIsDirectory(pszPath))
        {
            ids = IDS_MSG_ConfirmFolderSplit;
            idi = IDI_SPLIT_FOLDER;
        }
        else
        {
            ids = IDS_MSG_ConfirmFileSplit;
            idi = IDI_SPLIT_FILE;
        }
        
        idRet = MsgBox(hwndOwner, 
            MAKEINTRESOURCE(ids), 
            MAKEINTRESOURCE(IDS_CAP_ConfirmSplit), 
            LoadIcon(g_hinst, MAKEINTRESOURCE(idi)), 
            MB_QUESTION,
            PathGetDisplayName(pszPath, szName));
    }
    return idRet;
}


/*----------------------------------------------------------
Purpose: Splits a path from its sync copy.  Private function
called by Sync_Split.

  Returns: standard result
  S_OK if it is split
  
    Cond:    --
*/
HRESULT PRIVATE SplitPath(
                          HBRFCASE hbrf,
                          LPCTSTR pszPath,
                          HWND hwndOwner,
                          UINT uFlags)            // SF_* flags
{
    HRESULT hres;
    TWINRESULT tr;
    TCHAR sz[MAX_PATH];
    
    if (pszPath)
    {
        // Is the object a folder?
        if (IsFlagSet(uFlags, SF_ISFOLDER) || 
            PathIsDirectory(pszPath))
        {
            // Yup
            BOOL bIsTwin;
            
            if (IsFlagSet(uFlags, SF_ISTWIN))           // Optimization
            {
                tr = TR_SUCCESS;
                bIsTwin = TRUE;
            }
            else if (IsFlagSet(uFlags, SF_ISNOTTWIN))   // Optimization
            {
                tr = TR_SUCCESS;
                bIsTwin = FALSE;
            }
            else
            {
                tr = Sync_IsFolder(hbrf, pszPath, &bIsTwin);
            }
            
            // Is this folder a twin?
            if (TR_SUCCESS == tr)
            {
                if (bIsTwin)
                {
                    // Yes; delete all the twin handles associated with it
                    PFOLDERTWINLIST lpftl;
                    
                    tr = Sync_CreateFolderList(hbrf, pszPath, &lpftl);
                    if (TR_SUCCESS == tr)
                    {
                        PCFOLDERTWIN lpcfolder;
                        
                        ASSERT(lpftl);
                        
                        for (lpcfolder = lpftl->pcftFirst; lpcfolder; 
                        lpcfolder = lpcfolder->pcftNext)
                        {
                            Sync_DeleteTwin(lpcfolder->hftOther);
                        }
                        
                        Sync_DestroyFolderList(lpftl);
                        
                        if (IsFlagClear(uFlags, SF_QUIET))
                        {
                            // Send a notification so it is redrawn.
                            PathNotifyShell(pszPath, NSE_UPDATEITEM, FALSE);
                        }
                        hres = NOERROR;
                    }
                }
                else if (IsFlagClear(uFlags, SF_QUIET))
                {
                    // No
                    MsgBox(hwndOwner, 
                        MAKEINTRESOURCE(IDS_MSG_FolderAlreadyOrphan),
                        MAKEINTRESOURCE(IDS_CAP_Split), 
                        LoadIcon(g_hinst, MAKEINTRESOURCE(IDI_SPLIT_FOLDER)), 
                        MB_INFO,
                        PathGetDisplayName(pszPath, sz));
                    
                    hres = S_FALSE;
                }
                else
                {
                    hres = S_FALSE;
                }
            }
        }
        else
        {
            // No; it is a file
            HOBJECTTWIN hot;
            ULONG ulc;
            
            lstrcpy(sz, pszPath);
            PathRemoveFileSpec(sz);
            
            // Is this file a twin?
            // (We need the twin handle below, so we cannot take 
            // advantage of SF_ISTWIN or SF_ISNOTTWIN.)
            tr = Sync_GetObject(hbrf, sz, PathFindFileName(pszPath), &hot);
            
            if (TR_SUCCESS == tr)
            {
                if (hot)
                {
                    // Yes; is this inside a folder twin?
                    // (If we remove this check, the engine needs to be able
                    // to exclude specific files from a folder twin.)
                    tr = Sync_CountSourceFolders(hot, &ulc);
                    if (TR_SUCCESS == tr)
                    {
                        if (0 < ulc)
                        {
                            // Yes; can't do it
                            if (IsFlagClear(uFlags, SF_QUIET))
                            {
                                UINT rgids[2] = { IDS_ERR_1_CantSplit, IDS_ERR_2_CantSplit };
                                LPTSTR psz;
                                
                                if (FmtString(&psz, IDS_ERR_F_CantSplit, rgids, ARRAYSIZE(rgids)))
                                {
                                    // This object twin belongs to a folder twin.  We can't
                                    //  allow this action.
                                    MsgBox(hwndOwner, psz, MAKEINTRESOURCE(IDS_CAP_STATUS), 
                                        LoadIcon(g_hinst, MAKEINTRESOURCE(IDI_SPLIT_FILE)), MB_ERROR);
                                    GFree(psz);
                                }
                            }
                            hres = S_FALSE;
                        }
                        else
                        {
                            // No; delete the twin
                            Sync_DeleteTwin(hot);
                            
                            if (IsFlagClear(uFlags, SF_QUIET))
                            {
                                // Send a notification so it's redrawn immediately.
                                PathNotifyShell(pszPath, NSE_UPDATEITEM, FALSE);
                            }
                            hres = NOERROR;
                        }
                    }
                    
                    Sync_ReleaseTwin(hot);
                }
                else if (IsFlagClear(uFlags, SF_QUIET))
                {
                    // No
                    MsgBox(hwndOwner, 
                        MAKEINTRESOURCE(IDS_MSG_FileAlreadyOrphan), 
                        MAKEINTRESOURCE(IDS_CAP_Split), 
                        LoadIcon(g_hinst, MAKEINTRESOURCE(IDI_SPLIT_FILE)), 
                        MB_INFO,
                        PathGetDisplayName(pszPath, sz));
                    
                    hres = S_FALSE;
                }
            }
        }
        
        if (TR_SUCCESS != tr)
            hres = HRESULT_FROM_TR(tr);
    }
    else
        hres = S_FALSE;
    
    return hres;
}


/*----------------------------------------------------------
Purpose: Deletes a series of twins from the engine database.
The user is optionally asked to confirm the action.

  If a file is an orphan, the user is optionally 
  notified.  The user is also optionally notified
  of any errors.
  
Returns: standard result
S_OK if anything was deleted

Cond:    --
*/
HRESULT PUBLIC Sync_Split(
                          HBRFCASE hbrf,
                          LPCTSTR pszList,
                          UINT cFiles,
                          HWND hwndOwner,
                          UINT uFlags)
{
    HRESULT hres;
    UINT id;
    TCHAR szCanon[MAX_PATH];
    TCHAR sz[MAX_PATH];
    
    ASSERT(pszList);
    ASSERT(0 < cFiles);
    
    // Special precondition: is it a single file?
    if (1 == cFiles)
    {
        // Yes; is it a twin?
        BrfPathCanonicalize(pszList, szCanon);
        hres = Sync_IsTwin(hbrf, szCanon, uFlags);
        if (S_FALSE == hres)
        {
            // No; tell the user.  Don't bother confirming the action first.
            if (IsFlagClear(uFlags, SF_QUIET))
            {
                UINT ids;
                UINT idi;
                
                if (IsFlagSet(uFlags, SF_ISFOLDER) || 
                    PathIsDirectory(szCanon))
                {
                    ids = IDS_MSG_FolderAlreadyOrphan;
                    idi = IDI_SPLIT_FOLDER;
                }
                else
                {
                    ids = IDS_MSG_FileAlreadyOrphan;
                    idi = IDI_SPLIT_FILE;
                }
                
                MsgBox(hwndOwner, 
                    MAKEINTRESOURCE(ids), 
                    MAKEINTRESOURCE(IDS_CAP_Split), 
                    LoadIcon(g_hinst, MAKEINTRESOURCE(idi)), 
                    MB_INFO,
                    PathGetDisplayName(szCanon, sz));
            }
        }
        else if (S_OK == hres)
        {
            // Yes
            if (IsFlagClear(uFlags, SF_NOCONFIRM))
                id = ConfirmSplit(hwndOwner, szCanon, 1);
            else
                id = IDYES;
            
            if (IDYES == id)
            {
                hres = SplitPath(hbrf, szCanon, hwndOwner, uFlags);
                if (IsFlagClear(uFlags, SF_QUIET))
                {
                    SHChangeNotifyHandleEvents();
                }
            }
            else
                hres = S_FALSE;
        }
    }
    
    // Multiselection: ask the user first
    else
    {
        if (IsFlagClear(uFlags, SF_NOCONFIRM))
            id = ConfirmSplit(hwndOwner, pszList, cFiles);
        else
            id = IDYES;
        
        if (IDYES == id)
        {
            // Remove all the files from the engine database
            LPCTSTR psz;
            UINT i;
            HRESULT hresT;
            
            hres = S_FALSE;     // assume success but nothing done
            
            for (i = 0, psz = pszList; i < cFiles; i++)
            {
                // Get dragged file/folder name
                //
                BrfPathCanonicalize(psz, szCanon);
                
                hresT = SplitPath(hbrf, szCanon, hwndOwner, uFlags);
                if (S_OK == hresT)
                    hres = S_OK;  // (Don't set back to FALSE once it is TRUE)
                else if (FAILED(hresT))
                {
                    hres = hresT;
                    break;
                }
                
                DataObj_NextFile(psz);      // Set psz to next file in list
            }
            
            if (IsFlagClear(uFlags, SF_QUIET))
            {
                SHChangeNotifyHandleEvents();    // (Do this after the loop)
            }
        }
        else
            hres = S_FALSE;
    }
    return hres;
}
    

/*----------------------------------------------------------
Purpose: Change the recitem action and the two recnodes of
importance to the specified action.
Returns: --
Cond:    --
*/
void PUBLIC Sync_ChangeRecItemAction(
                                     PRECITEM pri,
                                     LPCTSTR pszBrfPath,
                                     LPCTSTR pszInsideDir,     // Folder inside the briefcase
                                     UINT riaction)           // One of RAIA_* values to change to
{
    HRESULT hres;
    PRECNODE prnInside;
    PRECNODE prnOutside;
    
    // Determine which node is inside the briefcase and which one is
    //  outside.
    //
    hres = Sync_GetNodePair(pri, pszBrfPath, pszInsideDir, &prnInside, &prnOutside);
    if (SUCCEEDED(hres))
    {
        ASSERT(prnInside);
        ASSERT(prnOutside);
        
        switch(riaction)
        {
        case RAIA_TOIN:
            pri->dwUser = RIU_CHANGED;
            pri->riaction = RIA_COPY;
            prnInside->rnaction = RNA_COPY_TO_ME;
            prnOutside->rnaction = RNA_COPY_FROM_ME;
            break;
            
        case RAIA_TOOUT:
            pri->dwUser = RIU_CHANGED;
            pri->riaction = RIA_COPY;
            prnInside->rnaction = RNA_COPY_FROM_ME;
            prnOutside->rnaction = RNA_COPY_TO_ME;
            break;
            
        case RAIA_SKIP:
            pri->dwUser = RIU_SKIP;
            break;
            
        case RAIA_MERGE:
            pri->dwUser = RIU_CHANGED;
            pri->riaction = RIA_MERGE;
            prnInside->rnaction = RNA_MERGE_ME;
            prnOutside->rnaction = RNA_MERGE_ME;
            break;
            
#ifdef NEW_REC
        case RAIA_DONTDELETE:
            if (RNA_DELETE_ME == prnInside->rnaction)
            {
                pri->dwUser = RIU_CHANGED;
                pri->riaction = RIA_NOTHING;
                prnInside->rnaction = RNA_NOTHING;
            }
            else if (RNA_DELETE_ME == prnOutside->rnaction)
            {
                pri->dwUser = RIU_CHANGED;
                pri->riaction = RIA_NOTHING;
                prnOutside->rnaction = RNA_NOTHING;
            }
            break;
            
        case RAIA_DELETEIN:
            pri->dwUser = RIU_CHANGED;
            pri->riaction = RIA_DELETE;
            prnInside->rnaction = RNA_DELETE_ME;
            prnOutside->rnaction = RNA_NOTHING;
            break;
            
        case RAIA_DELETEOUT:
            pri->dwUser = RIU_CHANGED;
            pri->riaction = RIA_DELETE;
            prnInside->rnaction = RNA_NOTHING;
            prnOutside->rnaction = RNA_DELETE_ME;
            break;
#endif
            
        default:
            // (The other values don't make sense here)
            ASSERT(0);
            break;
        }
    }
}


/////////////////////////////////////////////////////  PRIVATE FUNCTIONS


#ifdef DEBUG
/*----------------------------------------------------------
Purpose: Dumps the contents of the given twin structure to
to debug out
Returns: --
Cond:    --
*/
void PUBLIC Sync_FnDump(
                        LPVOID lpvBuf,
                        UINT cbBuf)
{
    int bDump;
    
#define szDumpTwin  TEXT("Dump TWIN: ")
#define szDumpSp    TEXT("           ")
    
    ENTEREXCLUSIVE();
    {
        bDump = IsFlagSet(g_uDumpFlags, DF_CREATETWIN);
    }
    LEAVEEXCLUSIVE();
    
    if (!bDump)
        return ;
    
    if (cbBuf == sizeof(NEWOBJECTTWIN))
    {
        PNEWOBJECTTWIN lpnot = (PNEWOBJECTTWIN)lpvBuf;
        
        TRACE_MSG(TF_ALWAYS, TEXT("%s.Folder1 = {%s}\r\n%s.Folder2 = {%s}\r\n%s.Name = {%s}\r\n"),
            (LPTSTR)szDumpTwin, lpnot->pcszFolder1,
            (LPTSTR)szDumpSp, lpnot->pcszFolder2,
            (LPTSTR)szDumpSp, lpnot->pcszName);
    }
    else if (cbBuf == sizeof(NEWFOLDERTWIN))
    {
        PNEWFOLDERTWIN lpnft = (PNEWFOLDERTWIN)lpvBuf;
        
        TRACE_MSG(TF_ALWAYS, TEXT("%s.Folder1 = {%s}\r\n%s.Folder2 = {%s}\r\n%s.Name = {%s}\r\n%s.dwFlags = 0x%04lx\r\n"),
            (LPTSTR)szDumpTwin, lpnft->pcszFolder1,
            (LPTSTR)szDumpSp, lpnft->pcszFolder2,
            (LPTSTR)szDumpSp, lpnft->pcszName,
            (LPTSTR)szDumpSp, (DWORD)lpnft->dwFlags);
    }
}


/*----------------------------------------------------------
Purpose: Return English form of RIA_ flags
Returns:
Cond:    --
*/
LPTSTR PRIVATE LpszFromItemAction(
                                  ULONG riaction)
{
    switch (riaction)
    {
        DEBUG_CASE_STRING( RIA_NOTHING );
        DEBUG_CASE_STRING( RIA_COPY );
        DEBUG_CASE_STRING( RIA_MERGE );
        DEBUG_CASE_STRING( RIA_BROKEN_MERGE );
        
#ifdef NEW_REC
        DEBUG_CASE_STRING( RIA_DELETE );
#endif
        
    default:        return TEXT("RIA unknown");
    }
}


/*----------------------------------------------------------
Purpose: Return English form of RNA_ flags
Returns:
Cond:    --
*/
LPTSTR PRIVATE LpszFromNodeAction(
                                  ULONG rnaction)
{
    switch (rnaction)
    {
        DEBUG_CASE_STRING( RNA_NOTHING );
        DEBUG_CASE_STRING( RNA_COPY_TO_ME );
        DEBUG_CASE_STRING( RNA_COPY_FROM_ME );
        DEBUG_CASE_STRING( RNA_MERGE_ME );
        
#ifdef NEW_REC
        DEBUG_CASE_STRING( RNA_DELETE_ME );
#endif
        
    default:    return TEXT("RNA unknown");
    }
}


/*----------------------------------------------------------
Purpose: Return English form of RNS_ flags
Returns:
Cond:    --
*/
LPTSTR PRIVATE LpszFromNodeState(
                                 ULONG rnstate)
{
    switch (rnstate)
    {
#ifdef NEW_REC
        DEBUG_CASE_STRING( RNS_NEVER_RECONCILED );
#endif
        
        DEBUG_CASE_STRING( RNS_UNAVAILABLE );
        DEBUG_CASE_STRING( RNS_DOES_NOT_EXIST );
        DEBUG_CASE_STRING( RNS_DELETED );
        DEBUG_CASE_STRING( RNS_NOT_RECONCILED );
        DEBUG_CASE_STRING( RNS_UP_TO_DATE );
        DEBUG_CASE_STRING( RNS_CHANGED );
        
    default: return TEXT("RNS unknown");
    }
}


/*----------------------------------------------------------
Purpose: Dump the RECNODE
Returns:
Cond:    --
*/
void PUBLIC Sync_DumpRecNode(
                             TWINRESULT tr,
                             PRECNODE lprn)
{
    BOOL bDump;
    TCHAR szBuf[MAXMSGLEN];
    
#define szDumpLabel     TEXT("\tDump RECNODE: ")
#define szDumpMargin    TEXT("\t              ")
    
    ENTEREXCLUSIVE();
    {
        bDump = IsFlagSet(g_uDumpFlags, DF_RECNODE);
    }
    LEAVEEXCLUSIVE();
    
    if (!bDump || lprn == NULL || tr == TR_OUT_OF_MEMORY || tr == TR_INVALID_PARAMETER)
        return ;
    
    wsprintf(szBuf, TEXT("%s.Folder = {%s}\r\n"), (LPTSTR)szDumpLabel, lprn->pcszFolder);
    OutputDebugString(szBuf);
    
    wsprintf(szBuf, TEXT("%s.hObjectTwin = %lx\r\n"), (LPTSTR)szDumpMargin, lprn->hObjectTwin);
    OutputDebugString(szBuf);
    
    wsprintf(szBuf, TEXT("%s.rnstate = %s\r\n"), (LPTSTR)szDumpMargin, LpszFromNodeState(lprn->rnstate));
    OutputDebugString(szBuf);
    
    wsprintf(szBuf, TEXT("%s.rnaction = %s\r\n"), (LPTSTR)szDumpMargin, LpszFromNodeAction(lprn->rnaction));
    OutputDebugString(szBuf);
    OutputDebugString(TEXT("\r\n"));
    
#undef szDumpLabel
#undef szDumpMargin
}
    
    
/*----------------------------------------------------------
Purpose: Dump the RECITEM
Returns:
Cond:    --
*/
void PUBLIC Sync_DumpRecItem(
                             TWINRESULT tr,
                             PRECITEM lpri,
                             LPCTSTR pszMsg)
{
    BOOL bDump;
    PRECNODE lprn;
    TCHAR szBuf[MAXMSGLEN];
    
#define szDumpLabel     TEXT("Dump RECITEM: ")
#define szDumpMargin    TEXT("              ")
    
    ENTEREXCLUSIVE();
    {
        bDump = IsFlagSet(g_uDumpFlags, DF_RECITEM);
    }
    LEAVEEXCLUSIVE();
    
    if (!bDump || lpri == NULL || tr == TR_OUT_OF_MEMORY || tr == TR_INVALID_PARAMETER)
        return ;
    
    if (pszMsg)
        TRACE_MSG(TF_ALWAYS, pszMsg);
    
    wsprintf(szBuf, TEXT("tr = %s\r\n"), (LPTSTR)SzFromTR(tr));
    OutputDebugString(szBuf);
    
    wsprintf(szBuf, TEXT("%s.Name = {%s}\r\n"), (LPTSTR)szDumpLabel, lpri->pcszName);
    OutputDebugString(szBuf);
    
    wsprintf(szBuf, TEXT("%s.hTwinFamily = %lx\r\n"), (LPTSTR)szDumpMargin, lpri->hTwinFamily);
    OutputDebugString(szBuf);
    
    wsprintf(szBuf, TEXT("%s.ulcNodes = %lu\r\n"), (LPTSTR)szDumpMargin, lpri->ulcNodes);
    OutputDebugString(szBuf);
    
    wsprintf(szBuf, TEXT("%s.riaction = %s\r\n"), (LPTSTR)szDumpMargin, LpszFromItemAction(lpri->riaction));
    OutputDebugString(szBuf);
    
    lprn = lpri->prnFirst;
    while (lprn)
    {
        Sync_DumpRecNode(tr, lprn);
        lprn = lprn->prnNext;
    }
    
#undef szDumpLabel
#undef szDumpMargin
}


/*----------------------------------------------------------
Purpose: Dump the RECLIST
Returns:
Cond:    --
*/
void PUBLIC Sync_DumpRecList(
                             TWINRESULT tr,
                             PRECLIST lprl,
                             LPCTSTR pszMsg)
{
    BOOL bDump;
    PRECITEM lpri;
    TCHAR szBuf[MAXMSGLEN];
    
#define szDumpLabel   TEXT("Dump RECLIST: ")
    
    ENTEREXCLUSIVE();
    {
        bDump = IsFlagSet(g_uDumpFlags, DF_RECLIST);
    }
    LEAVEEXCLUSIVE();
    
    if (!bDump)
        return ;
    
    if (pszMsg)
        TRACE_MSG(TF_ALWAYS, pszMsg);
    
    // Note we only dump on TR_SUCCESS
    //
    wsprintf(szBuf, TEXT("tr = %s\r\n"), (LPTSTR)SzFromTR(tr));
    OutputDebugString(szBuf);
    
    if (lprl == NULL || tr == TR_OUT_OF_MEMORY || tr == TR_INVALID_PARAMETER)
        return ;
    
    wsprintf(szBuf, TEXT("%s.ulcItems = %lu\r\n"), (LPTSTR)szDumpLabel, lprl->ulcItems);
    OutputDebugString(szBuf);
    
    lpri = lprl->priFirst;
    while (lpri)
    {
        Sync_DumpRecItem(TR_SUCCESS, lpri, NULL);
        lpri = lpri->priNext;
    }
    
#undef szDumpLabel
}


/*----------------------------------------------------------
Purpose: Dump the FOLDERTWIN
Returns: --
Cond:    --
*/
void PUBLIC Sync_DumpFolderTwin(
                                PCFOLDERTWIN pft)
{
    BOOL bDump;
    TCHAR szBuf[MAXMSGLEN];
    
#define szDumpLabel      TEXT("Dump FOLDERTWIN: ")
#define szDumpMargin     TEXT("                 ")
    
    ENTEREXCLUSIVE();
    {
        bDump = IsFlagSet(g_uDumpFlags, DF_FOLDERTWIN);
    }
    LEAVEEXCLUSIVE();
    
    if (!bDump || pft == NULL)
        return ;
    
    wsprintf(szBuf, TEXT("%s.Name = {%s}\r\n"), (LPTSTR)szDumpLabel, pft->pcszName);
    OutputDebugString(szBuf);
    
    wsprintf(szBuf, TEXT("%s.pszSrcFolder = {%s}\r\n"), (LPTSTR)szDumpMargin, pft->pcszSrcFolder);
    OutputDebugString(szBuf);
    
    wsprintf(szBuf, TEXT("%s.pszOtherFolder = {%s}\r\n"), (LPTSTR)szDumpMargin, pft->pcszOtherFolder);
    OutputDebugString(szBuf);
    
    wsprintf(szBuf, TEXT("%s.dwFlags = %lx\r\n"), (LPTSTR)szDumpMargin, pft->dwFlags);
    OutputDebugString(szBuf);
    
    wsprintf(szBuf, TEXT("%s.dwUser = %lx\r\n"), (LPTSTR)szDumpMargin, pft->dwUser);
    OutputDebugString(szBuf);
    
#undef szDumpLabel
#undef szDumpMargin
}


/*----------------------------------------------------------
Purpose: Dump the FOLDERTWINLIST
Returns: --
Cond:    --
*/
void PUBLIC Sync_DumpFolderTwinList(
                                    PFOLDERTWINLIST pftl,
                                    LPCTSTR pszMsg)
{
    BOOL bDump;
    PCFOLDERTWIN pft;
    TCHAR szBuf[MAXMSGLEN];
    
#define szDumpLabel   TEXT("Dump FOLDERTWINLIST: ")
    
    ENTEREXCLUSIVE();
    {
        bDump = IsFlagSet(g_uDumpFlags, DF_FOLDERTWIN);
    }
    LEAVEEXCLUSIVE();
    
    if (!bDump)
        return ;
    
    if (pszMsg)
        TRACE_MSG(TF_ALWAYS, pszMsg);
    
    if (pftl == NULL)
        return ;
    
    wsprintf(szBuf, TEXT("%s.ulcItems = %lu\r\n"), (LPTSTR)szDumpLabel, pftl->ulcItems);
    OutputDebugString(szBuf);
    
    for (pft = pftl->pcftFirst; pft; pft = pft->pcftNext)
    {
        Sync_DumpFolderTwin(pft);
    }
    
#undef szDumpLabel
}



#endif