windows-server-2003/shell/osshell/accesory/clipbook/clipview/cvcomman.c

/*****************************************************************************

                C L I P B O O K   V I E W E R   C O M M A N D S

    Name:       cvcomman.c
    Date:       21-Jan-1994
    Creator:    Unknown

    Description:
        This module handles all WM_COMMAND's.

*****************************************************************************/

#include <windows.h>
#include <windowsx.h>
#include <commctrl.h>
#include <nddeapi.h>
#include <shellapi.h>
#include <assert.h>
#include <strsafe.h>

#include "common.h"
#include "clipbook.h"
#include "clipbrd.h"
#include "clipdsp.h"
#include "dialogs.h"
#include "clpbkdlg.h"
#include "cvcomman.h"
#include "cvinit.h"
#include "cvutil.h"
#include "helpids.h"
#include "debugout.h"
#include "initmenu.h"
#include "shares.h"
#include "clipfile.h"

#include <htmlhelp.h>


// Typedef for the ShellAbout function
typedef void (WINAPI *LPFNSHELLABOUT)(HWND, LPTSTR, LPTSTR, HICON);



// Flags and typedef for the NT LanMan computer browser dialog.
// The actual function is I_SystemFocusDialog, in NTLANMAN.DLL.
#define FOCUSDLG_SERVERS_ONLY        (2)

#define FOCUSDLG_BROWSE_LOGON_DOMAIN         0x00010000
#define FOCUSDLG_BROWSE_WKSTA_DOMAIN         0x00020000
#define FOCUSDLG_BROWSE_OTHER_DOMAINS        0x00040000
#define FOCUSDLG_BROWSE_TRUSTING_DOMAINS     0x00080000
#define FOCUSDLG_BROWSE_WORKGROUP_DOMAINS    0x00100000

typedef UINT (APIENTRY *LPFNSYSFOCUS)(HWND, UINT, LPWSTR, UINT, PBOOL, LPWSTR, DWORD);


static TCHAR szDirName[256] = {'\0',};




///////////////////////////////////////////////////////////////////////
//
// Purpose: Delete the selected share.
//
///////////////////////////////////////////////////////////////////////
LRESULT OnIDMDelete(
    HWND    hwnd,
    UINT    msg,
    WPARAM  wparam,
    LPARAM  lparam)
{
int         tmp;
LPLISTENTRY lpLE;
LISTENTRY   LE;
LRESULT     ret = FALSE;
TCHAR       PageName[MAX_PAGENAME_LENGTH+1];


    if (!pActiveMDI)
        return 0L;


    // Doing a "delete" on the clipboard window clears clipboard
    if (pActiveMDI->flags & F_CLPBRD)
        {
        if ( ClearClipboard(hwndApp) == IDOK )
            {
            EmptyClipboard();
            InitializeMenu ( GetMenu(hwnd) );

            // Force redraw of clipboard window
            if (hwndClpbrd)
                {
                InvalidateRect(hwndClpbrd, NULL, TRUE);
                ret = TRUE;
                }
            }

        return ret;
        }



    tmp = (int)SendMessage (pActiveMDI->hWndListbox, LB_GETCURSEL, 0, 0L);

    if (tmp == LB_ERR)
        {
        PERROR("Could not figure out which item was selected!\r\n");
        return ret;
        }


    SendMessage ( pActiveMDI->hWndListbox, LB_GETTEXT, tmp, (LPARAM)(LPCSTR)&lpLE);
    memcpy(&LE, lpLE, sizeof(LE));

    StringCchPrintf(szBuf, SZBUFSIZ, szDeleteConfirmFmt, (LPTSTR)((lpLE->name)+1) );
    MessageBeep ( MB_ICONEXCLAMATION );

    StringCchCopy (PageName, MAX_PAGENAME_LENGTH+1, lpLE->name);

    if (MessageBox ( hwndApp, szBuf, szDelete, MB_ICONEXCLAMATION|MB_OKCANCEL ) != IDCANCEL)
        {
        AssertConnection ( hwndActiveChild );

        if ( hwndActiveChild == hwndClpOwner )
            {
            ForceRenderAll( hwnd, NULL );
            }


        // Perform an execute to the server to let it know that
        // we're not sharing anymore.

        StringCchPrintf(szBuf, SZBUFSIZ, TEXT("%s%s"), SZCMD_DELETE, lpLE->name);

        if (MySyncXact (szBuf,
                        lstrlen(szBuf) +1,
                        pActiveMDI->hExeConv,
                        0L,
                        CF_TEXT,
                        XTYP_EXECUTE,
                        SHORT_SYNC_TIMEOUT,
                        NULL)
            )
            {
            TCHAR   ComputerName[MAX_COMPUTERNAME_LENGTH+3] = TEXT("\\\\");
            DWORD   CNLen = sizeof(ComputerName) + 1;


            // Need to delete the trust
            GetComputerName (ComputerName+2, &CNLen);
            #ifdef USETWOSHARESPERPAGE
                if (fSharePreference)
                    PageName[0] = SHR_CHAR;
                else
                    PageName[0] = UNSHR_CHAR;
            #else
                PageName[0] = SHR_CHAR;
            #endif
            NDdeSetTrustedShare (ComputerName, PageName, NDDE_TRUST_SHARE_DEL);


            if ( pActiveMDI->DisplayMode == DSP_PAGE )
                {
                PINFO(TEXT("forcing back to list mode\n\r"));
                SendMessage (hwndApp, WM_COMMAND,
                             pActiveMDI->OldDisplayMode == DSP_PREV ?
                               IDM_PREVIEWS : IDM_LISTVIEW,
                             0L );
                }

            UpdateListBox (hwndActiveChild, pActiveMDI->hExeConv);
            InitializeMenu (GetMenu(hwndApp));
            }
        else
            {
            XactMessageBox (hInst, hwndApp, IDS_APPNAME, MB_OK | MB_ICONHAND);
            }
        }

    return ret;
}



/*
 *      OnIDMKeep
 *
 *  Purpose: Create a Clipbook page.
 */

