Annotation of mstools/mssetup/sample/setup.c, revision 1.1.1.1

1.1       root        1: #include <windows.h>
                      2: #include <stdlib.h>
                      3: #include <direct.h>
                      4: #include "setupapi.h"
                      5: #include "msdetect.h"
                      6: #include "msregdb.h"
                      7: #include "msshared.h"
                      8: 
                      9: #include "sample.h"
                     10: 
                     11: 
                     12: INT    installType;
                     13: CHAR   szInstallPath[cchMax];
                     14: CHAR   szSrcDir[cchMax];
                     15: 
                     16: 
                     17: HANDLE hInst;
                     18: 
                     19: 
                     20: /* ********************************************************************* */
                     21: VOID BuildLists()
                     22: {
                     23:        int iCursorSav = ShowWaitCursor();
                     24: 
                     25:        BuildCopyList();
                     26:        BuildBillboardList();
                     27: 
                     28:        RestoreCursor(iCursorSav);
                     29: }
                     30: 
                     31: 
                     32: /* ********************************************************************* */
                     33: VOID BuildCopyList()
                     34: {
                     35:        ClearCopyList();
                     36:        AddSectionFilesToCopyList("Minimum Files", szSrcDir, szInstallPath);
                     37: 
                     38:        if (installType == itComplete)
                     39:                AddSectionFilesToCopyList("Extra Files", szSrcDir, szInstallPath);
                     40: }
                     41: 
                     42: 
                     43: /* ********************************************************************* */
                     44: VOID BuildBillboardList()
                     45: {
                     46:        AddToBillboardList("mscuistf.dll", DLG_BOARD1, "FModelessDlgProc", 5);
                     47:        AddToBillboardList("mscuistf.dll", DLG_BOARD2, "FModelessDlgProc", 5);
                     48:        AddToBillboardList("mscuistf.dll", DLG_BOARD3, "FModelessDlgProc", 5);
                     49:        AddToBillboardList("mscuistf.dll", DLG_BOARD4, "FModelessDlgProc", 5);
                     50: 
                     51:        SetCopyGaugePosition(155, 130);
                     52: }
                     53: 
                     54: 
                     55: /* ********************************************************************* */
                     56: VOID Install()
                     57: {
                     58:        CHAR rgchT[16];
                     59:        INT  iCursorSav;
                     60: 
                     61:        CopyFilesInCopyList();
                     62: 
                     63:        UIStartDlg("mscuistf.dll", DLG_REGINI, "FModelessDlgProc", 0, NULL,
                     64:                        (LPSTR)rgchT, 16);
                     65:        iCursorSav = ShowWaitCursor();
                     66:        
                     67:        CreateIniKeyValue("WIN.INI", "Extensions", "smp", SzCat2Str(szInstallPath,
                     68:                        "SAMPLE.EXE ^.", "smp"), cmoOverwrite);
                     69: 
                     70:        CreateIniKeyValue("WIN.INI", "Sample", "Path", szInstallPath, cmoOverwrite);
                     71: 
                     72:        CreateProgmanGroup("Sample 4.0", "", cmoVital);
                     73:        ShowProgmanGroup("Sample 4.0",  1, cmoVital);
                     74: 
                     75:        CreateProgmanItem("Sample 4.0", "Sample Exe", SzCatStr(szInstallPath,
                     76:                                "sample.exe"), "", cmoOverwrite);
                     77: 
                     78:        RestoreCursor(iCursorSav);
                     79:        UIPop(1);
                     80: }
                     81: 
                     82: 
                     83: 
                     84: 
                     85: 
                     86: /* **************************************************************** */
                     87: VOID AskQuit()
                     88: {
                     89:        CHAR rgchT[16];
                     90: 
                     91:        while (TRUE)
                     92:                {
                     93:                UIStartDlg("mscuistf.dll", DLG_QUIT, "FQuitDlgProc", HELP_ASKQUIT,
                     94:                        "FHelpDlgProc", (LPSTR)rgchT, 15);
                     95:        
                     96:                switch ((WORD)(rgchT[0]+rgchT[1]))
                     97:                        {
                     98:                default:
                     99:                        continue;
                    100: 
                    101:                case IDC_QUITEXIT:
                    102:                        UIPopAll();
                    103:                        EndSetupToolkit();
                    104:                        exit(0);
                    105: 
                    106:                case IDC_CANCEL:
                    107:                case IDC_QUITCONTINUE:
                    108:                        break;
                    109:                        }
                    110: 
                    111:                UIPop(1);
                    112:                return;
                    113:                }
                    114: }
                    115: 
                    116: /* **************************************************************** */
                    117: VOID WelcomeDialog()
                    118: {
                    119:         CHAR rgchT[16];
                    120: 
                    121:         while (TRUE)
                    122:             {
                    123:                UIStartDlg("mscuistf.dll", DLG_WELCOME, "FInfoDlgProc",
                    124:                                HELP_APPLICATION, "FHelpDlgProc", (LPSTR)rgchT, 15);
                    125:        
                    126:                switch ((WORD)(rgchT[0]+rgchT[1]))
                    127:                        {
                    128:                case IDC_CANCEL:
                    129:                case IDC_TYPEEXIT:
                    130:                        AskQuit();
                    131:                        continue;
                    132: 
                    133:                default:
                    134:                        continue;
                    135: 
                    136:                case IDC_CONTINUE:
                    137:                        break;
                    138:                        }
                    139: 
                    140:                UIPop(1);
                    141:                return;
                    142:                }
                    143: }
                    144: 
                    145: /* **************************************************************** */
                    146: VOID InstallTypeDialog()
                    147: {
                    148:        CHAR rgchT[16];
                    149: 
                    150:        while (TRUE)
                    151:                {
                    152:                SetSymbolValue("RadioDefault", "1");
                    153:                UIStartDlg("mscuistf.dll", DLG_INSTALLTYPE, "FRadioDlgProc",
                    154:                                HELP_INSTALLTYPE, "FHelpDlgProc", (LPSTR)rgchT, 15);
                    155:        
                    156:                switch ((WORD)(rgchT[0]+rgchT[1]))
                    157:                        {
                    158:                case IDC_CANCEL:
                    159:                case IDC_TYPEEXIT:
                    160:                        AskQuit();
                    161:                        continue;
                    162: 
                    163:                default:
                    164:                        continue;
                    165: 
                    166:                case IDC_CONTINUE:
                    167:                        GetSymbolValue("ButtonChecked", rgchT, 15);
                    168:                        installType = (*rgchT == '1') ? itComplete : itMinimum;
                    169:                        break;
                    170:                        }
                    171: 
                    172:                UIPop(1);
                    173:                return;
                    174:                }
                    175: }
                    176: 
                    177: 
                    178: /* **************************************************************** */
                    179: VOID BlankPathDialog()
                    180: {
                    181:        CHAR rgchT[16];
                    182: 
                    183:        while (TRUE)
                    184:                {
                    185:                UIStartDlg("mscuistf.dll", DLG_BLANK, "FInfo0DlgProc", 0, NULL,
                    186:                                (LPSTR)rgchT, 15);
                    187:        
                    188:                switch ((WORD)(rgchT[0]+rgchT[1]))
                    189:                        {
                    190:                default:
                    191:                        continue;
                    192: 
                    193:                case IDC_BLANKEXIT:
                    194:                        AskQuit();
                    195:                        continue;
                    196: 
                    197:                case IDC_CANCEL:
                    198:                case IDC_BLANKCONTINUE:
                    199:                        break;
                    200:                        }
                    201: 
                    202:                UIPop(1);
                    203:                return;
                    204:                }
                    205: }
                    206: 
                    207: 
                    208: /* **************************************************************** */
                    209: VOID DestIsSrcDialog()
                    210: {
                    211:        CHAR rgchT[16];
                    212: 
                    213:        while (TRUE)
                    214:                {
                    215:                UIStartDlg("mscuistf.dll", DLG_DESTISSRC, "FInfo0DlgProc", 0, NULL,
                    216:                                (LPSTR)rgchT, 15);
                    217:        
                    218:                switch ((WORD)(rgchT[0]+rgchT[1]))
                    219:                        {
                    220:                default:
                    221:                        continue;
                    222: 
                    223:                case IDC_DESTISSRCEXIT:
                    224:                        AskQuit();
                    225:                        continue;
                    226: 
                    227:                case IDC_CANCEL:
                    228:                case IDC_DESTISSRCCONTINUE:
                    229:                        break;
                    230:                        }
                    231: 
                    232:                UIPop(1);
                    233:                return;
                    234:                }
                    235: }
                    236: 
                    237: 
                    238: /* **************************************************************** */
                    239: VOID InvalidPathDialog()
                    240: {
                    241:        CHAR rgchT[16];
                    242: 
                    243:        while (TRUE)
                    244:                {
                    245:                UIStartDlg("mscuistf.dll", DLG_INVALIDPATH, "FInfo0DlgProc", 0, NULL,
                    246:                                (LPSTR)rgchT, 15);
                    247:        
                    248:                switch ((WORD)(rgchT[0]+rgchT[1]))
                    249:                        {
                    250:                default:
                    251:                        continue;
                    252: 
                    253:                case IDC_INVALIDEXIT:
                    254:                        AskQuit();
                    255:                        continue;
                    256: 
                    257:                case IDC_CANCEL:
                    258:                case IDC_INVALIDCONTINUE:
                    259:                        break;
                    260:                        }
                    261: 
                    262:                UIPop(1);
                    263:                return;
                    264:                }
                    265: }
                    266: 
                    267: 
                    268: /* **************************************************************** */
                    269: VOID AppendSlash(LPSTR sz1)
                    270: {
                    271:        LPSTR sz2 = sz1;
                    272: 
                    273:        while (*sz2)
                    274:                {
                    275:                sz1 = sz2;
                    276:                sz2 = AnsiNext(sz1);
                    277:                }
                    278: 
                    279:        if (sz2 != sz1 + 1 || *sz1 != '\\')
                    280:                {
                    281:                *sz2++ = '\\';
                    282:                *sz2 = '\0';
                    283:                }
                    284: }
                    285: 
                    286: 
                    287: /* **************************************************************** */
                    288: VOID StripSlash(LPSTR sz1)
                    289: {
                    290:        LPSTR sz2 = sz1;
                    291: 
                    292:        while (*sz2)
                    293:                {
                    294:                sz1 = sz2;
                    295:                sz2 = AnsiNext(sz1);
                    296:                }
                    297: 
                    298:        if (sz2 == sz1 + 1 && *sz1 == '\\')
                    299:                *sz1 = '\0';
                    300: }
                    301: 
                    302: 
                    303: /* **************************************************************** */
                    304: BOOL FInstallPathDialog()
                    305: {
                    306:        CHAR rgchT[16];
                    307:        BOOL fRet;
                    308:        CHAR sz[cchMax];
                    309: 
                    310:        lstrcpy(sz, szInstallPath);
                    311: 
                    312:        StripSlash(sz);
                    313:        SetSymbolValue("EditTextIn", sz);
                    314:        SetSymbolValue("EditFocus", "END");
                    315: 
                    316:        while (TRUE)
                    317:                {
                    318:                UIStartDlg("mscuistf.dll", DLG_INSTALLPATH, "FEditDlgProc",
                    319:                        HELP_INSTALLPATH, "FHelpDlgProc", (LPSTR)rgchT, 15);
                    320: 
                    321:                if ((WORD)(rgchT[0]+rgchT[1]) == IDC_PATHEXIT)
                    322:                        {
                    323:                        AskQuit();
                    324:                        continue;
                    325:                        }
                    326:                else if ((WORD)(rgchT[0]+rgchT[1]) == IDC_PATHCANCEL
                    327:                                || (WORD)(rgchT[0]+rgchT[1]) == IDC_CANCEL
                    328:                                || (WORD)(rgchT[0]+rgchT[1]) == IDC_BACK)
                    329:                        {
                    330:                        fRet = FALSE;
                    331:                        break;
                    332:                        }
                    333: 
                    334:                GetSymbolValue("EditTextOut", sz, cchMax);
                    335: 
                    336:                if (lstrlen(sz) == 0)
                    337:                        {
                    338:                        BlankPathDialog();
                    339:                        continue;
                    340:                        }
                    341:        
                    342:                if (!FValidDir(sz))
                    343:                        {
                    344:                        InvalidPathDialog();
                    345:                        continue;
                    346:                        }
                    347: 
                    348:                lstrcpy(szInstallPath, sz);
                    349:                AppendSlash(szInstallPath);
                    350: 
                    351:                if (lstrcmp(szInstallPath, szSrcDir) == 0)
                    352:                        {
                    353:                        DestIsSrcDialog();
                    354:                        continue;
                    355:                        }
                    356:        
                    357:                fRet = TRUE;
                    358:                break;
                    359:                }
                    360: 
                    361:        UIPop(1);
                    362:        return fRet;
                    363: }
                    364: 
                    365: 
                    366: 
                    367: 
                    368: 
                    369: 
                    370: /* ********************************************************************* */
                    371: VOID SetupError(int error)
                    372: {
                    373:        CHAR rgchT[16];
                    374:        BOOL fLoopForDialog = TRUE;
                    375:        static BOOL fInsideSetupError = FALSE;
                    376: 
                    377:        if (!fInsideSetupError)
                    378:                {
                    379:                fInsideSetupError = TRUE;
                    380: 
                    381:                UIPopAll();
                    382: 
                    383:                while (fLoopForDialog)
                    384:                        {
                    385:                        UIStartDlg("mscuistf.dll", DLG_ERROR, "FInfo0DlgProc", 0, NULL,
                    386:                                (LPSTR)rgchT, 15);
                    387:        
                    388:                        switch ((WORD)(rgchT[0]+rgchT[1]))
                    389:                                {
                    390:                        default:
                    391:                                continue;
                    392: 
                    393:                        case IDC_CANCEL:
                    394:                        case IDC_ERROREXIT:
                    395:                                fLoopForDialog = FALSE;
                    396:                                break;
                    397:                                }
                    398:                        }
                    399: 
                    400:                UIPop(1);
                    401:                }
                    402: 
                    403:        EndSetupToolkit();
                    404:        exit(0);
                    405: }
                    406: 
                    407: 
                    408: /* **************************************************************** */
                    409: INT PASCAL WinMain(HANDLE hInstance, HANDLE hPrevInstance, LPSTR szCmdLineArgs,
                    410:                INT nCmdShow)
                    411: {
                    412:        hInst = hInstance;
                    413: 
                    414:        if (InitSetupToolkit(szCmdLineArgs) > 0)        // always should come first 
                    415:                {
                    416:                if (FInitRegDb())
                    417:                        {
                    418:                        SetBitmap("mscuistf.dll", 1);
                    419:                        SetTitle("Sample 4.0 Setup");
                    420:                        ReadInfFile(SzCatStr(szCurDir, "sample.inf"));
                    421: 
                    422:                        lstrcpy(szInstallPath, "C:\\SAMPLE\\");
                    423:                        GetSymbolValue("STF_SRCDIR", szSrcDir, cchMax);
                    424: 
                    425:                        WelcomeDialog();
                    426: 
                    427:                        do      {
                    428:                                InstallTypeDialog();
                    429:                                } while (!FInstallPathDialog());
                    430: 
                    431:                        BuildLists();
                    432:                        Install();
                    433:                        TerminateRegDb();
                    434:                        }
                    435: 
                    436:                EndSetupToolkit();
                    437:                }
                    438:        exit(0);
                    439:        return(0);
                    440: }

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.