windows-server-2003/sdktools/winobj/wfinit.c

/****************************************************************************/
/*                                                                          */
/*  WFINIT.C -                                                              */
/*                                                                          */
/*      Windows File System Initialization Routines                         */
/*                                                                          */
/****************************************************************************/

#include "winfile.h"
#include "lfn.h"
#include "winnet.h"
#include "wnetcaps.h"           // WNetGetCaps()
#include "stdlib.h"

typedef DWORD ( APIENTRY *EXTPROC)(HWND, WORD, LONG);
typedef DWORD ( APIENTRY *UNDELPROC)(HWND, LPSTR);
typedef VOID  ( APIENTRY *FNPENAPP)(WORD, BOOL);

VOID (APIENTRY *lpfnRegisterPenApp)(WORD, BOOL);
CHAR szPenReg[] = "RegisterPenApp";
CHAR szHelv[] = "MS Shell Dlg";    // default font, status line font face name

HBITMAP hbmSave;


INT     GetDriveOffset(register WORD wDrive);
DWORD   RGBToBGR(DWORD rgb);
VOID    BoilThatDustSpec(register CHAR *pStart, BOOL bLoadIt);
VOID    DoRunEquals(PINT pnCmdShow);
VOID    GetSavedWindow(LPSTR szBuf, PSAVE_WINDOW pwin);
VOID    GetSettings(VOID);
VOID    InitMenus(VOID);



INT
APIENTRY
GetHeightFromPointsString(
                         LPSTR szPoints
                         )
{
    HDC hdc;
    INT height;

    hdc = GetDC(NULL);
    height = MulDiv(-atoi(szPoints), GetDeviceCaps(hdc, LOGPIXELSY), 72);
    ReleaseDC(NULL, hdc);

    return height;
}

VOID
BiasMenu(
        HMENU hMenu,
        INT Bias
        )
{
    INT pos, id, count;
    HMENU hSubMenu;
    CHAR szMenuString[80];

    ENTER("BiasMenu");

    count = GetMenuItemCount(hMenu);

    if (count < 0)
        return;

    for (pos = 0; pos < count; pos++) {

        id = GetMenuItemID(hMenu, pos);

        if (id < 0) {
            // must be a popup, recurse and update all ID's here
            if (hSubMenu = GetSubMenu(hMenu, pos))
                BiasMenu(hSubMenu, Bias);
        } else if (id) {
            // replace the item that was there with a new
            // one with the id adjusted

            GetMenuString(hMenu, (WORD)pos, szMenuString, sizeof(szMenuString), MF_BYPOSITION);
            DeleteMenu(hMenu, pos, MF_BYPOSITION);
            InsertMenu(hMenu, (WORD)pos, MF_BYPOSITION | MF_STRING, id + Bias, szMenuString);
        }
    }
    LEAVE("BiasMenu");
}