LRESULT OnIDMKeep (
    HWND    hwnd,
    UINT    msg,
    WPARAM  wParam,
    LPARAM  lParam,
    BOOL    bNewPage)
{
PMDIINFO        pMDI;
int             tmp;
DWORD           ret;
HANDLE          hData;
PNDDESHAREINFO  lpDdeInfo = NULL;
TCHAR           atchItem[256];
#ifdef NOOLEITEMSPERMIT
    unsigned    i;
#endif
LPTSTR          lpEnd; // Pointer to the end of the current data block
TCHAR           rgtchCName[MAX_COMPUTERNAME_LENGTH + 3];
DWORD           dwLen;
HCURSOR         hCursor = NULL;
BOOL            bShareSave = fSharePreference;
KEEPASDLG_PARAM KeepAs;
int             Size;


    if (!CountClipboardFormats())
        {
        PERROR (TEXT("Paste entered with no data on the clipboard!\r\n"));
        goto done;
        }

    if (!hwndLocal || !IsWindow(hwndLocal))
        {
        MessageBoxID (hInst, hwnd, IDS_NOCLPBOOK, IDS_APPNAME, MB_OK | MB_ICONSTOP);
        goto done;
        }

    if (!pActiveMDI)
        goto done;

    pMDI = GETMDIINFO(hwndLocal);


    if (bNewPage)
        {
        tmp = (int)SendMessage (pActiveMDI->hWndListbox, LB_GETCOUNT, 0, 0L );

        if (tmp >= MAX_ALLOWED_PAGES)
            {
            MessageBoxID (hInst, hwnd, IDS_MAXPAGESERROR, IDS_PASTEDLGTITLE, MB_OK|MB_ICONEXCLAMATION);
            goto done;
            }


        // Do the dialog and get KeepAs request

        KeepAs.ShareName[0]   = TEXT('\0');
        KeepAs.bAlreadyExist  = FALSE;
        KeepAs.bAlreadyShared = FALSE;

        dwCurrentHelpId = 0;            //  F1 will be context sensitive

        ret = (DWORD)DialogBoxParam (hInst,
                                     MAKEINTRESOURCE(IDD_KEEPASDLG),
                                     hwnd,
                                     KeepAsDlgProc ,
                                     (LPARAM)&KeepAs);

        PINFO (TEXT("DialogBox returning %d\n\r"), ret );
        dwCurrentHelpId = 0L;


        // refresh main window
        UpdateWindow (hwndApp);

        if (!ret || !KeepAs.ShareName[0])
            goto done;

        bShareSave = fSharePreference;
        }



    if (!bNewPage || KeepAs.bAlreadyExist)
        {
        PLISTENTRY lpLE;

        if (!bNewPage)
            tmp = (int)SendMessage (pMDI->hWndListbox, LB_GETCURSEL, 0, 0);
        else
            tmp = (int)SendMessage (pMDI->hWndListbox,
                                    LB_FINDSTRING,
                                    (WPARAM)-1,
                                    (LPARAM)(LPCSTR)KeepAs.ShareName);


        if (LB_ERR == tmp)
            goto done;

        SendMessage (pMDI->hWndListbox,
                     LB_GETTEXT,
                     tmp,
                     (LPARAM)&lpLE);

        StringCchCopy (KeepAs.ShareName, MAX_NDDESHARENAME +2, lpLE->name);

        KeepAs.bAlreadyShared = IsShared (lpLE);
        KeepAs.bAlreadyExist  = TRUE;

        fSharePreference = bNewPage? fSharePreference: KeepAs.bAlreadyShared;
        }


    // Set up NetDDE share for the page
    Size = 2048 * sizeof(TCHAR);
    lpDdeInfo = GlobalAllocPtr (GHND, Size);
    if (!lpDdeInfo)
       {
       MessageBoxID (hInst, hwnd, IDS_INTERNALERR, IDS_APPNAME, MB_OK|MB_ICONSTOP);
       goto done;
       }

    hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT));


    // Set up computer name with \\ in front

    rgtchCName[1] = rgtchCName[0] = TEXT('\\');
    dwLen = MAX_COMPUTERNAME_LENGTH+1;
    GetComputerName (rgtchCName + 2, &dwLen);


    lpEnd = (LPTSTR)lpDdeInfo + sizeof(NDDESHAREINFO);
    Size -= sizeof(NDDESHAREINFO);

    // Set up the constant members of the struct

    if (KeepAs.bAlreadyExist && KeepAs.bAlreadyShared)
        {
        DWORD   dwAddItem = 0;
        DWORD   dwTotal;

        ret = NDdeShareGetInfo (rgtchCName,
                                KeepAs.ShareName,
                                2,
                                (PUCHAR)lpDdeInfo,
                                2048 * sizeof (TCHAR),
                                &dwTotal,
                                (PUSHORT)&dwAddItem);
        }
    else
        {
        lpDdeInfo->lRevision        = 1L;
        lpDdeInfo->fSharedFlag      = 0;
        lpDdeInfo->fService         = 1; //0;
        lpDdeInfo->fStartAppFlag    = 0;
        lpDdeInfo->qModifyId[0]     = 0;
        lpDdeInfo->qModifyId[1]     = 0;
        lpDdeInfo->nCmdShow         = SW_SHOWMINNOACTIVE;
        lpDdeInfo->lShareType       = SHARE_TYPE_STATIC;
        }



    // Enter the share name... must be == $<PAGENAME>.
    lpDdeInfo->lpszShareName = lpEnd;

    #ifdef USETWOSHARESPERPAGE
        if (fSharePreference || KeepAs.bAlreadyShared)
            {
            *lpEnd = SHR_CHAR;
            }
        else
            {
            *lpEnd = UNSHR_CHAR;
            }
    #else
        *lpEnd = SHR_CHAR;
    #endif


    StringCchCopy(lpDdeInfo->lpszShareName + 1, Size, KeepAs.ShareName + 1);
    lpEnd += lstrlen(lpDdeInfo->lpszShareName) + 1;
    Size -= (lstrlen(lpDdeInfo->lpszShareName) + 1);

    // Start work on the app|topic list
    lpDdeInfo->lpszAppTopicList = lpEnd;

    // By default, there are no items.
    atchItem[0] = TEXT('\0');

    // Set up old-style and OLE name if cf_objectlink is
    // available, else set '\0'.
    if (OpenClipboard(hwnd))
        {
        unsigned cb;
        LPTSTR lpData;

        if ((hData = VGetClipboardData(NULL, cf_link)) &&
            (lpData = GlobalLock(hData)))
            {
            PINFO(TEXT("Link found\r\n"));
            StringCchCopy(lpEnd, Size, lpData);
            lpEnd += cb = lstrlen(lpEnd);
            *lpEnd++ = TEXT('|');
            Size -= (cb+1);
            StringCchCopy(lpEnd, Size, lpData + cb + 1);
            cb += lstrlen(lpEnd) + 2;
            Size -= (lstrlen(lpEnd) + 1);
            lpEnd += lstrlen(lpEnd) + 1;
            StringCchCopy(atchItem, 256, lpData + cb);
            GlobalUnlock(lpData);
            lpDdeInfo->lShareType |= SHARE_TYPE_OLD;
            }
        else
            {
            *lpEnd++ = TEXT('\0');
            Size--;
            }

        if ((hData = VGetClipboardData(NULL, cf_objectlink)) &&
            (lpData = GlobalLock(hData)))
            {
            PINFO(TEXT("ObjectLink found\r\n"));
            StringCchCopy(lpEnd, Size, lpData);
            lpEnd += cb = lstrlen(lpEnd);
            Size -= (cb+1);
            *lpEnd++ = TEXT('|');
            StringCchCopy(lpEnd, Size, lpData + cb + 1);
            cb += lstrlen(lpEnd) + 2;
            Size -= (lstrlen(lpEnd) + 1);
            lpEnd += lstrlen(lpEnd) + 1;
            StringCchCopy(atchItem, 256, lpData + cb);
            GlobalUnlock(lpData);
            lpDdeInfo->lShareType |= SHARE_TYPE_NEW;
            }
        else
            {
            *lpEnd++ = TEXT('\0');
            Size--;
            }

        CloseClipboard();
        }
    else // We couldn't open, we can't get objectlink.
       {
       *lpEnd++ = TEXT('\0');
       *lpEnd++ = TEXT('\0');
       Size -=2;
       }


    // Set up "CLIPSRV|*<pagename>" for a static app/topic
    // We use the *<pagename> form because when the page
    // is first created, it's ALWAYS unshared, and the server's
    // expecting us to be on the "unshared" topic name.
    // Unless the page already exists and is already shared.

    StringCchCopy(lpEnd, Size, SZ_SRV_NAME);
    StringCchCat (lpEnd, Size, TEXT(BAR_CHAR));
    Size -= (lstrlen(lpEnd)+1);
    lpEnd += lstrlen(lpEnd);

    if (KeepAs.bAlreadyShared)
        *lpEnd = SHR_CHAR;
    else
        *lpEnd = UNSHR_CHAR;


    StringCchCopy(lpEnd + 1, Size, KeepAs.ShareName + 1);
    Size -= (lstrlen(lpEnd) + 2);
    lpEnd += lstrlen(lpEnd) + 1;

    // NetDDE requires a fourth NULL at the end of the app/topic list
    *lpEnd++ = TEXT('\0');

    lpDdeInfo->lpszItemList = lpEnd;
    // If there's an item listed, we need to set the item.
    // Otherwise, set no items-- this is an OLE link to the entire
    // document. ANY item, but there's nothing but the static
    // share anyway.
    if (lstrlen(atchItem))
        {
        StringCchCopy(lpEnd, Size, atchItem);
        Size -= (lstrlen(lpEnd) + 1);
        lpEnd += lstrlen(lpEnd) + 1;
        lpDdeInfo->cNumItems = 1;
        #ifdef NOOLEITEMSPERMIT
            for (i = 0; i < NOLEITEMS; i++)
                {
                StringCchCopy(lpEnd, Size, OleShareItems[i]);
                Size -= (lstrlen(lpEnd) + 1);
                lpEnd += lstrlen(lpEnd) + 1;
                }
            lpDdeInfo->cNumItems = NOLEITEMS + 1;
        #endif
        }
    else
        {
        lpDdeInfo->cNumItems = 0;
        *lpEnd++ = TEXT('\0');
        }


    // Finish off item list with an extra null.
    *lpEnd++ = TEXT('\0');



    // Create the share

    if (!KeepAs.bAlreadyExist)
        {
        DumpDdeInfo(lpDdeInfo, rgtchCName);
        ret = NDdeShareAdd (rgtchCName, 2, NULL, (LPBYTE)lpDdeInfo, sizeof(NDDESHAREINFO) );

        PINFO(TEXT("NDdeShareAdd ret %ld\r\n"), ret);

        if (ret != NDDE_NO_ERROR && ret != NDDE_SHARE_ALREADY_EXIST)
            {
            if (NDDE_ACCESS_DENIED == ret)
                {
                MessageBoxID (hInst, hwnd, IDS_PRIVILEGEERROR, IDS_APPNAME, MB_OK|MB_ICONSTOP);
                }
            else
                {
                PERROR(TEXT("NDDE Error %d\r\n"), ret);
                NDdeMessageBox (hInst, hwnd, ret, IDS_APPNAME, MB_OK|MB_ICONSTOP);
                }
            goto done;
            }


        // Need to trust the share so that we can init through it!
        ret = NDdeSetTrustedShare (rgtchCName,
                                   lpDdeInfo->lpszShareName,
                                   NDDE_TRUST_SHARE_INIT);

        if (ret != NDDE_NO_ERROR)
            NDdeMessageBox (hInst, hwnd, ret, IDS_APPNAME, MB_OK|MB_ICONSTOP);

        }
    else
        {
        ret = NDdeShareSetInfo (rgtchCName,
                                lpDdeInfo->lpszShareName,
                                2,
                                (LPBYTE)lpDdeInfo,
                                sizeof(NDDESHAREINFO),
                                0);

        if (NDDE_NO_ERROR != ret)
            {
            NDdeMessageBox (hInst, hwnd, ret, IDS_APPNAME, MB_OK|MB_ICONSTOP);
            goto done;
            }
        }



    // Send DEExecute to tell clipsrv that we've created this page,
    // and will it please make an actual file for it?
    // NOTE must force all formats rendered to prevent deadlock
    // on the clipboard.
    ForceRenderAll (hwnd, NULL);

    StringCchCopy(szBuf, SZBUFSIZ, SZCMD_PASTE);
    StringCchCat (szBuf, SZBUFSIZ, KeepAs.ShareName);


    AssertConnection (hwndLocal);

    if (!MySyncXact ((LPBYTE)szBuf,
                     lstrlen(szBuf) +1,
                     pMDI->hExeConv,
                     0L,
                     CF_TEXT,
                     XTYP_EXECUTE,
                     LONG_SYNC_TIMEOUT,
                     NULL))
        {
        XactMessageBox (hInst, hwnd, IDS_APPNAME, MB_OK|MB_ICONSTOP);


        if (!KeepAs.bAlreadyExist)
            {
            // Problem creating the page so ask the server to delete it
            StringCchPrintf (szBuf, SZBUFSIZ, TEXT("%s%s"), SZCMD_DELETE, KeepAs.ShareName);
            MySyncXact (szBuf,
                        lstrlen (szBuf) +1,
                        pMDI->hExeConv,
                        0L,
                        CF_TEXT,
                        XTYP_EXECUTE,
                        SHORT_SYNC_TIMEOUT,
                        NULL);

            // and we'll delete the rest.
            NDdeSetTrustedShare (rgtchCName,
                                 lpDdeInfo->lpszShareName,
                                 NDDE_TRUST_SHARE_DEL);

            NDdeShareDel (rgtchCName,
                          lpDdeInfo->lpszShareName,
                          0);
            goto done;
            }
        }


    // Turn off redraw and add the new page to list.  Adding the new item
    // to list is necessary because the Properties() call below.  Turning
    // off the redraw is necessary because we sometimes get into a re-entrancy
    // problem.  When the list box is update, it is redrawn and if we're in
    // the preview mode, we get into the async xaction in the middle of some
    // sync xact.

    SendMessage (pMDI->hWndListbox, WM_SETREDRAW, FALSE, 0);

    if (!KeepAs.bAlreadyExist)
        {
        PLISTENTRY lpLE;

        // below code is copied from InitListBox()
        if (lpLE = (PLISTENTRY)GlobalAllocPtr (GHND, sizeof(LISTENTRY)))
            {
            lpLE->fDelete = TRUE;
            lpLE->fTriedGettingPreview = FALSE;
            StringCchCopy (lpLE->name, MAX_PAGENAME_LENGTH + 1, KeepAs.ShareName);
            SendMessage (pMDI->hWndListbox, LB_ADDSTRING, 0, (LPARAM)lpLE);
            }
        }


    if (fSharePreference != KeepAs.bAlreadyShared)
        {
        // get the item number
        tmp = (int)SendMessage (pMDI->hWndListbox,
                                LB_FINDSTRING,
                                (WPARAM)-1,
                                (LPARAM)(LPCSTR)KeepAs.ShareName);

        if (LB_ERR != tmp)
            {
            if (fSharePreference)
                {
                PLISTENTRY lpLE;

                SendMessage (pMDI->hWndListbox,
                             LB_GETTEXT,
                             tmp,
                             (LPARAM)&lpLE);
                Properties (hwnd, lpLE);
                }
            else
                OnIdmUnshare (tmp);
            }
        }


    // Now, turn on redraw.

    SendMessage (pMDI->hWndListbox, WM_SETREDRAW, TRUE, 0);


    // update the list box in all cases, the function
    // is smart enough to figure out which item has
    // changed and update only it.

    UpdateListBox (hwndLocal, pMDI->hExeConv);
    InvalidateRect (pMDI->hWndListbox, NULL, FALSE);



