Return to dlgMemory.c CVS log

Up to [Previous NeXT emulator] / previous_trunk / src / gui-sdl

Annotation of previous_trunk/src/gui-sdl/dlgMemory.c, revision 1.1

1.1     ! root        1: /*
        !             2:   Previous - dlgMemory.c
        !             3: 
        !             4:   This file is distributed under the GNU Public License, version 2 or at
        !             5:   your option any later version. Read the file gpl.txt for details.
        !             6: */
        !             7: const char DlgMemory_fileid[] = "Previous dlgMemory.c : " __DATE__ " " __TIME__;
        !             8: 
        !             9: #include "main.h"
        !            10: #include "dialog.h"
        !            11: #include "sdlgui.h"
        !            12: #include "file.h"
        !            13: #include "screen.h"
        !            14: 
        !            15: #define GUI_SAVE_MEMORY 0
        !            16: 
        !            17: #define DLGMEM_8MB      4
        !            18: #define DLGMEM_16MB     5
        !            19: #define DLGMEM_32MB     6
        !            20: #define DLGMEM_64MB     8
        !            21: #define DLGMEM_128MB    9
        !            22: #define DLGMEM_CUSTOM   7
        !            23: 
        !            24: #define DLGMEM_120NS    12
        !            25: #define DLGMEM_100NS    13
        !            26: #define DLGMEM_80NS     14
        !            27: #define DLGMEM_60NS     15
        !            28: 
        !            29: #if GUI_SAVE_MEMORY
        !            30: #define DLGMEM_FILENAME 19
        !            31: #define DLGMEM_SAVE     20
        !            32: #define DLGMEM_RESTORE  21
        !            33: #define DLGMEM_AUTOSAVE 22
        !            34: 
        !            35: #define DLGMEM_EXIT     23
        !            36: #else
        !            37: #define DLGMEM_EXIT     16
        !            38: #endif
        !            39: 
        !            40: void Dialog_MemDlgDraw(void);
        !            41: char custom_memsize[16] = "Customize";
        !            42: 
        !            43: /* The memory dialog: */
        !            44: static SGOBJ memorydlg[] =
        !            45: {
        !            46: #if GUI_SAVE_MEMORY
        !            47:        { SGBOX, 0, 0, 0,0, 41,28, NULL },
        !            48: #else
        !            49:     { SGBOX, 0, 0, 0,0, 41,18, NULL },
        !            50: #endif
        !            51:     { SGTEXT, 0, 0, 14,1, 12,1, "Memory options" },
        !            52: 
        !            53:        { SGBOX, 0, 0, 1,3, 19,10, NULL },
        !            54:        { SGTEXT, 0, 0, 2,4, 12,1, "Memory size" },
        !            55:        { SGRADIOBUT, 0, 0, 3,6, 6,1, "8 MB" },
        !            56:        { SGRADIOBUT, 0, 0, 3,7, 7,1, "16 MB" },
        !            57:        { SGRADIOBUT, 0, 0, 3,8, 7,1, "32 MB" },
        !            58:     { SGRADIOBUT, 0, 0, 3,11, 11,1, custom_memsize },
        !            59:        { SGRADIOBUT, 0, 0, 3,9, 7,1, "64 MB" },
        !            60:        { SGRADIOBUT, 0, 0, 3,10, 8,1, "128 MB" },
        !            61:     
        !            62:     { SGBOX, 0, 0, 21,3, 19,10, NULL },
        !            63:        { SGTEXT, 0, 0, 22,4, 12,1, "Memory speed" },
        !            64:        { SGRADIOBUT, 0, 0, 23,6, 8,1, "120 ns" },
        !            65:        { SGRADIOBUT, 0, 0, 23,7, 8,1, "100 ns" },
        !            66:        { SGRADIOBUT, 0, 0, 23,8, 7,1, "80 ns" },
        !            67:        { SGRADIOBUT, 0, 0, 23,9, 7,1, "60 ns" },
        !            68:     
        !            69:     { SGBUTTON, SG_DEFAULT, 0, 10,15, 23,1, "Back to system menu" },
        !            70: #if GUI_SAVE_MEMORY
        !            71:        { SGBOX, 0, 0, 1,14, 39,10, NULL },
        !            72:        { SGTEXT, 0, 0, 2,15, 17,1, "Load/Save memory state (untested)" },
        !            73:        { SGTEXT, 0, 0, 2,17, 20,1, "Snap-shot file name:" },
        !            74:        { SGTEXT, 0, 0, 2,18, 36,1, dlgSnapShotName },
        !            75:        { SGBUTTON, 0, 0, 8,20, 10,1, "Save" },
        !            76:        { SGBUTTON, 0, 0, 22,20, 10,1, "Restore" },
        !            77:        { SGCHECKBOX, 0, 0, 2,22, 37,1, "Load/save state at start-up/exit" },
        !            78:     
        !            79:     { SGBUTTON, SG_DEFAULT, 0, 10,26, 21,1, "Back to main menu" },
        !            80: #endif
        !            81:        { -1, 0, 0, 0,0, 0,0, NULL }
        !            82: };
        !            83: 
        !            84: /* Variable objects */
        !            85: SGOBJ disable_128mb_option = { SGTEXT, 0, 0, 3,10, 8,1, " " };
        !            86: SGOBJ enable_128mb_option = { SGRADIOBUT, 0, 0, 3,10, 8,1, "128 MB" };
        !            87: SGOBJ disable_64mb_option = { SGTEXT, 0, 0, 3,9, 7,1, " " };
        !            88: SGOBJ enable_64mb_option = { SGRADIOBUT, 0, 0, 3,9, 7,1, "64 MB" };
        !            89: 
        !            90: /* Default configuration constants */
        !            91: int defsize[9][4] = {
        !            92:     { 4, 4, 0, 0},  /*  8 MB for monochrome non-turbo */
        !            93:     { 8, 0, 0, 0},  /*  8 MB for turbo and non-turbo color */
        !            94:     {16, 0, 0, 0},  /* 16 MB for monochrome non-turbo */
        !            95:     { 8, 8, 0, 0},  /* 16 MB for turbo and non-turbo color */
        !            96:     {16,16, 0, 0},  /* 32 MB for monochrome non-turbo */
        !            97:     { 8, 8, 8, 8},  /* 32 MB for turbo and non-turbo color */
        !            98:     {16,16,16,16},  /* 64 MB for monochrome non-turbo */
        !            99:     {32,32, 0, 0},  /* 64 MB for turbo */
        !           100:     {32,32,32,32}   /* 128 MB for turbo */
        !           101: };
        !           102: int defsizecount=0; /* Compare defsizes up to this value */
        !           103: 
        !           104: /**
        !           105:  * Show and process the memory dialog.
        !           106:  * @return  true if a memory snapshot has been loaded, false otherwise
        !           107:  */
        !           108: bool Dialog_MemDlg(void)
        !           109: {
        !           110:        int but;
        !           111: 
        !           112:        SDLGui_CenterDlg(memorydlg);
        !           113:     
        !           114:     /* Remove 64 and 128MB option if system is non-Turbo Slab,
        !           115:      * remove 128MB option if system is not Turbo */
        !           116:     if (ConfigureParams.System.bTurbo) {
        !           117:         memorydlg[DLGMEM_64MB] = enable_64mb_option;
        !           118:         memorydlg[DLGMEM_128MB] = enable_128mb_option;
        !           119:         defsizecount = 9;
        !           120:     } else if (ConfigureParams.System.bColor ||
        !           121:                ConfigureParams.System.nMachineType == NEXT_STATION) {
        !           122:         memorydlg[DLGMEM_64MB] = disable_64mb_option;
        !           123:         memorydlg[DLGMEM_128MB] = disable_128mb_option;
        !           124:         defsizecount = 6;
        !           125:     } else {
        !           126:         memorydlg[DLGMEM_64MB] = enable_64mb_option;
        !           127:         memorydlg[DLGMEM_128MB] = disable_128mb_option;
        !           128:         defsizecount = 8;
        !           129:     }
        !           130:        
        !           131:        /* Display memory speed options depending on system type */
        !           132:        if (ConfigureParams.System.bTurbo) {
        !           133:                memorydlg[DLGMEM_120NS].txt = "60 ns";
        !           134:                memorydlg[DLGMEM_100NS].txt = "70 ns";
        !           135:                memorydlg[DLGMEM_80NS].txt = "80 ns";
        !           136:                memorydlg[DLGMEM_60NS].txt = "100 ns";
        !           137:        } else {
        !           138:                memorydlg[DLGMEM_120NS].txt = "120 ns";
        !           139:                memorydlg[DLGMEM_100NS].txt = "100 ns";
        !           140:                memorydlg[DLGMEM_80NS].txt = "80 ns";
        !           141:                memorydlg[DLGMEM_60NS].txt = "60 ns";
        !           142:        }
        !           143: 
        !           144:     /* Draw dialog from actual values */
        !           145: 
        !           146:     Dialog_MemDlgDraw();
        !           147: 
        !           148:        do
        !           149:        {
        !           150:                but = SDLGui_DoDialog(memorydlg, NULL);
        !           151:         
        !           152:                switch (but)
        !           153:                {
        !           154:             case DLGMEM_8MB:
        !           155:                 if (ConfigureParams.System.bColor || ConfigureParams.System.bTurbo) {
        !           156:                     memcpy(ConfigureParams.Memory.nMemoryBankSize, defsize[1],
        !           157:                            sizeof(ConfigureParams.Memory.nMemoryBankSize));
        !           158:                 } else {
        !           159:                     memcpy(ConfigureParams.Memory.nMemoryBankSize, defsize[0],
        !           160:                            sizeof(ConfigureParams.Memory.nMemoryBankSize));
        !           161:                 }
        !           162:                 sprintf(custom_memsize, "Customize");
        !           163:                 break;
        !           164:             case DLGMEM_16MB:
        !           165:                 if (ConfigureParams.System.bColor || ConfigureParams.System.bTurbo) {
        !           166:                     memcpy(ConfigureParams.Memory.nMemoryBankSize, defsize[3],
        !           167:                            sizeof(ConfigureParams.Memory.nMemoryBankSize));
        !           168:                 } else {
        !           169:                     memcpy(ConfigureParams.Memory.nMemoryBankSize, defsize[2],
        !           170:                            sizeof(ConfigureParams.Memory.nMemoryBankSize));
        !           171:                 }
        !           172:                 sprintf(custom_memsize, "Customize");
        !           173:                 break;
        !           174:             case DLGMEM_32MB:
        !           175:                 if (ConfigureParams.System.bColor || ConfigureParams.System.bTurbo) {
        !           176:                     memcpy(ConfigureParams.Memory.nMemoryBankSize, defsize[5],
        !           177:                            sizeof(ConfigureParams.Memory.nMemoryBankSize));
        !           178:                 } else {
        !           179:                     memcpy(ConfigureParams.Memory.nMemoryBankSize, defsize[4],
        !           180:                            sizeof(ConfigureParams.Memory.nMemoryBankSize));
        !           181:                 }
        !           182:                 sprintf(custom_memsize, "Customize");
        !           183:                 break;
        !           184:             case DLGMEM_64MB:
        !           185:                 if (ConfigureParams.System.bTurbo) {
        !           186:                     memcpy(ConfigureParams.Memory.nMemoryBankSize, defsize[7],
        !           187:                            sizeof(ConfigureParams.Memory.nMemoryBankSize));
        !           188:                 } else {
        !           189:                     memcpy(ConfigureParams.Memory.nMemoryBankSize, defsize[6],
        !           190:                            sizeof(ConfigureParams.Memory.nMemoryBankSize));
        !           191:                 }
        !           192:                 sprintf(custom_memsize, "Customize");
        !           193:                 break;
        !           194:             case DLGMEM_128MB:
        !           195:                 memcpy(ConfigureParams.Memory.nMemoryBankSize, defsize[8],
        !           196:                        sizeof(ConfigureParams.Memory.nMemoryBankSize));
        !           197:                 sprintf(custom_memsize, "Customize");
        !           198:                 break;
        !           199:             case DLGMEM_CUSTOM:
        !           200:                 Dialog_MemAdvancedDlg(ConfigureParams.Memory.nMemoryBankSize);
        !           201:                 Dialog_MemDlgDraw();
        !           202:                 break;
        !           203: #if GUI_SAVE_MEMORY
        !           204:             case DLGMEM_SAVE:              /* Save memory snap-shot */
        !           205:                 if (SDLGui_FileConfSelect(dlgSnapShotName,
        !           206:                                           ConfigureParams.Memory.szMemoryCaptureFileName,
        !           207:                                           memorydlg[DLGMEM_FILENAME].w, true))
        !           208:                 {
        !           209:                     MemorySnapShot_Capture(ConfigureParams.Memory.szMemoryCaptureFileName, true);
        !           210:                 }
        !           211:                 break;
        !           212:             case DLGMEM_RESTORE:           /* Load memory snap-shot */
        !           213:                 if (SDLGui_FileConfSelect(dlgSnapShotName,
        !           214:                                           ConfigureParams.Memory.szMemoryCaptureFileName,
        !           215:                                           memorydlg[DLGMEM_FILENAME].w, false))
        !           216:                 {
        !           217:                     MemorySnapShot_Restore(ConfigureParams.Memory.szMemoryCaptureFileName, true);
        !           218:                     return true;
        !           219:                 }
        !           220:                 break;
        !           221: #endif
        !           222:                }
        !           223:        }
        !           224:        while (but != DLGMEM_EXIT && but != SDLGUI_QUIT
        !           225:            && but != SDLGUI_ERROR && !bQuitProgram );
        !           226: 
        !           227:        /* Read new values from dialog: */
        !           228: 
        !           229:     if (memorydlg[DLGMEM_120NS].state & SG_SELECTED)
        !           230:         ConfigureParams.Memory.nMemorySpeed = MEMORY_120NS;
        !           231:     else if (memorydlg[DLGMEM_100NS].state & SG_SELECTED)
        !           232:         ConfigureParams.Memory.nMemorySpeed = MEMORY_100NS;
        !           233:     else if (memorydlg[DLGMEM_80NS].state & SG_SELECTED)
        !           234:         ConfigureParams.Memory.nMemorySpeed = MEMORY_80NS;
        !           235:     else
        !           236:         ConfigureParams.Memory.nMemorySpeed = MEMORY_60NS;
        !           237: #if GUI_SAVE_MEMORY
        !           238:        ConfigureParams.Memory.bAutoSave = (memorydlg[DLGMEM_AUTOSAVE].state & SG_SELECTED);
        !           239: #endif
        !           240:        return false;
        !           241: }
        !           242: 
        !           243: 
        !           244: void Dialog_MemDlgDraw(void) {
        !           245:     int i;
        !           246:     int memsum, memsize;
        !           247:     
        !           248:     sprintf(custom_memsize, "Customize");
        !           249:     
        !           250:     for (i = DLGMEM_8MB; i <= DLGMEM_128MB; i++)
        !           251:        {
        !           252:                memorydlg[i].state &= ~SG_SELECTED;
        !           253:        }
        !           254:     
        !           255:     for (i = DLGMEM_120NS; i <= DLGMEM_60NS; i++)
        !           256:     {
        !           257:         memorydlg[i].state &= ~SG_SELECTED;
        !           258:     }
        !           259: 
        !           260:     /* Check memory configuration and find out if it is one of our default configurations */
        !           261:     memsum = Configuration_CheckMemory(ConfigureParams.Memory.nMemoryBankSize);
        !           262:     
        !           263:     for (i=0; i<defsizecount; i++) {
        !           264:         if (memcmp(ConfigureParams.Memory.nMemoryBankSize, defsize[i],
        !           265:                    sizeof(ConfigureParams.Memory.nMemoryBankSize))) {
        !           266:             memsize = 0;
        !           267:         } else {
        !           268:             memsize = memsum;
        !           269:             break;
        !           270:         }
        !           271:     }
        !           272: 
        !           273:     switch (memsize)
        !           274:     {
        !           275:         case 8:
        !           276:             memorydlg[DLGMEM_8MB].state |= SG_SELECTED;
        !           277:             break;
        !           278:         case 16:
        !           279:             memorydlg[DLGMEM_16MB].state |= SG_SELECTED;
        !           280:             break;
        !           281:         case 32:
        !           282:             memorydlg[DLGMEM_32MB].state |= SG_SELECTED;
        !           283:             break;
        !           284:         case 64:
        !           285:             memorydlg[DLGMEM_64MB].state |= SG_SELECTED;
        !           286:             break;
        !           287:         case 128:
        !           288:             memorydlg[DLGMEM_128MB].state |= SG_SELECTED;
        !           289:             break;
        !           290:         default:
        !           291:             memorydlg[DLGMEM_CUSTOM].state |= SG_SELECTED;
        !           292:             sprintf(custom_memsize, "Custom (%i MB)", memsum);
        !           293:             break;
        !           294:     }
        !           295:     
        !           296:     switch (ConfigureParams.Memory.nMemorySpeed) {
        !           297:         case MEMORY_120NS:
        !           298:             memorydlg[DLGMEM_120NS].state |= SG_SELECTED;
        !           299:             break;
        !           300:         case MEMORY_100NS:
        !           301:             memorydlg[DLGMEM_100NS].state |= SG_SELECTED;
        !           302:             break;
        !           303:         case MEMORY_80NS:
        !           304:             memorydlg[DLGMEM_80NS].state |= SG_SELECTED;
        !           305:             break;
        !           306:         case MEMORY_60NS:
        !           307:             memorydlg[DLGMEM_60NS].state |= SG_SELECTED;
        !           308:             break;
        !           309:             
        !           310:         default:
        !           311:             ConfigureParams.Memory.nMemorySpeed = MEMORY_100NS;
        !           312:             memorydlg[DLGMEM_100NS].state |= SG_SELECTED;
        !           313:             break;
        !           314:     }
        !           315: #if GUI_SAVE_MEMORY
        !           316:     File_ShrinkName(dlgSnapShotName, ConfigureParams.Memory.szMemoryCaptureFileName, memorydlg[DLGMEM_FILENAME].w);
        !           317:     
        !           318:     
        !           319:     if (ConfigureParams.Memory.bAutoSave)
        !           320:         memorydlg[DLGMEM_AUTOSAVE].state |= SG_SELECTED;
        !           321:     else
        !           322:         memorydlg[DLGMEM_AUTOSAVE].state &= ~SG_SELECTED;
        !           323: #endif
        !           324: }

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