macunzip.c

完整的解压zip文件的源码。包含密码功能

        if (check == 0)
            CheckItem(infoHandle, theitem, false);
        else if (check > 0)
            CheckItem(infoHandle, theitem, true);
        break;

    case formatMenu:
        switch (theitem) {
        case filenameItem:
            CheckItem(formatHandle, filenameItem, true);
            CheckItem(formatHandle, longItem, false);
            CheckItem(formatHandle, mediumItem, false);
            CheckItem(formatHandle, shortItem, false);
            modifiers &= (allFlags ^ (longFlag | mediumFlag | shortFlag));
            modifiers |= filenameFlag;
            break;
        case longItem:
            CheckItem(formatHandle, filenameItem, false);
            CheckItem(formatHandle, longItem, true);
            CheckItem(formatHandle, mediumItem, false);
            CheckItem(formatHandle, shortItem, false);
            modifiers &= (allFlags ^ (filenameFlag | mediumFlag | shortFlag));
            modifiers |= longFlag;
            break;
        case mediumItem:
            CheckItem(formatHandle, filenameItem, false);
            CheckItem(formatHandle, longItem, false);
            CheckItem(formatHandle, mediumItem, true);
            CheckItem(formatHandle, shortItem, false);
            modifiers &= (allFlags ^ (filenameFlag | longFlag | shortFlag));
            modifiers |= mediumFlag;
            break;
        case shortItem:
            CheckItem(formatHandle, filenameItem, false);
            CheckItem(formatHandle, longItem, false);
            CheckItem(formatHandle, mediumItem, false);
            CheckItem(formatHandle, shortItem, true);
            modifiers &= (allFlags ^ (filenameFlag | longFlag | mediumFlag));
            modifiers |= shortFlag;
            break;
        default:
            break;
        }
        break;

    default:
        break;

    }

    HiliteMenu(0);
    return;
}



/*
** work with shortcuts
**
*/

static void dokey(myevent) EventRecord *myevent;
{
    char code;

    code = (char)(myevent->message & charCodeMask);

    if (myevent->modifiers & cmdKey) {
        if (myevent->what != autoKey) {
            domenu(MenuKey(code));
        }
    }

    return;
}



/*
** work with mouse-events
**
*/

static void domousedown(EventRecord *myevent)
{
    WindowPtr whichwindow;
    long code;

    code = FindWindow(myevent->where, &whichwindow);

    switch (code) {

    case inSysWindow:
        SystemClick(myevent, whichwindow);
        break;

    case inMenuBar:
        domenu(MenuSelect(myevent->where));
        break;

    }

    return;
}



/*
** Do a little event-handling and let the user stop
** th current action
*/

void UserStop(void)
{
    EventRecord theEvent;

    if ( WaitNextEvent( everyEvent, &theEvent, 0, nil )) {

            switch (theEvent.what) {

        case mouseDown:
        domousedown( &theEvent );
        break;

            case autoKey:
            case keyDown:
        {
                if ((theEvent.modifiers & cmdKey) &&
                    ((theEvent.message & charCodeMask) == '.'))
                    {
                    printf("\n\n <- User Canceled -> \n");
                    exit(1);  /* setjmp() must be already called  */
                    }
                return;
                }

            } /*   switch (theEvent.what)   */
        }  /*   if ( WaitNextEvent(...  */
}



/*
** The Standalone Unzip starts here
**
*/