done:
    if (lpDdeInfo)
        GlobalFreePtr (lpDdeInfo);


    InitializeMenu (GetMenu (hwndApp));
    if (hCursor)
    {
        hCursor = SetCursor (hCursor);
    }

    fSharePreference = bShareSave;

    return 0L;
}




/*
 *      OnIDMCopy
 *
 *  Handles IDM_COPY to copy a page to clipbrd.
 */

LRESULT OnIDMCopy (
    HWND    hwnd,
    UINT    msg,
    WPARAM  wParam,
    LPARAM  lParam)
{
LPLISTENTRY lpLE;
PMDIINFO    pMDIc;
PDATAREQ    pDataReq;
TCHAR       tchTmp;
INT         tmp;
BOOL        fLocked;


    if (WAIT_TIMEOUT == WaitForSingleObject (hXacting, 0))
        return 0L;

    fLocked = LockApp (TRUE, NULL);


    // make a copy to ensure that the global is not
    // changed from under us in case proc is reentered

    if (!(pMDIc = GETMDIINFO(hwndActiveChild)))
        goto done;

    tmp = (int)SendMessage ( pMDIc->hWndListbox, LB_GETCURSEL, 0, 0L );

    if (tmp == LB_ERR)
        goto done;


    if (SendMessage (pMDIc->hWndListbox, LB_GETTEXT, tmp, (LPARAM)(LPCSTR)&lpLE)
        == LB_ERR )
        {
        PERROR(TEXT("IDM_COPY: bad listbox index: %d\n\r"), tmp );
        goto done;
        }

    if (!(pDataReq = CreateNewDataReq()))
        {
        PERROR(TEXT("error from CreateNewDataReq\n\r"));
        goto done;
        }

    if (pMDIc->hszClpTopic)
        {
        DdeFreeStringHandle (idInst, pMDIc->hszClpTopic);
        }


    tchTmp = lpLE->name[0];
    lpLE->name[0] = SHR_CHAR;
    pMDIc->hszClpTopic = DdeCreateStringHandle(idInst, lpLE->name, 0);


    // If we're local, trust the share so we can copy through it
    if (hwndActiveChild == hwndLocal)
       {
       DWORD adwTrust[3];

       NDdeGetTrustedShare(NULL, lpLE->name, adwTrust, adwTrust + 1,
            adwTrust + 2);
       adwTrust[0] |= NDDE_TRUST_SHARE_INIT;

       NDdeSetTrustedShare(NULL, lpLE->name, adwTrust[0]);
       }

    lpLE->name[0] = tchTmp;


    if ( !pMDIc->hszClpTopic )
       {
       MessageBoxID (hInst,
                     hwndActiveChild,
                     IDS_DATAUNAVAIL,
                     IDS_APPNAME,
                     MB_OK | MB_ICONEXCLAMATION );
       goto done;
       }



    if (pMDIc->hClpConv)
       {
       DdeDisconnect (pMDIc->hClpConv);
       pMDIc->hClpConv = NULL;
       }

    pMDIc->hClpConv = DdeConnect (idInst,
                                  pMDIc->hszConvPartner,
                                  pMDIc->hszClpTopic,
                                  NULL);


    if (!pMDIc->hClpConv)
       {
       PERROR(TEXT("DdeConnect to (%s) failed %d\n\r"),
              (LPSTR)(lpLE->name), DdeGetLastError(idInst) );

       MessageBoxID (hInst,
                     hwndActiveChild,
                     IDS_DATAUNAVAIL,
                     IDS_APPNAME,
                     MB_OK | MB_ICONEXCLAMATION);
       goto done;
       }

    pDataReq->rqType      = RQ_COPY;
    pDataReq->hwndList    = pMDIc->hWndListbox;
    pDataReq->iListbox    = tmp;
    pDataReq->hwndMDI     = hwndActiveChild;
    pDataReq->fDisconnect = FALSE;
    pDataReq->wFmt        = CF_TEXT;

    DdeSetUserHandle (pMDIc->hClpConv, (DWORD)QID_SYNC, (DWORD_PTR)pDataReq);
    DdeKeepStringHandle (idInst, hszFormatList);


    if (!DdeClientTransaction (NULL,
                               0L,
                               pMDIc->hClpConv,
                               hszFormatList,
                               CF_TEXT,
                               XTYP_REQUEST,
                               (DWORD)TIMEOUT_ASYNC,
                               NULL))
        DdeMessageBox (hInst,
                       hwndApp,
                       DdeGetLastError(idInst),
                       IDS_APPNAME,
                       MB_OK|MB_ICONEXCLAMATION);

done:
    if (fLocked)
        LockApp (FALSE, NULL);

    SetEvent (hXacting);

    return 0L;
}