VOID
APIENTRY
InitExtensions()
{
    CHAR szBuf[300] = {0};
    CHAR szPath[MAXPATHLEN];
    LPSTR p;
    HANDLE hMod;
    FM_EXT_PROC fp;
    HMENU hMenu;
    INT iMax;
    HMENU hMenuFrame;
    HWND  hwndActive;

    ENTER("InitExtensions");

    hMenuFrame = GetMenu(hwndFrame);

    hwndActive = (HWND)SendMessage(hwndMDIClient, WM_MDIGETACTIVE, 0, 0L);
    if (hwndActive && GetWindowLong(hwndActive, GWL_STYLE) & WS_MAXIMIZE)
        iMax = 1;
    else
        iMax = 0;

    GetPrivateProfileString(szAddons, NULL, szNULL, szBuf, sizeof(szBuf), szTheINIFile);

    for (p = szBuf; *p && iNumExtensions < MAX_EXTENSIONS; p += lstrlen(p) + 1) {

        GetPrivateProfileString(szAddons, p, szNULL, szPath, sizeof(szPath), szTheINIFile);

        hMod = MLoadLibrary(szPath);

        if (hMod >= (HANDLE)32) {
            fp = (FM_EXT_PROC)GetProcAddress(hMod, "FMExtensionProc");

            if (fp) {
                WORD bias;
                FMS_LOAD ls;

                bias = (WORD)((IDM_EXTENSIONS + iNumExtensions + 1)*100);
                ls.wMenuDelta = bias;
                if ((*fp)(hwndFrame, FMEVENT_LOAD, (LPARAM)&ls)) {

                    if (ls.dwSize != sizeof(FMS_LOAD) || !ls.hMenu)
                        goto LoadFail;

                    hMenu = ls.hMenu;

                    extensions[iNumExtensions].ExtProc = fp;
                    extensions[iNumExtensions].Delta = bias;
                    extensions[iNumExtensions].hModule = hMod;
                    extensions[iNumExtensions].hMenu = hMenu;

                    BiasMenu(hMenu, bias);

                    InsertMenu(hMenuFrame,
                               IDM_EXTENSIONS + iNumExtensions + iMax,
                               MF_BYPOSITION | MF_POPUP,
                               (UINT_PTR)hMenu, ls.szMenuName);

                    iNumExtensions++;
                }
            } else {
                LoadFail:
                FreeLibrary(hMod);
            }
        }
    }
    LEAVE("InitExtensions");
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  GetSettings() -                                                         */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID
GetSettings()
{
    CHAR szTemp[128] = {0};
    INT size;

    ENTER("GetSettings");

    /* Get the flags out of the INI file. */
    bMinOnRun       = GetPrivateProfileInt(szSettings, szMinOnRun,      bMinOnRun,      szTheINIFile);
    wTextAttribs    = (WORD)GetPrivateProfileInt(szSettings, szLowerCase,     wTextAttribs,   szTheINIFile);
    bStatusBar      = GetPrivateProfileInt(szSettings, szStatusBar,     bStatusBar,     szTheINIFile);
    bConfirmDelete  = GetPrivateProfileInt(szSettings, szConfirmDelete, bConfirmDelete, szTheINIFile);
    bConfirmSubDel  = GetPrivateProfileInt(szSettings, szConfirmSubDel, bConfirmSubDel, szTheINIFile);
    bConfirmReplace = GetPrivateProfileInt(szSettings, szConfirmReplace,bConfirmReplace,szTheINIFile);
    bConfirmMouse   = GetPrivateProfileInt(szSettings, szConfirmMouse,  bConfirmMouse,  szTheINIFile);
    bConfirmFormat  = GetPrivateProfileInt(szSettings, szConfirmFormat, bConfirmFormat, szTheINIFile);
    bSaveSettings   = GetPrivateProfileInt(szSettings, szSaveSettings,  bSaveSettings, szTheINIFile);

    // test font for now

    GetPrivateProfileString(szSettings, szSize, "8", szTemp, sizeof(szTemp), szTheINIFile);
    size = GetHeightFromPointsString(szTemp);

    GetPrivateProfileString(szSettings, szFace, szHelv, szTemp, sizeof(szTemp), szTheINIFile);

    hFont = CreateFont(size, 0, 0, 0,
                       wTextAttribs & TA_BOLD ? 700 : 400,
                       wTextAttribs & TA_ITALIC, 0, 0,
                       ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                       DEFAULT_QUALITY, DEFAULT_PITCH | FF_SWISS, szTemp);

    LEAVE("GetSettings");
}



/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  GetInternational() -                                                    */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID
APIENTRY
GetInternational()
{
    ENTER("GetInternational");

    GetProfileString(szInternational, "sShortDate", szShortDate, szShortDate, 11);
    AnsiUpper(szShortDate);
    GetProfileString(szInternational, "sTime", szTime, szTime, 2);
    GetProfileString(szInternational, "s1159", sz1159, sz1159, 9);
    GetProfileString(szInternational, "s2359", sz2359, sz2359, 9);
    GetProfileString(szInternational, "sThousand", szComma, szComma, sizeof(szComma));
    iTime   = GetProfileInt(szInternational, "iTime", iTime);
    iTLZero = GetProfileInt(szInternational, "iTLZero", iTLZero);

    LEAVE("GetInternational");
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  BuildDocumentString() -                                                 */
/*                                                                          */
/*--------------------------------------------------------------------------*/

/* Create a string which contains all of the extensions the user wants us to
 * display with document icons.  This consists of any associated extensions
 * as well as any extensions listed in the "Documents=" WIN.INI line.
 */

VOID
APIENTRY
BuildDocumentString()
{
    register LPSTR     p;
    register INT      len;
    INT               lenDocs;
    CHAR              szT[10];
    INT               i;
    HKEY hk;


    ENTER("BuildDocumentString");

    len = 32;

    /* Get all of the "Documents=" stuff. */
    szDocuments = (LPSTR)LocalAlloc(LPTR, len);
    if (!szDocuments)
        return;

    while ((lenDocs = GetProfileString(szWindows, "Documents", szNULL, szDocuments, len-1)) == len-1) {
        len += 32;
        {
            void *pv = (LPSTR)LocalReAlloc((HANDLE)szDocuments, len, LMEM_MOVEABLE);
            if (!pv) {
                LEAVE("BuildDocumentString");
                return;
            } else
                szDocuments = pv;
        }
    }

    lstrcat(szDocuments, szBlank);
    lenDocs++;
    p = (LPSTR)(szDocuments + lenDocs);

    /* Read all of the [Extensions] keywords into 'szDocuments'. */
    while ((INT)GetProfileString(szExtensions, NULL, szNULL, p, len-lenDocs) > (len-lenDocs-3)) {
        len += 32;
        {
            void *pv =(LPSTR)LocalReAlloc((HANDLE)szDocuments, len, LMEM_MOVEABLE);
            if (!pv) {
                LEAVE("BuildDocumentString");
                return;
            } else {
                szDocuments = pv;
            }
        }
        p = (LPSTR)(szDocuments + lenDocs);
    }

    /* Step through each of the keywords in 'szDocuments' changing NULLS into
     * spaces until a double-NULL is found.
     */
    p = szDocuments;
    while (*p) {
        /* Find the next NULL. */
        while (*p)
            p++;

        /* Change it into a space. */
        *p = ' ';
        p++;
    }


    if (RegOpenKey(HKEY_CLASSES_ROOT,szNULL,&hk) == ERROR_SUCCESS) {
        /* now enumerate the classes in the registration database and get all
         * those that are of the form *.ext
         */
        for (i = 0; RegEnumKey(hk,(DWORD)i,szT,sizeof(szT))
            == ERROR_SUCCESS; i++) {
            if (szT[0] != '.' ||
                (szT[1] && szT[2] && szT[3] && szT[4])) {
                /* either the class does not start with . or it has a greater
                 * than 3 byte extension... skip it.
                 */
                continue;
            }

            if (FindExtensionInList(szT+2,szDocuments)) {
                // don't add it if it's already there!
                continue;
            }

            len += 4;
            {
                void *pv = (PSTR)LocalReAlloc((HANDLE)szDocuments, len, LMEM_MOVEABLE);
                if (!pv) {
                    break;
                } else {
                    szDocuments = pv;
                }
            }
            lstrcat(szDocuments, szT+1);
            lstrcat(szDocuments, szBlank);
        }

        RegCloseKey(hk);
    }

    PRINT(BF_PARMTRACE, "OUT: szDocuments=%s", szDocuments);
    LEAVE("BuildDocumentString - ok");
    return;
}




INT
GetDriveOffset(
              register WORD wDrive
              )
{
    if (IsCDRomDrive(wDrive))
        return dxDriveBitmap * 0;

    switch (IsNetDrive(wDrive)) {
        case 1:
            return dxDriveBitmap * 4;
        case 2:
            return dxDriveBitmap * 5;
    }

    if (IsRemovableDrive(wDrive))
        return dxDriveBitmap * 1;

    if (IsRamDrive(wDrive))
        return dxDriveBitmap * 3;

    return dxDriveBitmap * 2;
}


VOID
APIENTRY
InitDriveBitmaps()
{
    INT nDrive;

    ENTER("InitDiskMenus");

    // and now add all new ones
    for (nDrive=0; nDrive < cDrives; nDrive++) {
        // refresh/init this here as well
        rgiDrivesOffset[nDrive] = GetDriveOffset((WORD)rgiDrive[nDrive]);
    }
    LEAVE("InitDiskMenus");
}



/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  InitMenus() -                                                           */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID
InitMenus()
{
    WORD i;
    HMENU hMenu;
    OFSTRUCT os;
    INT iMax;
    CHAR szValue[MAXPATHLEN];
    HWND hwndActive;

    ENTER("InitMenus");

    hwndActive = (HWND)SendMessage(hwndMDIClient, WM_MDIGETACTIVE, 0, 0L);
    if (hwndActive && GetWindowLong(hwndActive, GWL_STYLE) & WS_MAXIMIZE)
        iMax = 1;
    else
        iMax = 0;

    GetPrivateProfileString(szSettings, szUndelete, szNULL, szValue, sizeof(szValue), szTheINIFile);

    if (szValue[0]) {

        // create explicit filename to avoid searching the path

        GetSystemDirectory(os.szPathName, sizeof(os.szPathName));
        AddBackslash(os.szPathName);
        lstrcat(os.szPathName, szValue);

        if (MOpenFile(os.szPathName, &os, OF_EXIST) > 0) {

            hModUndelete = MLoadLibrary(szValue);

            if (hModUndelete >= (HANDLE)32) {
                lpfpUndelete = (FM_UNDELETE_PROC)GetProcAddress(hModUndelete, "UndeleteFile");

                if (lpfpUndelete) {
                    hMenu = GetSubMenu(GetMenu(hwndFrame), IDM_FILE + iMax);
                    LoadString(hAppInstance, IDS_UNDELETE, szValue, sizeof(szValue));
                    InsertMenu(hMenu, 4, MF_BYPOSITION | MF_STRING, IDM_UNDELETE, szValue);
                }
            } else {
                FreeLibrary(hModUndelete);

            }
        }
    }

    /* Init the Disk menu. */
    hMenu = GetMenu(hwndFrame);

    if (nFloppies == 0) {
        EnableMenuItem(hMenu, IDM_DISKCOPY, MF_BYCOMMAND | MF_GRAYED);
        EnableMenuItem(hMenu, IDM_FORMAT,   MF_BYCOMMAND | MF_GRAYED);
        EnableMenuItem(hMenu, IDM_SYSDISK,  MF_BYCOMMAND | MF_GRAYED);
    }

    bNetAdmin = WNetGetCaps(WNNC_ADMIN) & WNNC_ADM_GETDIRECTORYTYPE;

    /* Should we enable the network items? */
    i = (WORD)WNetGetCaps(WNNC_DIALOG);

    i = 0;

    bConnect    = i & WNNC_DLG_ConnectDialog;     // note, these should both
    bDisconnect = i & WNNC_DLG_DisconnectDialog;  // be true or both false

    // use submenu because we are doing this by position

    hMenu = GetSubMenu(GetMenu(hwndFrame), IDM_DISK + iMax);

    if (i)
        InsertMenu(hMenu, 5, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);

    if (bConnect && bDisconnect) {

        // lanman style double connect/disconnect

        LoadString(hAppInstance, IDS_CONNECT, szValue, sizeof(szValue));
        InsertMenu(hMenu, 6, MF_BYPOSITION | MF_STRING, IDM_CONNECT, szValue);
        LoadString(hAppInstance, IDS_DISCONNECT, szValue, sizeof(szValue));
        InsertMenu(hMenu, 7, MF_BYPOSITION | MF_STRING, IDM_DISCONNECT, szValue);
    } else if (WNetGetCaps(WNNC_CONNECTION)) {

    }

    hMenu = GetMenu(hwndFrame);

    if (bStatusBar)
        CheckMenuItem(hMenu, IDM_STATUSBAR, MF_BYCOMMAND | MF_CHECKED);
    if (bMinOnRun)
        CheckMenuItem(hMenu, IDM_MINONRUN,  MF_BYCOMMAND | MF_CHECKED);
    if (bSaveSettings)
        CheckMenuItem(hMenu, IDM_SAVESETTINGS,  MF_BYCOMMAND | MF_CHECKED);

    InitDriveBitmaps();

    InitExtensions();

    LEAVE("InitMenus");
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  BoilThatDustSpec() -                                                    */
/*                                                                          */
/*--------------------------------------------------------------------------*/

/* Parses the command line (if any) passed into WINFILE and exec's any tokens
 * it may contain.
 */

VOID
BoilThatDustSpec(
                register CHAR *pStart,
                BOOL bLoadIt
                )
{
    register CHAR *pEnd;
    WORD          ret;
    BOOL          bFinished;

    ENTER("BoilThatDustSpec");

    if (*pStart == TEXT('\0'))
        return;

    bFinished = FALSE;
    while (!bFinished) {
        pEnd = pStart;
        while ((*pEnd) && (*pEnd != ' ') && (*pEnd != ','))
            pEnd = AnsiNext(pEnd);

        if (*pEnd == TEXT('\0'))
            bFinished = TRUE;
        else
            *pEnd = TEXT('\0');

        ret = ExecProgram(pStart, szNULL, NULL, bLoadIt);
        if (ret)
            MyMessageBox(NULL, IDS_EXECERRTITLE, ret, MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);

        pStart = pEnd+1;
    }
    LEAVE("BoilThatDustSpec");
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  DoRunEquals() -                                                         */
/*                                                                          */
/*--------------------------------------------------------------------------*/

/* Handle the "Run=" and "Load=" lines in WIN.INI. */

VOID
DoRunEquals(
           PINT pnCmdShow
           )
{
    CHAR      szBuffer[128] = {0};

    /* "Load" apps before "Run"ning any. */
    GetProfileString(szWindows, "Load", szNULL, szBuffer, 128);
    if (*szBuffer)
        BoilThatDustSpec(szBuffer, TRUE);

    GetProfileString(szWindows, "Run", szNULL, szBuffer, 128);
    if (*szBuffer) {
        BoilThatDustSpec(szBuffer, FALSE);
        *pnCmdShow = SW_SHOWMINNOACTIVE;
    }
}


//
// BOOL APIENTRY LoadBitmaps()
//
// this routine loads DIB bitmaps, and "fixes up" their color tables
// so that we get the desired result for the device we are on.
//
// this routine requires:
//      the DIB is a 16 color DIB authored with the standard windows colors
//      bright blue (00 00 FF) is converted to the background color!
//      light grey  (C0 C0 C0) is replaced with the button face color
//      dark grey   (80 80 80) is replaced with the button shadow color
//
// this means you can't have any of these colors in your bitmap
//

#define BACKGROUND      0x000000FF      // bright blue
#define BACKGROUNDSEL   0x00FF00FF      // bright blue
#define BUTTONFACE      0x00C0C0C0      // bright grey
#define BUTTONSHADOW    0x00808080      // dark grey

DWORD
FlipColor(
         DWORD rgb
         )
{
    return RGB(GetBValue(rgb), GetGValue(rgb), GetRValue(rgb));
}


BOOL
APIENTRY
LoadBitmaps()
{
    HDC                   hdc;
    HANDLE                h;
    DWORD                 *p;
    LPSTR                 lpBits;
    HANDLE                hRes;
    LPBITMAPINFOHEADER    lpBitmapInfo;
    INT numcolors;
    DWORD n;
    DWORD rgbSelected;
    DWORD rgbUnselected;
    PVOID pv;

    ENTER("LoadBitmaps");

    rgbSelected = FlipColor(GetSysColor(COLOR_HIGHLIGHT));
    rgbUnselected = FlipColor(GetSysColor(COLOR_WINDOW));

    h = FindResource(hAppInstance, MAKEINTRESOURCE(BITMAPS), RT_BITMAP);
    if (!h) {
        return FALSE;
    }

    n = SizeofResource(hAppInstance, h);
    lpBitmapInfo = (LPBITMAPINFOHEADER)LocalAlloc(LPTR, n);
    if (!lpBitmapInfo)
        return FALSE;

    /* Load the bitmap and copy it to R/W memory */
    hRes = LoadResource(hAppInstance, h);
    pv = (PVOID) LockResource(hRes);
    if (pv)
        memcpy( lpBitmapInfo, pv, n );
    UnlockResource(hRes);
    FreeResource(hRes);

    p = (DWORD *)((LPSTR)(lpBitmapInfo) + lpBitmapInfo->biSize);

    /* Search for the Solid Blue entry and replace it with the current
     * background RGB.
     */
    numcolors = 16;

    while (numcolors-- > 0) {
        if (*p == BACKGROUND)
            *p = rgbUnselected;
        else if (*p == BACKGROUNDSEL)
            *p = rgbSelected;
        else if (*p == BUTTONFACE)
            *p = FlipColor(GetSysColor(COLOR_BTNFACE));
        else if (*p == BUTTONSHADOW)
            *p = FlipColor(GetSysColor(COLOR_BTNSHADOW));

        p++;
    }

    /* Now create the DIB. */

    /* First skip over the header structure */
    lpBits = (LPSTR)(lpBitmapInfo + 1);

    /* Skip the color table entries, if any */
    lpBits += (1 << (lpBitmapInfo->biBitCount)) * sizeof(RGBQUAD);

    /* Create a color bitmap compatible with the display device */
    hdc = GetDC(NULL);
    if (hdcMem = CreateCompatibleDC(hdc)) {

        if (hbmBitmaps = CreateDIBitmap(hdc, lpBitmapInfo, (DWORD)CBM_INIT, lpBits, (LPBITMAPINFO)lpBitmapInfo, DIB_RGB_COLORS))
            hbmSave = SelectObject(hdcMem, hbmBitmaps);

    }
    ReleaseDC(NULL, hdc);



    LEAVE("LoadBitmaps");

    return TRUE;
}

//
// void GetSavedWindow(LPSTR szBuf, PSAVE_WINDOW pwin)
//
// in:
//      szBuf   buffer to parse out all the saved window stuff
//              if NULL pwin is filled with all defaults
// out:
//      pwin    this structure is filled with all fields from
//              szBuf.  if any fields do not exist this is
//              initialized with the standard defaults
//

VOID
GetSavedWindow(
              LPSTR szBuf,
              PSAVE_WINDOW pwin
              )
{
    PINT pint;
    INT count;

    ENTER("GetSavedWindow");

    // defaults

    pwin->rc.right = pwin->rc.left = CW_USEDEFAULT;
    pwin->pt.x = pwin->pt.y = pwin->rc.top = pwin->rc.bottom = 0;
    pwin->sw = SW_SHOWNORMAL;
    pwin->sort = IDD_NAME;
    pwin->view = VIEW_NAMEONLY;
    pwin->attribs = ATTR_DEFAULT;
    pwin->split = 0;

    pwin->szDir[0] = 0;

    if (!szBuf)
        return;

    count = 0;
    pint = (PINT)&pwin->rc;         // start by filling the rect

    while (*szBuf && count < 11) {

        *pint++ = atoi(szBuf);  // advance to next field

        while (*szBuf && *szBuf != ',')
            szBuf++;

        while (*szBuf && *szBuf == ',')
            szBuf++;

        count++;
    }

    lstrcpy(pwin->szDir, szBuf);    // this is the directory

    LEAVE("GetSavedWindow");
}


// szDir (OEM) path to check for existance

BOOL
CheckDirExists(
              LPSTR szDir
              )
{
    BOOL bRet = FALSE;

    ENTER("CheckDirExists");
    PRINT(BF_PARMTRACE, "szDir=%s", szDir);

    if (IsNetDrive((WORD)(DRIVEID(szDir))) == 2)
        return FALSE;

    if (IsValidDisk(DRIVEID(szDir)))
        bRet = !SheChangeDir(szDir);

    LEAVE("CheckDirExists");

    return bRet;
}



// return the tree directory in szTreeDir

BOOL
APIENTRY
CreateSavedWindows()
{
    CHAR buf[MAXPATHLEN+7*7], key[10];
    INT dir_num;
    HWND hwnd;
    SAVE_WINDOW win;
    INT iNumTrees;

    ENTER("CreateSavedWindows");

    // make sure this thing exists so we don't hit drives that don't
    // exist any more

    dir_num = 1;
    iNumTrees = 0;

    do {
        wsprintf(key, szDirKeyFormat, dir_num++);

        GetPrivateProfileString(szSettings, key, szNULL, buf, sizeof(buf), szTheINIFile);

        if (*buf) {
            CHAR szDir[MAXPATHLEN];

            GetSavedWindow(buf, &win);
            AnsiUpperBuff(win.szDir, 1);

            // clean off some junk so we
            // can do this test

            lstrcpy(szDir, win.szDir);
            StripFilespec(szDir);
            StripBackslash(szDir);
            FixAnsiPathForDos(szDir);

            if (!CheckDirExists(szDir))
                continue;

            wNewView = (WORD)win.view;
            wNewSort = (WORD)win.sort;
            dwNewAttribs = win.attribs;

            hwnd = CreateTreeWindow(win.szDir, win.split);

            if (!hwnd) {
                LEAVE("CreateSavedWindows");
                return FALSE;
            }

            iNumTrees++;

            // keep track of this for now...


            SetInternalWindowPos(hwnd, win.sw, &win.rc, &win.pt);
        }

    } while (*buf);

    // if nothing was saved create a tree for the current drive

    if (!iNumTrees) {
        //lstrcpy(buf, szOriginalDirPath);
        lstrcpy(buf, "\\"); // Don't use current filesystem directory
        lstrcat(buf, szStarDotStar);

        hwnd = CreateTreeWindow(buf, -1);// default to split window
        if (!hwnd)
            return FALSE;

        // ShowWindow(hwnd, SW_MAXIMIZE);

        iNumTrees++;
    }

    LEAVE("CreateSavedWindows - Ok");
    return TRUE;
}


// void  APIENTRY GetTextStuff(HDC hdc)
//
// this computues all the globals that are dependant on the
// currently selected font
//
// in:
//      hdc     DC with font selected into it
//

VOID
APIENTRY
GetTextStuff(
            HDC hdc
            )
{
    ENTER("GetTextStuff");

    MGetTextExtent(hdc, "M", 1, &dxText, &dyText);
    MGetTextExtent(hdc, szEllipses, 3, &dxEllipses, NULL);

    // these are all dependant on the text metrics

    dxDrive = dxDriveBitmap + dxText + (4*dyBorderx2);
    dyDrive = max(dyDriveBitmap + (4*dyBorderx2), dyText);

    // dxFileName = dxFolder + (12*dxText);
    dyFileName = max(dyText, dyFolder);   //  + dyBorder;

    LEAVE("GetTextStuff");
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  InitFileManager() -                                                     */
/*                                                                          */
/*--------------------------------------------------------------------------*/

BOOL
APIENTRY
InitFileManager(
               HANDLE hInstance,
               HANDLE hPrevInstance,
               LPSTR lpCmdLine,
               INT nCmdShow
               )
{
    INT           i;
    WORD          ret;
    INT           nHardDisk;
    HDC           hdcScreen;
    CHAR          szBuffer[128];
    HCURSOR       hcurArrow;
    WNDCLASS      wndClass;
    SAVE_WINDOW   win;
    HWND          hwnd;
    HANDLE hOld;
    LPSTR         lpT;
    TEXTMETRIC    tm;
    CHAR szTemp[80];

    ENTER("InitFileManager");
    PRINT(BF_PARMTRACE, "lpCmdLine=%s", lpCmdLine);
    PRINT(BF_PARMTRACE, "nCmdShow=%d", IntToPtr(nCmdShow));

    // ProfStart();

    hAppInstance = hInstance;     // Preserve this instance's module handle
    /* Set the Global DTA Address. This must be done before ExecProgram. */
    DosGetDTAAddress();

    if (*lpCmdLine)
        nCmdShow = SW_SHOWMINNOACTIVE;

    PRINT(BF_PARMTRACE, "lpCmdLine=%s", lpCmdLine);
    PRINT(BF_PARMTRACE, "nCmdShow=%d", IntToPtr(nCmdShow));

#ifdef LATER
    if (hPrevInstance) {
        // if we are already running bring up the other instance

        +++GetInstanceData - NOOP on 32BIT side+++(hPrevInstance, (NLPSTR)&hwndFrame, sizeof(HWND));

        if (hwndFrame) {

            hwnd = GetLastActivePopup(hwndFrame);

            BringWindowToTop(hwndFrame);

            if (IsIconic(hwndFrame))
                ShowWindow(hwndFrame, SW_RESTORE);
            else
                SetActiveWindow(hwnd);
        }
        LEAVE("InitFileManager");
        return FALSE;
    }
#else
    UNREFERENCED_PARAMETER(hPrevInstance);
    {
        HWND hwndT;
        BYTE szClass[20];

        if (CreateEvent(NULL, TRUE, FALSE, szFrameClass) == NULL) {
            for (hwndT = GetWindow(GetDesktopWindow(), GW_CHILD); hwndT;
                hwndT = GetWindow(hwndT, GW_HWNDNEXT)) {
                if (GetClassName(hwndT, szClass, sizeof(szClass)))
                    if (!lstrcmpi(szFrameClass, szClass)) {
                        SetForegroundWindow(hwndT);
                        if (IsIconic(hwndT))
                            ShowWindow(hwndT, SW_RESTORE);
                        return FALSE;
                    }
            }

            return FALSE;
        }
    }
#endif


    SetErrorMode(1);              // turn off critical error 

//    if (lpfnRegisterPenApp = (FNPENAPP)GetProcAddress((HANDLE)GetSystemMetrics(SM_PENWINDOWS), szPenReg))
//        (*lpfnRegisterPenApp)(1, TRUE);


    /* Remember the current directory. */
    SheGetDir(0, szOriginalDirPath);

    if (!GetWindowsDirectory(szTheINIFile, sizeof(szTheINIFile))) {
        szTheINIFile[0] = '\0';
    }

    AddBackslash(szTheINIFile);
    lstrcat(szTheINIFile, szINIFile);

    GetProfileString(szWindows, "Programs", szDefPrograms, szTemp, sizeof(szTemp));
    szPrograms = (LPSTR)LocalAlloc(LPTR, lstrlen(szTemp)+1);
    if (!szPrograms)
        szPrograms = szNULL;
    else
        lstrcpy(szPrograms, szTemp);

    BuildDocumentString();

    /* Deal with any RUN= or LOAD= lines in WIN.INI. */

    if (*lpCmdLine) {
        // skip spaces
        while (*lpCmdLine == ' ')
            lpCmdLine++;

        for (lpT = lpCmdLine; *lpT; lpT = AnsiNext(lpT)) {
            if (*lpT == ' ')
                break;
        }
        if (*lpT == ' ')
            *lpT++ = 0;

        ret = ExecProgram(lpCmdLine, lpT, NULL, FALSE);
        if (ret)
            MyMessageBox(NULL, IDS_EXECERRTITLE, ret, MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
        else
            nCmdShow = SW_SHOWMINNOACTIVE;
    }

    /* Read WINFILE.INI and set the approriate variables. */
    GetSettings();

    /* Read the International constants out of WIN.INI. */
    GetInternational();

    dyBorder = GetSystemMetrics(SM_CYBORDER);
    dyBorderx2 = dyBorder * 2;
    dxFrame = GetSystemMetrics(SM_CXFRAME) - dyBorder;

    dxDriveBitmap = DRIVES_WIDTH;
    dyDriveBitmap = DRIVES_HEIGHT;
    dxFolder = FILES_WIDTH;
    dyFolder = FILES_HEIGHT;

    if (!LoadBitmaps())
        return FALSE;

    hicoTree = LoadIcon(hAppInstance, MAKEINTRESOURCE(TREEICON));
    hicoTreeDir = LoadIcon(hAppInstance, MAKEINTRESOURCE(TREEDIRICON));
    hicoDir = LoadIcon(hAppInstance, MAKEINTRESOURCE(DIRICON));

    chFirstDrive = (CHAR)((wTextAttribs & TA_LOWERCASE) ? 'a' : 'A');

    // now build the parameters based on the font we will be using

    hdcScreen = GetDC(NULL);

    hOld = SelectObject(hdcScreen, hFont);
    GetTextStuff(hdcScreen);
    if (hOld)
        SelectObject(hdcScreen, hOld);

    dxClickRect = max(GetSystemMetrics(SM_CXDOUBLECLK) / 2, 2 * dxText);
    dyClickRect = max(GetSystemMetrics(SM_CYDOUBLECLK) / 2, dyText);

    hFontStatus = CreateFont(GetHeightFromPointsString("10"), 0, 0, 0, 400, 0, 0, 0,
                             ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                             DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, szHelv);

    hOld = SelectObject(hdcScreen, hFontStatus);

    GetTextMetrics(hdcScreen, &tm);

    if (hOld)
        SelectObject(hdcScreen, hOld);

    dyStatus = tm.tmHeight + tm.tmExternalLeading + 7 * dyBorder;
    dxStatusField = GetDeviceCaps(hdcScreen, LOGPIXELSX) * 3;

    ReleaseDC(NULL, hdcScreen);

    cDrives = UpdateDriveList();

    /* Create an array of INT 13h drive numbers (floppies only). */
    nFloppies = 0;
    nHardDisk = 0x80;
    for (i=0; i < cDrives; i++) {
        if (IsRemovableDrive(rgiDrive[i])) {
            /* Avoid Phantom B: problems. */
            if ((nFloppies == 1) && (i > 1))
                nFloppies = 2;
            nFloppies++;
        } else {
            nHardDisk++;
        }
    }

    /* Load the accelerator table. */
    hAccel = LoadAccelerators(hInstance, MAKEINTRESOURCE(WFACCELTABLE));

    LoadString(hInstance, IDS_DIRSREAD, szDirsRead, sizeof(szDirsRead));
    LoadString(hInstance, IDS_BYTES, szBytes, sizeof(szBytes));
    LoadString(hInstance, IDS_SBYTES, szSBytes, sizeof(szSBytes));

    wDOSversion = DOS_320;

    wHelpMessage = RegisterWindowMessage("ShellHelp");
    wBrowseMessage = RegisterWindowMessage("commdlg_help");

    hhkMessageFilter = SetWindowsHook(WH_MSGFILTER, MessageFilter);

    hcurArrow = LoadCursor(NULL, IDC_ARROW);

    wndClass.lpszClassName  = szFrameClass;
    wndClass.style          = 0;
    wndClass.lpfnWndProc    = FrameWndProc;
    wndClass.cbClsExtra     = 0;
    wndClass.cbWndExtra     = 0;
    wndClass.hInstance      = hInstance;
    wndClass.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(APPICON));
    wndClass.hCursor        = hcurArrow;
    wndClass.hbrBackground  = (HBRUSH)(COLOR_APPWORKSPACE + 1); // COLOR_WINDOW+1;
    wndClass.lpszMenuName   = MAKEINTRESOURCE(FRAMEMENU);

    if (!RegisterClass(&wndClass)) {
        LEAVE("InitFileManager");
        return FALSE;
    }

    wndClass.lpszClassName  = szTreeClass;
    wndClass.style          = CS_VREDRAW | CS_HREDRAW;
    wndClass.lpfnWndProc    = TreeWndProc;
//  wndClass.cbClsExtra     = 0;
    wndClass.cbWndExtra     = sizeof(LONG) +// GWL_TYPE
                              sizeof(LONG) +// wViewStyle GWL_VIEW
                              sizeof(LONG) +// wSortStyle GWL_SORT
                              sizeof(LONG) +// dwAttrStyle GWL_ATTRIBS
                              sizeof(LONG) +// FSC flag GWL_FSCFLAG
                              sizeof(PVOID) +// hwndLastFocus GWL_LASTFOCUS
                              sizeof(LONG); // dxSplit GWL_SPLIT

    wndClass.hIcon          = NULL;
    wndClass.hCursor        = LoadCursor(hInstance, MAKEINTRESOURCE(SPLITCURSOR));
    wndClass.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wndClass.lpszMenuName   = NULL;

    if (!RegisterClass(&wndClass)) {
        LEAVE("InitFileManager");
        return FALSE;
    }

    wndClass.lpszClassName  = szDrivesClass;
    wndClass.style          = CS_HREDRAW | CS_VREDRAW;
    wndClass.lpfnWndProc    = DrivesWndProc;
    wndClass.cbWndExtra     = sizeof(LONG) +// GWL_CURDRIVEIND
                              sizeof(LONG) +// GWL_CURDRIVEFOCUS
                              sizeof(PVOID); // GWLP_LPSTRVOLUME

    wndClass.hCursor        = hcurArrow;
    wndClass.hbrBackground  = (HBRUSH)(COLOR_BTNFACE+1);

    if (!RegisterClass(&wndClass)) {
        LEAVE("InitFileManager");
        return FALSE;
    }

    wndClass.lpszClassName  = szTreeControlClass;
    wndClass.style          = CS_DBLCLKS | CS_VREDRAW | CS_HREDRAW;
    wndClass.lpfnWndProc    = TreeControlWndProc;
    wndClass.cbWndExtra     = sizeof(LONG); // GWL_READLEVEL
    wndClass.hCursor        = hcurArrow;
    wndClass.hbrBackground  = NULL;

    if (!RegisterClass(&wndClass)) {
        LEAVE("InitFileManager");
        return FALSE;
    }

    wndClass.lpszClassName  = szDirClass;
    wndClass.style          = CS_VREDRAW | CS_HREDRAW;
    wndClass.lpfnWndProc    = DirWndProc;
    wndClass.cbWndExtra     = sizeof(PVOID)+ // DTA data GWLP_HDTA
                              sizeof(PVOID); // GWLP_TABARRAY

    wndClass.hIcon          = NULL;
    wndClass.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);

    if (!RegisterClass(&wndClass)) {
        LEAVE("InitFileManager");
        return FALSE;
    }

    wndClass.lpszClassName  = szSearchClass;
    wndClass.style          = 0;
    wndClass.lpfnWndProc    = SearchWndProc;
    wndClass.cbWndExtra     = sizeof(LONG) +        // GWL_TYPE
                              sizeof(LONG) +        // wViewStyle GWL_VIEW
                              sizeof(LONG) +        // wSortStyle GWL_SORT
                              sizeof(LONG) +        // dwAttrStyle GWL_ATTRIBS
                              sizeof(LONG) +        // FSC flag GWL_FSCFLAG
                              sizeof(PVOID) +       // GWLP_HDTASEARCH
                              sizeof(PVOID) +       // GWLP_TABARRAYSEARCH
                              sizeof(PVOID);        // GWLP_LASTFOCUSSEARCH

    wndClass.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(DIRICON));
    wndClass.hbrBackground  = NULL;

    if (!RegisterClass(&wndClass)) {
        LEAVE("InitFileManager");
        return FALSE;
    }


    if (!LoadString(hInstance, IDS_WINFILE, szTitle, 32)) {
        LEAVE("InitFileManager");
        return FALSE;
    }

    GetPrivateProfileString(szSettings, szWindow, szNULL, szBuffer, sizeof(szBuffer), szTheINIFile);
    GetSavedWindow(szBuffer, &win);


    if (!CreateWindowEx(0, szFrameClass, szTitle,WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
                        win.rc.left, win.rc.top, win.rc.right, win.rc.bottom,
                        NULL, NULL, hInstance, NULL)) {

        LEAVE("InitFileManager - Frame class creation failure");
        return FALSE;
    }


    InitMenus();            // after the window/menu has been created

    // support forced min or max

    if (nCmdShow == SW_SHOWNORMAL && win.sw == SW_SHOWMAXIMIZED)
        nCmdShow = SW_SHOWMAXIMIZED;

    ShowWindow(hwndFrame, nCmdShow);
    UpdateWindow(hwndFrame);

    LFNInit();

    if (!CreateSavedWindows()) {
        LEAVE("InitFileManager");
        return FALSE;
    }

    ShowWindow(hwndMDIClient, SW_NORMAL);

    // now refresh all tree windows (start background tree read)
    //
    // since the tree reads happen in the background the user can
    // change the Z order by activating windows once the read
    // starts.  to avoid missing a window we must restart the
    // search through the MDI child list, checking to see if the
    // tree has been read yet (if there are any items in the
    // list box).  if it has not been read yet we start the read

    hwnd = GetWindow(hwndMDIClient, GW_CHILD);

    while (hwnd) {
        HWND hwndTree;

        if ((hwndTree = HasTreeWindow(hwnd)) &&
            (INT)SendMessage(GetDlgItem(hwndTree, IDCW_TREELISTBOX), LB_GETCOUNT, 0, 0L) == 0) {
            SendMessage(hwndTree, TC_SETDRIVE, MAKEWORD(FALSE, 0), 0L);
            hwnd = GetWindow(hwndMDIClient, GW_CHILD);
        } else {
            hwnd = GetWindow(hwnd, GW_HWNDNEXT);
        }
    }

    // ProfStop();

    LEAVE("InitFileManager - OK");
    return TRUE;
}


VOID
APIENTRY
DeleteBitmaps()
{
    ENTER("DeleteBitmaps");

    if (hdcMem) {

        SelectObject(hdcMem, hbmSave);

        if (hbmBitmaps)
            DeleteObject(hbmBitmaps);
        DeleteDC(hdcMem);
    }
    LEAVE("DeleteBitmaps");
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  FreeFileManager() -                                                     */
/*                                                                          */
/*--------------------------------------------------------------------------*/

VOID
APIENTRY
FreeFileManager()
{
    ENTER("FreeFileManager");


    if (lpfnRegisterPenApp)
        (*lpfnRegisterPenApp)(1, FALSE);

    DeleteBitmaps();

    if (hFont)
        DeleteObject(hFont);

    if (hFontStatus)
        DeleteObject(hFontStatus);

    LEAVE("FreeFileManager");
}