int main(argc, argv) int argc; char *argv[];
{
    Uz_Globs saveGlobals;
    Boolean haveEvent, useWNE;
    short markChar;
    char *ArchivePath, *ExtractPath;
    OSErr err;

    FlushEvents(everyEvent, 0);
    InitGraf(&qd.thePort);
    InitFonts();
    InitWindows();
    InitMenus();
    TEInit();
    InitDialogs(nil);
    InitCursor();

    CONSTRUCTGLOBALS();

    sprintf(UnzipVersion, "%d.%d%d%s of %s", UZ_MAJORVER, UZ_MINORVER,
        PATCHLEVEL, BETALEVEL, VERSION_DATE);
    sprintf(ZipinfoVersion, "%d.%d%d%s of %s", ZI_MAJORVER, ZI_MINORVER,
        PATCHLEVEL, BETALEVEL, VERSION_DATE);

    c2pstr(UnzipVersion);
    c2pstr(ZipinfoVersion);

    SysEnvirons(1, &sysRec);
    useWNE = TrapAvailable(sysRec.machineType, _WaitNextEvent, ToolTrap);

    SetMenuBar(menubar = GetNewMBar(unzipMenuBar));
    DisposeHandle(menubar);
    InsertMenu(GetMenu(screenMenu), -1);
    InsertMenu(GetMenu(extractMenu), -1);
    InsertMenu(GetMenu(caseMenu), -1);
    InsertMenu(GetMenu(convertMenu), -1);
    InsertMenu(GetMenu(overwriteMenu), -1);
    InsertMenu(GetMenu(infoMenu), -1);
    InsertMenu(GetMenu(formatMenu), -1);
    AppendResMenu(appleHandle = GetMenuHandle(appleMenu), 'DRVR');
    modifierHandle = GetMenuHandle(modifierMenu);
    screenHandle = GetMenuHandle(screenMenu);
    extractHandle = GetMenuHandle(extractMenu);
    caseHandle = GetMenuHandle(caseMenu);
    convertHandle = GetMenuHandle(convertMenu);
    overwriteHandle = GetMenuHandle(overwriteMenu);
    infoHandle = GetMenuHandle(infoMenu);
    formatHandle = GetMenuHandle(formatMenu);
    DrawMenuBar();

    screenOpen("Unzip");

    modifiers = 0;

    GetItemMark(modifierHandle, quietItem, &markChar);
    if (markChar) modifiers ^= quietFlag;
    GetItemMark(modifierHandle, verboseItem, &markChar);
    if (markChar) modifiers ^= verboseFlag;

    GetItemMark(screenHandle, pauseItem, &markChar);
    if (markChar) modifiers ^= pauseFlag;
    screenControl("p", markChar);
    GetItemMark(screenHandle, scrollItem, &markChar);
    if (markChar) modifiers ^= scrollFlag;
    screenControl("s", markChar);

    GetItemMark(extractHandle, screenItem, &markChar);
    if (markChar) modifiers ^= screenFlag;
    GetItemMark(extractHandle, junkItem, &markChar);
    if (markChar) modifiers ^= junkFlag;

    GetItemMark(caseHandle, insensitiveItem, &markChar);
    if (markChar) modifiers ^= insensitiveFlag;
    GetItemMark(caseHandle, lowercaseItem, &markChar);
    if (markChar) modifiers ^= lowercaseFlag;

    GetItemMark(convertHandle, autoItem, &markChar);
    if (markChar) modifiers ^= autoFlag;
    GetItemMark(convertHandle, textItem, &markChar);
    if (markChar) modifiers ^= textFlag;

    if ((modifiers & (autoFlag | textFlag)) == (autoFlag | textFlag)) {
        CheckItem(convertHandle, textItem, false);
        modifiers &= (allFlags ^ textFlag);
    } else if (modifiers & (autoFlag | textFlag))
        CheckItem(convertHandle, binaryItem, false);
    else
        CheckItem(convertHandle, binaryItem, true);

    GetItemMark(overwriteHandle, alwaysItem, &markChar);
    if (markChar) modifiers ^= overwriteFlag;
    GetItemMark(overwriteHandle, neverItem, &markChar);
    if (markChar) modifiers ^= neverFlag;

    if ((modifiers & (neverFlag | overwriteFlag)) == (neverFlag | overwriteFlag)) {
        CheckItem(overwriteHandle, alwaysItem, false);
        CheckItem(overwriteHandle, neverItem, false);
        CheckItem(overwriteHandle, promptItem, true);
        modifiers &= (allFlags ^ (neverFlag | overwriteFlag));
    } else if (modifiers & (neverFlag | overwriteFlag))
        CheckItem(overwriteHandle, promptItem, false);
    else
        CheckItem(overwriteHandle, promptItem, true);

    GetItemMark(infoHandle, prtCommentItem, &markChar);
    if (markChar) modifiers ^= prtCommentFlag;
    GetItemMark(infoHandle, prtHeaderItem, &markChar);
    if (markChar) modifiers ^= prtHeaderFlag;
    GetItemMark(infoHandle, prtTotalsItem, &markChar);
    if (markChar) modifiers ^= prtTotalsFlag;

    GetItemMark(formatHandle, filenameItem, &markChar);
    if (markChar) modifiers ^= filenameFlag;
    GetItemMark(formatHandle, longItem, &markChar);
    if (markChar) modifiers ^= longFlag;
    GetItemMark(formatHandle, mediumItem, &markChar);
    if (markChar) modifiers ^= mediumFlag;
    GetItemMark(formatHandle, shortItem, &markChar);
    if (markChar) modifiers ^= shortFlag;

    if (modifiers & longFlag) {
        CheckItem(formatHandle, filenameItem, false);
        CheckItem(formatHandle, mediumItem, false);
        CheckItem(formatHandle, shortItem, false);
        modifiers &= (allFlags ^ (filenameFlag | mediumFlag | shortFlag));
    } else if (modifiers & mediumFlag) {
        CheckItem(formatHandle, filenameItem, false);
        CheckItem(formatHandle, shortItem, false);
        modifiers &= (allFlags ^ (filenameFlag | shortFlag));
    } else if (modifiers & shortFlag) {
        CheckItem(formatHandle, filenameItem, false);
        modifiers &= (allFlags ^ filenameFlag);
    }

    command = ' ';

    stop = false;
    while (!stop) {
        SetCursor(&qd.arrow);

        if (useWNE) {
            haveEvent = WaitNextEvent(everyEvent, &myevent, LONG_MAX, NULL);
        } else {
            SystemTask();
            haveEvent = GetNextEvent(everyEvent, &myevent);
        }

        if (haveEvent) {
            switch (myevent.what) {

            case activateEvt:
                break;

            case keyDown:
            case autoKey:
                dokey(&myevent);
                break;

            case mouseDown:
                domousedown(&myevent);
                break;

            case updateEvt:
                screenUpdate((WindowPtr)myevent.message);
                break;

            case mouseUp:
            case keyUp:
                break;

            default:
                break;

            }
        }

        if (command != ' ') {
            char *s, **v, modifierString[32];
            Point p;
            int m, n;
            SFTypeList          myTypes = {'TEXT', '.zip'};
            StandardFileReply   myReply;

            SetPt(&p, 40, 40);

            StandardGetFile(nil, 2, myTypes, &myReply);

            ArchivePath = StrCalloc(512);
            ExtractPath = StrCalloc(512);

            GetFullPathFromSpec(ArchivePath, &myReply.sfFile, &err);

            strcpy(ExtractPath,ArchivePath);
            FindNewExtractFolder(ExtractPath);

            if (myReply.sfGood && (CheckMountedVolumes(ArchivePath) == 1)) {
                modifierMask &= modifiers;

                s = modifierString;

                *s++ = '-';
                if ((command != 'x') && (command != 'Z')) *s++ = command;

                if (modifierMask) {
                    if (modifierMask & (autoFlag | textFlag)) *s++ = 'a';
                    if (modifierMask & textFlag) *s++ = 'a';
                    if (modifierMask & insensitiveFlag) *s++ = 'C';
                    if (modifierMask & junkFlag) *s++ = 'j';
                    if (modifierMask & lowercaseFlag) *s++ = 'L';
                    if (modifierMask & neverFlag) *s++ = 'n';
                    if (modifierMask & overwriteFlag) *s++ = 'o';
                    if (modifierMask & quietFlag) *s++ = 'q';
                    if (modifierMask & verboseFlag) *s++ = 'v';

                    if (modifierMask & prtCommentFlag) *s++ = 'z';
                    if (modifierMask & prtHeaderFlag) *s++ = 'h';
                    if (modifierMask & prtTotalsFlag) *s++ = 't';
                    if (modifierMask & filenameFlag) *s++ = '2';
                    if (modifierMask & longFlag) *s++ = 'l';
                    if (modifierMask & mediumFlag) *s++ = 'm';
                    if (modifierMask & shortFlag) *s++ = 's';
                }

                if (*(s - 1) == '-') s -= 1;

                *s++ = 'd';
                *s = '\0';

                v = (char **)malloc(sizeof(char *));
                *v = "unzip";
                argc = 1;

                envargs(&argc, &v, NULL, NULL);

                argv = (char **)malloc((argc + 3) * sizeof(char *));

                argv[m = 0] = (command == 'Z') ? "zipinfo" : "unzip";
                if (*modifierString) argv[++m] = modifierString;
                argv[++m] = ExtractPath;
                argv[++m] = ArchivePath;
                for (n = 1; n < argc; n++) argv[n + m] = v[n];
                argv[argc += m] = NULL;

                free(v);

                for (n = 0; argv[n] != NULL; n++) printf("%s ", argv[n]);
                printf("...\n\n");

                memcpy(&saveGlobals, &G, sizeof(Uz_Globs));

                unzip(__G__ argc, argv);

                memcpy(&G, &saveGlobals, sizeof(Uz_Globs));

                ArchivePath = StrFree(ArchivePath);
                ExtractPath = StrFree(ExtractPath);

                printf("\nDone\n");
            }

            fileList[0] = '\0';
            command = ' ';
        }
    }

    screenClose();

    DESTROYGLOBALS()

    ExitToShell();

return 0;
}