/*
 *      CreateClipboardWindow
 *
 *  Purpose: Create and activate a window showing the contents of the
 *  clipboard.
 */

static void CreateClipboardWindow (void)
{
WINDOWPLACEMENT wpl;
HMENU           hSysMenu;
PMDIINFO        pMDI;


    // create Clipboard Window
    hwndClpbrd = NewWindow();
    if (NULL == hwndClpbrd)
        {
        return;
        }

    pMDI              = GETMDIINFO(hwndClpbrd);
    pMDI->flags       = F_CLPBRD;
    pMDI->DisplayMode = DSP_PAGE;

    AdjustControlSizes ( hwndClpbrd );
    ShowHideControls ( hwndClpbrd );

    StringCchCopy (pMDI->szBaseName,   (MAX_COMPUTERNAME_LENGTH+1)*2, szSysClpBrd);
    StringCchCopy (pMDI->szComputerName, MAX_COMPUTERNAME_LENGTH + 1, TEXT(""));

    SetWindowText ( hwndClpbrd, szSysClpBrd );

    // Grey out close item on sys menu
    hSysMenu = GetSystemMenu ( hwndClpbrd, FALSE );
    EnableMenuItem (hSysMenu, SC_CLOSE, MF_GRAYED | MF_BYCOMMAND);

    // Tell MDI where the Window menu is -- must do this BEFORE placing
    // the clipboard window. (If the clipboard window's maximized, its
    // System menu is the first menu-- not the app's File menu.)
    hSysMenu = GetSubMenu(GetMenu(hwndApp), WINDOW_MENU_INDEX);
    SendMessage(hwndMDIClient, WM_MDISETMENU, 0, (LPARAM)hSysMenu);

    if ( ReadWindowPlacement ( szSysClpBrd, &wpl ))
        {
        wpl.length = sizeof(WINDOWPLACEMENT);
        wpl.flags = WPF_SETMINPOSITION;
        SetWindowPlacement ( hwndClpbrd, &wpl );
        PINFO(TEXT("sizing %s from .ini\n\r"), (LPSTR)szSysClpBrd);
        UpdateWindow ( hwndClpbrd );
        }
    else
        {
        PINFO(TEXT("showing %s in default size/posiiton\n\r"),
            (LPSTR)szSysClpBrd );
        ShowWindow ( hwndClpbrd, SW_MINIMIZE );
        }

    SendMessage ( hwndMDIClient, WM_MDIACTIVATE, (WPARAM)hwndClpbrd, 0L );
}



/*
 *      CreateLocalWindow
 *
 *  Purpose: Create the "Local Clipbook" window.
 *  Parameters: None.
 *  Returns: Void.
 *
 */

static void CreateLocalWindow (void)
{
WINDOWPLACEMENT wpl;
HMENU           hSysMenu;
PMDIINFO        pMDI;


    hwndLocal = NewWindow();
    if (NULL == hwndLocal)
        {
        return;
        }

    pMDI = GETMDIINFO(hwndLocal);
    ShowHideControls (hwndLocal);

    pMDI->hszConvPartner   =
    pMDI->hszConvPartnerNP = hszDataSrv;
    pMDI->hExeConv         = InitSysConv (hwndLocal,
                                          pMDI->hszConvPartner,
                                          hszSystem,
                                          TRUE);

    if (!pMDI->hExeConv )
        goto error;

    pMDI->flags = F_LOCAL;

    if (!UpdateListBox ( hwndLocal, pMDI->hExeConv ))
        goto error;

    SetWindowText ( hwndLocal, szLocalClpBk );

    StringCchCopy (pMDI->szBaseName,   (MAX_COMPUTERNAME_LENGTH+1)*2, szLocalClpBk);
    StringCchCopy (pMDI->szComputerName, MAX_COMPUTERNAME_LENGTH + 1, TEXT(""));

    hSysMenu = GetSystemMenu ( hwndLocal, FALSE );
    EnableMenuItem ( hSysMenu, SC_CLOSE, MF_GRAYED );

    if ( ReadWindowPlacement ( szLocalClpBk, &wpl ))
        {
        wpl.length = sizeof(WINDOWPLACEMENT);
        wpl.flags = WPF_SETMINPOSITION;
        SetWindowPlacement ( hwndLocal, &wpl );
        PINFO(TEXT("sizing Local Clipbook from .ini\n\r"));
        UpdateWindow ( hwndLocal );
        }
    else
        {
        if ( !IsIconic(hwndApp))
            {
            RECT MDIrect;

            PINFO(TEXT("calculating size for Local Clipbook window\n\r"));
            GetClientRect ( hwndMDIClient, &MDIrect );
            MoveWindow ( hwndLocal,
                MDIrect.left, MDIrect.top, MDIrect.right - MDIrect.left,
                ( MDIrect.bottom - MDIrect.top )
                - GetSystemMetrics(SM_CYICONSPACING), FALSE );
            }
        else
            {
            fNeedToTileWindows = TRUE;
            }
        ShowWindow ( hwndLocal, SW_SHOWNORMAL );
        }

    SendMessage (hwndMDIClient, WM_MDIACTIVATE, (WPARAM)hwndLocal, 0L);
    SendMessage (hwndMDIClient, WM_MDIREFRESHMENU, 0, 0L);

    if (NULL != hkeyRoot)
        {
        DWORD dwDefView = IDM_LISTVIEW;
        DWORD dwSize = sizeof(dwDefView);

        if (ERROR_SUCCESS != RegQueryValueEx(hkeyRoot,
              (LPTSTR)szDefView, NULL, NULL, (LPBYTE)&dwDefView, &dwSize));
            {
            PINFO(TEXT("Couldn't get DefView value\r\n"));
            }

        SendMessage ( hwndApp, WM_COMMAND, dwDefView, 0L );
        }

    return;


error:
    #if DEBUG
        MessageBox (hwndApp,
                    TEXT("No Local Server"),
                    TEXT("ClipBook Initialization"),
                    MB_OK | MB_ICONEXCLAMATION );
    #endif

    fShareEnabled = FALSE;

    SendMessage (hwndLocal, WM_MDIDESTROY, 0, 0L);

    hwndLocal = NULL;

    return;
}




/*
 *      UnsharePage
 *
 *  Purpose: Unshare the selected page in the active window.
 *  Parameters: None.
 *  Returns: Void. All error handling is provided within the function.
 *
 */

void UnsharePage (void)
{
DWORD           adwTrust[3];
int             tmp;
LPLISTENTRY     lpLE;
DWORD           ret;
WORD            wAddlItems;
PNDDESHAREINFO  lpDdeI;
DWORD           dwRet = 2048 * sizeof(TCHAR);


    assert(pActiveMDI);

    if (!pActiveMDI);
        return;

    tmp = (int)SendMessage (pActiveMDI->hWndListbox, LB_GETCURSEL, 0, 0L);

    if ( tmp == LB_ERR )
        return;

    if (!(lpDdeI = LocalAlloc(LPTR, 2048 * sizeof(TCHAR))))
       {
       MessageBoxID (hInst, hwndApp, IDS_INTERNALERR, IDS_APPNAME, MB_OK | MB_ICONHAND);
       return;
       }

   SendMessage (  pActiveMDI->hWndListbox, LB_GETTEXT, tmp, (LPARAM)(LPCSTR)&lpLE);

   AssertConnection(hwndActiveChild);

   PINFO(TEXT("for share [%s]"), lpLE->name);
   wAddlItems = 0;
   ret = NDdeShareGetInfo ( NULL, lpLE->name, 2,
       (LPBYTE)lpDdeI, 2048 * sizeof(TCHAR), &dwRet, &wAddlItems );


    if (NDDE_ACCESS_DENIED == ret)
        {
        MessageBoxID (hInst, hwndApp, IDS_PRIVILEGEERROR, IDS_APPNAME,
                      MB_OK | MB_ICONHAND);
        }
    else if (NDDE_NO_ERROR != ret)
        {
        PERROR(TEXT("Error from NDdeShareSetInfo %d\n\r"), ret );
        NDdeMessageBox (hInst, hwndApp, ret,
                        IDS_SHAREDLGTITLE, MB_ICONHAND | MB_OK );
        }
    else
        {
        register LPTSTR lpOog;

        lpOog = lpDdeI->lpszAppTopicList;

        // Jump over the first two NULL chars you find-- these
        // are the old- and new-style app/topic pairs, we don't
        // mess with them. Then jump over the next BAR_CHAR you find.
        // The first character after that is the first char of the
        // static topic-- change that to a UNSHR_CHAR.

        while (*lpOog++) ;
        while (*lpOog++) ;

        while (*lpOog++ != TEXT('|')) ;

        *lpOog = UNSHR_CHAR;
        lpDdeI->fSharedFlag = 0L;

        DumpDdeInfo(lpDdeI, NULL);

        // We want to get trusted info BEFORE we start changing the share.
        NDdeGetTrustedShare(NULL, lpLE->name, adwTrust, adwTrust + 1, adwTrust + 2);

        ret = NDdeShareSetInfo ( NULL, lpLE->name, 2,
            (LPBYTE)lpDdeI, 2048 * sizeof(TCHAR), 0 );

        if (NDDE_NO_ERROR == ret)
            {

            // We've finished mucking with the share, now set trust info
            PINFO(TEXT("Setting trust info to 0x%lx\r\n"), adwTrust[0]);
            NDdeSetTrustedShare(NULL, lpLE->name, adwTrust[0]);

            ///////////////////////////////////////////////
            // do the execute to change the server state
            StringCchCopy(szBuf, SZBUFSIZ, SZCMD_UNSHARE);
            StringCchCat( szBuf, SZBUFSIZ, lpLE->name);
            PINFO(TEXT("sending cmd [%s]\n\r"), szBuf);

            if (MySyncXact ((LPBYTE)szBuf,
                            lstrlen(szBuf) +1,
                            GETMDIINFO(hwndLocal)->hExeConv,
                            0L,
                            CF_TEXT,
                            XTYP_EXECUTE,
                            SHORT_SYNC_TIMEOUT,
                            NULL))
                {
                SetShared(lpLE, FALSE);
                InitializeMenu(GetMenu(hwndApp));
                }
            else
                {
                XactMessageBox (hInst, hwndApp, IDS_APPNAME, MB_OK | MB_ICONSTOP);
                }
            }
        }
}




/*
 *      OnIdmUnshare
 *
 *
 *  Purpose: Set the currently selected page in the active MDI window
 *      to 'unshared'.
 *
 *  dwItem is the item number to unshare.  If == LB_ERR then the current
 *      selected item will be unshared.
 *
 *  Parameters: None.
 *
 *  Returns: 0L always, function handles its own errors.
 *
 */

LRESULT OnIdmUnshare (DWORD dwItem)
{
PNDDESHAREINFO lpDdeI;
PLISTENTRY     lpLE;
DWORD          adwTrust[3];
WORD           wAddlItems;
DWORD          ret;
DWORD          dwRet = 2048 * sizeof(TCHAR);
LPTSTR         lpOog;


    if (!pActiveMDI)
        return 0L;

    if (LB_ERR == dwItem)
        dwItem = (int)SendMessage (pActiveMDI->hWndListbox, LB_GETCURSEL, 0, 0L );

    if (LB_ERR == dwItem)
        {
        PERROR(TEXT("IDM_UNSHARE w/no page selected\r\n"));
        return 0L;
        }


    if (!(lpDdeI = LocalAlloc(LPTR, 2048 * sizeof(TCHAR))))
        {
        MessageBoxID (hInst, hwndApp, IDS_INTERNALERR, IDS_APPNAME,
                      MB_OK | MB_ICONHAND);
        return 0L;
        }

    SendMessage (pActiveMDI->hWndListbox,
                 LB_GETTEXT,
                 dwItem,
                 (LPARAM)(LPCSTR)&lpLE);

    AssertConnection(hwndActiveChild);


    PINFO(TEXT("for share [%s]"), lpLE->name);
    wAddlItems = 0;
    ret = NDdeShareGetInfo (NULL, lpLE->name,
                            2,
                            (LPBYTE)lpDdeI,
                            2048 * sizeof(TCHAR),
                            &dwRet,
                            &wAddlItems );


    if (NDDE_ACCESS_DENIED == ret)
        {
        MessageBoxID (hInst, hwndApp, IDS_PRIVILEGEERROR, IDS_APPNAME,
                      MB_OK | MB_ICONHAND);
        return 0L;
        }
    else if (ret != NDDE_NO_ERROR)
        {
        PERROR(TEXT("Error from NDdeShareSetInfo %d\n\r"), ret );
        NDdeMessageBox (hInst, hwndApp, ret,
                        IDS_SHAREDLGTITLE, MB_ICONHAND | MB_OK );
        return 0L;
        }


    lpOog = lpDdeI->lpszAppTopicList;


    // Jump over the first two NULL chars you find-- these
    // are the old- and new-style app/topic pairs, we don't
    // mess with them. Then jump over the next BAR_CHAR you find.
    // The first character after that is the first char of the
    // static topic-- change that to a SHR_CHAR.

    while (*lpOog++) ;
    while (*lpOog++) ;

    while (*lpOog++ != TEXT('|')) ;

    *lpOog = UNSHR_CHAR;
    lpDdeI->fSharedFlag = 1L;



    // Have to get trusted share settings before we modify
    // the share, because they'll be invalid.

    NDdeGetTrustedShare (NULL,
                         lpDdeI->lpszShareName,
                         adwTrust,
                         adwTrust + 1,
                         adwTrust + 2);


    DumpDdeInfo (lpDdeI, NULL);
    ret = NDdeShareSetInfo (NULL,
                            lpDdeI->lpszShareName,
                            2,
                            (LPBYTE)lpDdeI,
                            2048 * sizeof(TCHAR),
                            0);


    if (NDDE_ACCESS_DENIED == ret)
        {
        MessageBoxID (hInst, hwndApp, IDS_PRIVILEGEERROR, IDS_APPNAME,
                      MB_OK | MB_ICONHAND);
        return 0L;
        }
    else if (NDDE_NO_ERROR != ret)
        {
        NDdeMessageBox (hInst, hwndApp, ret, IDS_APPNAME,
                        MB_OK | MB_ICONHAND);
        PERROR(TEXT("Couldn't set share info\r\n"));
        return 0L;
        }


    // Setting trusted share info needs to be the last
    // operation we do on the share.
    if (NDDE_NO_ERROR != NDdeSetTrustedShare (NULL, lpDdeI->lpszShareName, adwTrust[0]))
        {
        PERROR(TEXT("Couldn't set trust status\r\n"));
        }

    ///////////////////////////////////////////////
    // do the execute to change the server state
    StringCchCopy(szBuf, SZBUFSIZ, SZCMD_UNSHARE);
    StringCchCat( szBuf, SZBUFSIZ, lpLE->name);
    PINFO(TEXT("sending cmd [%s]\n\r"), szBuf);

    if (MySyncXact ((LPBYTE)szBuf,
                    lstrlen(szBuf) +1,
                    GETMDIINFO(hwndLocal)->hExeConv,
                    0L,
                    CF_TEXT,
                    XTYP_EXECUTE,
                    SHORT_SYNC_TIMEOUT,
                    NULL))
        {

        InitializeMenu(GetMenu(hwndApp));
        }
    else
        {
        XactMessageBox (hInst, hwndApp, IDS_APPNAME, MB_OK | MB_ICONSTOP );
        }

    return(0L);
}



/*
 *      ClipBookCommand
 *
 * Purpose: Process menu commands for the Clipbook Viewer.
 *
 * Parameters: As wndproc.
 *
 * Returns: 0L, or DefWindowProc() if wParam isn't a WM_COMMAND id I
 *    know about.
 *
 */

LRESULT ClipBookCommand (
     HWND   hwnd,
     UINT   msg,
     WPARAM wParam,
     LPARAM lParam)
{
int             tmp;
UINT            wNewFormat;
UINT            wOldFormat;
LPLISTENTRY     lpLE;
BOOL            bRet;
DWORD           dwErr;


    switch (LOWORD(wParam))
        {
        case IDM_AUDITING:
            return(EditPermissions(TRUE));
            break;

        case IDM_OWNER:
            return EditOwner();
            break;

        case IDM_PERMISSIONS:
            {
            PLISTENTRY pLE;
            RECT       Rect;
            INT        i;

            i = (INT)EditPermissions(FALSE);


            // Permissions may have changed.  Get old data, they need
            //  to be updated.

            SendMessage (pActiveMDI->hWndListbox, LB_GETTEXT,     i, (LPARAM)&pLE);
            SendMessage (pActiveMDI->hWndListbox, LB_GETITEMRECT, i, (LPARAM)&Rect);


            // Delete the old bitmap.  If we are allowed to see it we'll
            //  get it when the list item is redrawn.

            DeleteObject (pLE->hbmp);
            pLE->fTriedGettingPreview = FALSE;
            pLE->hbmp = NULL;


            // Make it redraw.

            InvalidateRect (pActiveMDI->hWndListbox, &Rect, FALSE);
            }
            break;

        case IDC_TOOLBAR:
            MenuHelp( WM_COMMAND, wParam, lParam, GetMenu(hwnd), hInst,
                  hwndStatus, nIDs );
            break;

        case IDM_EXIT:
            SendMessage (hwnd, WM_CLOSE, 0, 0L);
            break;

        case IDM_TILEVERT:
        case IDM_TILEHORZ:
            SendMessage(hwndMDIClient, WM_MDITILE,
                wParam == IDM_TILEHORZ ? MDITILE_HORIZONTAL : MDITILE_VERTICAL,
                0L);
            break;

        case IDM_CASCADE:
            SendMessage (hwndMDIClient, WM_MDICASCADE, 0, 0L);
            break;

        case IDM_ARRANGEICONS:
            SendMessage (hwndMDIClient, WM_MDIICONARRANGE, 0, 0L);
            break;

        case IDM_COPY:
            szSaveFileName[0] = '\0';
            OnIDMCopy (hwnd, msg, wParam, lParam);
            break;

        case IDM_TOOLBAR:
            if ( fToolBar )
                {
                fToolBar = FALSE;
                ShowWindow ( hwndToolbar, SW_HIDE );
                AdjustMDIClientSize();
                }
            else
                {
                fToolBar = TRUE;
                AdjustMDIClientSize();
                ShowWindow ( hwndToolbar, SW_SHOW );
                }
            break;

        case IDM_STATUSBAR:

            if ( fStatus )
                {
                fStatus = FALSE;
                ShowWindow ( hwndStatus, SW_HIDE );
                AdjustMDIClientSize();
                }
            else
                {
                fStatus = TRUE;
                AdjustMDIClientSize();
                ShowWindow ( hwndStatus, SW_SHOW );
                }
            break;

        case ID_PAGEUP:
        case ID_PAGEDOWN:
            {
            HWND hwndc;
            PMDIINFO pMDIc;
            UINT iLstbox, iLstboxOld;

            // copy to make sure this value doesn't change when we yield
            hwndc = hwndActiveChild;

            if (!(pMDIc = GETMDIINFO(hwndc)))
                break;

            SetFocus ( hwndc );

            // make sure this is not clipboard window...
            if ( pMDIc->flags & F_CLPBRD )
                break;

            // must be in page view
            if ( pMDIc->DisplayMode != DSP_PAGE )
                break;

            iLstbox = (int)SendMessage ( pMDIc->hWndListbox,
                LB_GETCURSEL, 0, 0L );
            if ( iLstbox == LB_ERR )
                break;

            // page up on first entry?
            if ( iLstbox == 0 && wParam == ID_PAGEUP )
                {
                MessageBeep(0);
                break;
                }

            // page down on last entry?
            if ( (int)iLstbox == (int)SendMessage(pMDIc->hWndListbox,
                LB_GETCOUNT,0,0L) - 1 && wParam == (WPARAM)ID_PAGEDOWN )
                {
                MessageBeep(0);
                break;
                }

            // move selection up/down as appropriate
            iLstboxOld;
            if ( wParam == ID_PAGEDOWN )
                iLstbox++;
            else
                iLstbox--;

            SetListboxEntryToPageWindow ( hwndc, pMDIc, iLstbox );
            }
            break;

        case IDM_LISTVIEW:
        case IDM_PREVIEWS:
            {
            HWND    hwndtmp;
            int     OldSel;
            int     OldDisplayMode;
            TCHAR   szBuff[80];

            SetFocus (hwndActiveChild);

            if (!pActiveMDI)
                break;

            // make sure this is not clipboard window...
            if (pActiveMDI->flags & F_CLPBRD)
                break;

            // NOP?
            if (pActiveMDI->DisplayMode == DSP_PREV && wParam == IDM_PREVIEWS ||
                pActiveMDI->DisplayMode == DSP_LIST && wParam == IDM_LISTVIEW)
                break;

            OldDisplayMode = pActiveMDI->DisplayMode;

            // nuke vclipboard if there is one
            if ( pActiveMDI->pVClpbrd )
                {
                DestroyVClipboard( pActiveMDI->pVClpbrd );
                pActiveMDI->pVClpbrd = NULL;
                }


            // Save selection... (extra code to avoid strange lb div-by-zero)
            OldSel = (int)SendMessage( pActiveMDI->hWndListbox, LB_GETCURSEL, 0, 0L);
            SendMessage (pActiveMDI->hWndListbox, LB_SETCURSEL, (WPARAM)-1, 0L);
            UpdateNofMStatus (hwndActiveChild);
            SendMessage (pActiveMDI->hWndListbox, WM_SETREDRAW, 0, 0L);


            // set new display mode so listbox will get created right
            pActiveMDI->DisplayMode = (wParam == IDM_PREVIEWS)? DSP_PREV :DSP_LIST;


            // save handle to old listbox
            hwndtmp =  pActiveMDI->hWndListbox;


            // hide the old listbox - will soon destroy
            ShowWindow ( hwndtmp, SW_HIDE );


            // make new listbox and save handle in extra window data
            pActiveMDI->hWndListbox = CreateNewListBox (hwndActiveChild,
                                                        (pActiveMDI->DisplayMode == DSP_PREV)?
                                                         LBS_PREVIEW:
                                                         LBS_LISTVIEW);

            // loop, extracting items from one box and into other
            while (SendMessage (hwndtmp, LB_GETTEXT, 0, (LPARAM)(LPCSTR)&lpLE ) != LB_ERR)
                {
                // mark this item not to be deleted in WM_DELETEITEM
                lpLE->fDelete = FALSE;

                // remove from listbox
                SendMessage (hwndtmp, LB_DELETESTRING, 0, 0L);

                // reset fDelete flag
                lpLE->fDelete = TRUE;

                // add to new listbox
                SendMessage (pActiveMDI->hWndListbox, LB_ADDSTRING, 0, (LPARAM)(LPCSTR)lpLE);
                }



            // kill old (empty) listbox
            DestroyWindow ( hwndtmp );


            if ( pActiveMDI->flags & F_LOCAL )
                {
                SetWindowText ( hwndLocal, szLocalClpBk );
                StringCchCopy(szBuff, 80, szDefView);
                }
            else
                {
                StringCchPrintf(szBuff, 80, szClipBookOnFmt,(LPSTR)(pActiveMDI->szBaseName));
                SetWindowText ( hwndActiveChild, szBuff );
                StringCchCopy(szBuff, 80, pActiveMDI->szBaseName);
                StringCchCat(szBuff, 80, szConn);
                }

            if (NULL != hkeyRoot)
                {
                DWORD dwValue;

                dwValue = pActiveMDI->DisplayMode == DSP_LIST ? IDM_LISTVIEW :
                          pActiveMDI->DisplayMode == DSP_PREV ? IDM_PREVIEWS :
                          IDM_PAGEVIEW;

                RegSetValueEx (hkeyRoot, (LPTSTR)szBuff, 0L, REG_DWORD,
                               (LPBYTE)&dwValue, sizeof(DWORD));
                }


            // adjust size and show
            AdjustControlSizes( hwndActiveChild );
            ShowHideControls ( hwndActiveChild );

            // restore selection
            SendMessage( pActiveMDI->hWndListbox, LB_SETCURSEL, OldSel, 0L );
            UpdateNofMStatus ( hwndActiveChild );

            InitializeMenu ( GetMenu(hwndApp) );
            SetFocus ( pActiveMDI->hWndListbox );
            break;
            }

        case IDM_UPDATE_PAGEVIEW:
        case IDM_PAGEVIEW:
            {
            HWND hwndc;
            PMDIINFO pMDIc;

            // copy to make sure this value doesn't change when we yield
            hwndc = hwndActiveChild;

            if (!(pMDIc = GETMDIINFO(hwndc)))
                break;

            SetFocus (hwndc);


            // make sure this is not clipboard window...

            if (pMDIc->flags & F_CLPBRD)
                break;


            // if switch to page view

            if (IDM_PAGEVIEW == LOWORD(wParam))
                {
                // already in page view?
                if (pMDIc->DisplayMode == DSP_PAGE)
                    break;
                }
            else
                {
                // make sure we're not in an sync xaction, if so
                //  post a message and try again later.
                if (WAIT_TIMEOUT == WaitForSingleObject (hXacting, 0))
                    {
                    PostMessage (hwndApp, WM_COMMAND, IDM_UPDATE_PAGEVIEW, 0L);
                    break;
                    }

                // hXacting is now reset, set it so it can be used again
                SetEvent (hXacting);
                }


            tmp = (int)SendMessage (pMDIc->hWndListbox, LB_GETCURSEL, 0, 0L);
            if (tmp == LB_ERR)
                break;


            SetListboxEntryToPageWindow (hwndc, pMDIc, tmp);
            break;
            }

        case IDM_SHARE:
            if (!pActiveMDI)
                break;

            tmp = (int) SendMessage (pActiveMDI->hWndListbox,LB_GETCURSEL, 0, 0L);

            if ( tmp != LB_ERR )
                {
                SendMessage (pActiveMDI->hWndListbox, LB_GETTEXT, tmp, (LPARAM)&lpLE);

                // We create the NetDDE share when we create the page, not when we
                // share it. Thus, we're always 'editing the properties' of an existing
                // share, even if the user thinks that he's sharing the page NOW.
                Properties(hwnd, lpLE);

                // Redraw the listbox.
                if (pActiveMDI->DisplayMode == DSP_PREV)
                    {
                    InvalidateRect(pActiveMDI->hWndListbox, NULL, FALSE);
                    }
                else
                    {
                    SendMessage(pActiveMDI->hWndListbox,LB_SETCURSEL, tmp, 0L);
                    UpdateNofMStatus(hwndActiveChild);
                    }
                }
            break;

        case IDM_CLPWND:
            CreateClipboardWindow();
            break;

        case IDM_LOCAL:
            if (fNetDDEActive)
                CreateLocalWindow();
            break;

        case IDM_UNSHARE:
            bRet = (BOOL)OnIdmUnshare(LB_ERR);
            UpdateListBox (hwndActiveChild, pActiveMDI->hExeConv);
            return bRet;
            break;

        case IDM_DELETE:
            bRet = (BOOL)OnIDMDelete(hwnd, msg, wParam, lParam);
            return bRet;
            break;


        case IDM_PASTE_PAGE:
        case IDM_KEEP:
            bRet = (BOOL)OnIDMKeep (hwnd,
                                    msg,
                                    wParam,
                                    lParam,
                                    IDM_KEEP == LOWORD(wParam));
            return bRet;
            break;

        case IDM_SAVEAS:
            {
            OPENFILENAME ofn;
            CHAR         szFile[MAX_PATH+1];

            if (CountClipboardFormats())
                {
                szFile[0] = '\0';
                // Initialize the OPENFILENAME members
                ofn.lStructSize       = sizeof(OPENFILENAME);
                ofn.hwndOwner         = hwnd;
                ofn.lpstrFilter       = szFilter;
                ofn.lpstrCustomFilter = (LPTSTR) NULL;
                ofn.nMaxCustFilter    = 0L;
                ofn.nFilterIndex      = 1;
                ofn.lpstrFile         = (LPTSTR)szFile;
                ofn.nMaxFile          = sizeof(szFile);
                ofn.lpstrFileTitle    = NULL;
                ofn.nMaxFileTitle     = 0L;
                ofn.lpstrInitialDir   = szDirName;
                ofn.lpstrTitle        = (LPTSTR) NULL;
                ofn.lpstrDefExt       = "CLP";
                ofn.Flags             = OFN_HIDEREADONLY |
                                        OFN_NOREADONLYRETURN |
                                        OFN_OVERWRITEPROMPT;

                if (GetSaveFileName (&ofn) && szFile[0])
                    {
                    // NOTE must force all formats rendered!
                    ForceRenderAll (hwnd, NULL);

                    AssertConnection (hwndLocal);

                    // If user picked first filter ("NT Clipboard"), use save as..
                    // other filters would use save as old.
                    StringCchPrintf (szBuf, SZBUFSIZ, "%s%s",
                               (ofn.nFilterIndex == 1) ?
                                (LPSTR)SZCMD_SAVEAS :
                                (LPSTR)SZCMD_SAVEASOLD,
                               (LPSTR)szFile );

                    dwErr = SaveClipboardToFile (hwndApp, NULL, szFile, FALSE);
                    SysMessageBox (hInst, hwnd, dwErr, IDS_APPNAME, MB_OK|MB_ICONHAND);

                    }
                }
            break;
            }
        case IDM_OPEN:
            {
            OPENFILENAME ofn;
            TCHAR        szFile[MAX_PATH+1] = TEXT("*.clp");

            // Initialize the OPENFILENAME members
            ofn.lStructSize       = sizeof(OPENFILENAME);
            ofn.hwndOwner         = hwnd;
            ofn.lpstrFilter       = szFilter;
            ofn.lpstrCustomFilter = (LPTSTR) NULL;
            ofn.nMaxCustFilter    = 0L;
            ofn.nFilterIndex      = 1;
            ofn.lpstrFile         = (LPTSTR)szFile;
            ofn.nMaxFile          = sizeof(szFile);
            ofn.lpstrFileTitle    = NULL;
            ofn.nMaxFileTitle     = 0L;
            ofn.lpstrInitialDir   = szDirName;
            ofn.lpstrTitle        = (LPTSTR) NULL;
            ofn.Flags             = OFN_HIDEREADONLY | OFN_PATHMUSTEXIST;
            ofn.lpstrDefExt       = TEXT("CLP");

            if (GetOpenFileName (&ofn) && szFile[0])
                 {
                 // prompt for clearing clipboard
                 if (ClearClipboard(hwnd))
                    {
                    AssertConnection ( hwndLocal );

                    StringCchPrintf(szBuf, SZBUFSIZ, TEXT("%s%s"), (LPTSTR)SZCMD_OPEN, (LPTSTR)szFile);

                    dwErr = OpenClipboardFile (hwndApp, szFile);
                    SysMessageBox (hInst, hwnd, dwErr, IDS_APPNAME, MB_OK|MB_ICONHAND);

                    InitializeMenu (GetMenu(hwnd));
                    }
                 }
            break;
            }

        case IDM_DISCONNECT:

            if (!pActiveMDI)
                break;

            // don't allow close of local or clipboard window
            if (pActiveMDI->flags & (F_LOCAL | F_CLPBRD))
                break;
            SendMessage ( hwndActiveChild, WM_CLOSE, 0, 0L );
            break;

        case IDM_CONNECT:
            {
            WCHAR rgwch[MAX_COMPUTERNAME_LENGTH + 3];
            BOOL  bOK = FALSE;
            BOOL  fFoundLMDlg = FALSE;
            HMODULE hMod;
            LPFNSYSFOCUS lpfn;
            #ifndef UNICODE
              WCHAR rgwchHelp[64];
            #endif
            WCHAR szPath[MAX_PATH];
            UINT  uDirLen;

            *szConvPartner = '\0';
            rgwch[0] = L'\0';

            //  get windows\system32 directory : null terminated; doesnt have a
            //  trailing '\'; 0==api failed; need 14 tchars at the end for dllname
            uDirLen = GetSystemDirectoryW(szPath,MAX_PATH);
            if ( (uDirLen > 0) && (uDirLen < MAX_PATH-20) )
            {
               StringCchCatW(szPath, MAX_PATH, L"\\NTLANMAN.DLL");
               if (hMod = LoadLibraryW(szPath))
               {
                  if (lpfn = (LPFNSYSFOCUS)GetProcAddress(hMod, "I_SystemFocusDialog"))
                     {
                     #ifndef UNICODE
                       MultiByteToWideChar(CP_ACP, 0, szHelpFile, -1, rgwchHelp, 64);
                     #endif

                     fFoundLMDlg = TRUE;
                     (*lpfn)(hwnd,
                             FOCUSDLG_BROWSE_LOGON_DOMAIN |
                             FOCUSDLG_BROWSE_WKSTA_DOMAIN |
                             FOCUSDLG_BROWSE_OTHER_DOMAINS |
                             FOCUSDLG_BROWSE_TRUSTING_DOMAINS |
                             FOCUSDLG_BROWSE_WORKGROUP_DOMAINS |
                             FOCUSDLG_SERVERS_ONLY,
                             rgwch,
                             MAX_COMPUTERNAME_LENGTH + 3,
                             &bOK,
                             #ifndef UNICODE
                               rgwchHelp,
                             #else
                               szHelpFile,
                             #endif
                             IDH_SELECT_COMPUTER);

                     if (IDOK == bOK)
                        {
                        #ifndef UNICODE
                        WideCharToMultiByte(CP_ACP,
                            WC_COMPOSITECHECK | WC_DISCARDNS, rgwch,
                            -1, szConvPartner, MAX_COMPUTERNAME_LENGTH + 3, NULL, &bOK);
                        #else
                        lstrcpy(szConvPartner, rgwch);
                        #endif
                        }
                     else
                        {
                        szConvPartner[0] = TEXT('\0');
                        }
                     }
                  else
                     {
                     PERROR(TEXT("Couldn't find connect proc!\r\n"));
                     }
                  FreeLibrary(hMod);
                  }
               else
                  {
                  PERROR(TEXT("Couldn't find NTLANMAN.DLL\r\n"));
                  }
               }
            else
               {
               PERROR(TEXT("Couldn't get path to system32 directory\r\n"));
               }

            // If we didn't find the fancy LanMan dialog, we still can get by
            if (!fFoundLMDlg)
               {
               bOK = (BOOL)DialogBox(hInst, MAKEINTRESOURCE(IDD_CONNECT), hwnd,
                                     ConnectDlgProc);
               }

            if ( *szConvPartner )
               {
               CreateNewRemoteWindow ( szConvPartner, TRUE );
               }
            else
               {
                MessageBoxID (hInst,
                              hwnd,
                              IDS_NOCONNECTION,
                              IDS_APPNAME,
                              MB_OK | MB_ICONHAND);
               }
            UpdateWindow ( hwnd );
            break;
            }

        case IDM_REFRESH:

            if (!pActiveMDI)
                break;

            #if DEBUG
                {
                DWORD cbDBL = sizeof(DebugLevel);

                RegQueryValueEx(hkeyRoot, szDebug, NULL, NULL,
                    (LPBYTE)&DebugLevel, &cbDBL);
                }
            #endif
            if (pActiveMDI->flags & F_CLPBRD)
                break;

            AssertConnection ( hwndActiveChild );
            UpdateListBox ( hwndActiveChild, pActiveMDI->hExeConv );
            break;

        case IDM_CONTENTS:
            HtmlHelp(GetDesktopWindow(), szChmHelpFile, HH_DISPLAY_TOPIC, 0L);
            break;

        case IDM_ABOUT:
           {
           HMODULE hMod;
           LPFNSHELLABOUT lpfn;

           if (hMod = LoadLibrary(TEXT("SHELL32")))
              {
              if (lpfn = (LPFNSHELLABOUT)GetProcAddress(hMod,
                 #ifdef UNICODE
                   "ShellAboutW"
                 #else
                   "ShellAboutA"
                 #endif
                 ))
                 {
                 (*lpfn)(hwnd, szAppName, szNull,
                      LoadIcon(hInst, MAKEINTRESOURCE(IDFRAMEICON)));
                 }
              FreeLibrary(hMod);
              }
           else
              {
              PERROR(TEXT("Couldn't get SHELL32.DLL\r\n"));
              }
           }
           break;

        case CBM_AUTO:
        case CF_PALETTE:
        case CF_TEXT:
        case CF_BITMAP:
        case CF_METAFILEPICT:
        case CF_SYLK:
        case CF_DIF:
        case CF_TIFF:
        case CF_OEMTEXT:
        case CF_DIB:
        case CF_OWNERDISPLAY:
        case CF_DSPTEXT:
        case CF_DSPBITMAP:
        case CF_DSPMETAFILEPICT:
        case CF_PENDATA:
        case CF_RIFF:
        case CF_WAVE:
        case CF_ENHMETAFILE:
        case CF_UNICODETEXT:
        case CF_DSPENHMETAFILE:
        case CF_LOCALE:

            if (!pActiveMDI)
               break;

            if ( pActiveMDI->CurSelFormat != wParam)
                {
                CheckMenuItem (hDispMenu, pActiveMDI->CurSelFormat, MF_BYCOMMAND | MF_UNCHECKED);
                CheckMenuItem (hDispMenu, (UINT)wParam,                   MF_BYCOMMAND | MF_CHECKED);

                DrawMenuBar(hwnd);

                wOldFormat = GetBestFormat( hwndActiveChild, pActiveMDI->CurSelFormat);
                wNewFormat = GetBestFormat( hwndActiveChild, (UINT)wParam);

                if (wOldFormat == wNewFormat)
                    {
                    /* An equivalent format is selected; No change */
                    pActiveMDI->CurSelFormat = (UINT)wParam;
                    }
                else
                    {
                    /* A different format is selected; So, refresh... */

                    /* Change the character sizes based on new format. */
                    ChangeCharDimensions (hwndActiveChild, wOldFormat, wNewFormat);

                    pActiveMDI->fDisplayFormatChanged = TRUE;
                    pActiveMDI->CurSelFormat = (UINT)wParam;

                    // NOTE OwnerDisplay stuff applies only to the "real" clipboard!

                    if (wOldFormat == CF_OWNERDISPLAY)
                        {
                        /* Save the owner Display Scroll info */
                        SaveOwnerScrollInfo(hwndClpbrd);
                        ShowScrollBar ( hwndClpbrd, SB_BOTH, FALSE );
                        ShowHideControls(hwndClpbrd);
                        ResetScrollInfo( hwndActiveChild );
                        InvalidateRect ( hwndActiveChild, NULL, TRUE );
                        break;
                        }

                    if (wNewFormat == CF_OWNERDISPLAY)
                        {
                        /* Restore the owner display scroll info */
                        ShowHideControls(hwndClpbrd);
                        ShowWindow ( pActiveMDI->hwndSizeBox, SW_HIDE );
                        RestoreOwnerScrollInfo(hwndClpbrd);
                        InvalidateRect ( hwndActiveChild, NULL, TRUE );
                        break;
                        }

                    InvalidateRect  (hwndActiveChild, NULL, TRUE);
                    ResetScrollInfo (hwndActiveChild );
                    }
                }
            break;

        default:
            return DefFrameProc ( hwnd,hwndMDIClient,msg,wParam,lParam);
        }

    return 0;
}




/*
 *      SetListboxEntryToPageWindow
 */

BOOL SetListboxEntryToPageWindow(
    HWND        hwndc,
    PMDIINFO    pMDIc,
    int         lbindex)
{
HCONV       hConv;
LPLISTENTRY lpLE;
PVCLPBRD    pVClp;
PDATAREQ    pDataReq;
BOOL        fOK = FALSE;
TCHAR       tchTmp;
BOOL        fLocked;


    if (WAIT_TIMEOUT == WaitForSingleObject (hXacting, 0))
        return fOK;

    fLocked = LockApp (TRUE, NULL);

    if (LB_ERR == SendMessage (pMDIc->hWndListbox, LB_GETTEXT, lbindex, (LPARAM)(LPCSTR)&lpLE)
        || !lpLE
        || !(pDataReq = CreateNewDataReq()))
        {
        PERROR(TEXT("error from CreateNewDataReq\n\r"));
        goto done;
        }

    // make new clipboard
    if (!(pVClp = CreateVClipboard(hwndc)))
        {
        PERROR(TEXT("Failed to create Vclipboard\n\r"));
        goto done;
        }

    // nuke previous vclipboard if any
    if ( pMDIc->pVClpbrd )
        DestroyVClipboard( pMDIc->pVClpbrd );

    pMDIc->pVClpbrd = pVClp;

    // Set up $<page name> for topic
    if (pMDIc->hszClpTopic)
        DdeFreeStringHandle ( idInst, pMDIc->hszClpTopic );

    tchTmp = lpLE->name[0];
    lpLE->name[0] = SHR_CHAR;
    pMDIc->hszVClpTopic = DdeCreateStringHandle ( idInst, lpLE->name, 0 );
    lpLE->name[0] = tchTmp;

    if (!pMDIc->hszVClpTopic)
       {
       PERROR(TEXT("Couldn't make string handle for %s\r\n"), lpLE->name);
       goto done;
       }


    if (pMDIc->hVClpConv)
       {
       DdeDisconnect (pMDIc->hVClpConv);
       pMDIc->hVClpConv = NULL;
       }


    hConv = DdeConnect (idInst, pMDIc->hszConvPartner, pMDIc->hszVClpTopic, NULL);
    if (!hConv)
       {
       PERROR(TEXT("DdeConnect for Vclip failed: %x\n\r"), DdeGetLastError(idInst) );
       goto done;
       }

    pMDIc->hVClpConv = hConv;

    DdeKeepStringHandle (idInst, hszFormatList);

    pDataReq->rqType      = RQ_SETPAGE;
    pDataReq->hwndList    = pMDIc->hWndListbox;
    pDataReq->iListbox    = lbindex;
    pDataReq->hwndMDI     = hwndc;
    pDataReq->fDisconnect = FALSE;
    pDataReq->wFmt        = CF_TEXT;

    DdeSetUserHandle (hConv, (DWORD)QID_SYNC, (DWORD_PTR)pDataReq);

    if (!DdeClientTransaction (NULL,
                               0L,
                               hConv,
                               hszFormatList,
                               CF_TEXT,
                               XTYP_REQUEST,
                               (DWORD)TIMEOUT_ASYNC,
                               NULL ))
        DdeMessageBox (hInst,
                       pDataReq->hwndMDI,
                       DdeGetLastError (idInst),
                       IDS_APPNAME,
                       MB_OK|MB_ICONEXCLAMATION);

    fOK = TRUE;


done:
    if (!fOK)
        MessageBoxID ( hInst, hwndc, IDS_INTERNALERR, IDS_APPNAME, MB_OK | MB_ICONSTOP );

    if (fLocked)
        LockApp (FALSE, NULL);

    SetEvent (hXacting);

    return(fOK);
}