Annotation of previous/src/gui-sdl/dlgMemory.c, revision 1.1.1.1

1.1       root        1: /*
                      2:   Hatari - 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[] = "Hatari dlgMemory.c : " __DATE__ " " __TIME__;
                      8: 
                      9: #include "main.h"
                     10: #include "dialog.h"
                     11: #include "sdlgui.h"
                     12: #include "memorySnapShot.h"
                     13: #include "file.h"
                     14: #include "screen.h"
                     15: 
                     16: 
                     17: #define DLGMEM_512KB    4
                     18: #define DLGMEM_1MB      5
                     19: #define DLGMEM_2MB      6
                     20: #define DLGMEM_4MB      7
                     21: #define DLGMEM_8MB      8
                     22: #define DLGMEM_14MB     9
                     23: #define DLGMEM_FILENAME 13
                     24: #define DLGMEM_SAVE     14
                     25: #define DLGMEM_RESTORE  15
                     26: #define DLGMEM_AUTOSAVE 16
                     27: #define DLGMEM_EXIT     17
                     28: 
                     29: 
                     30: static char dlgSnapShotName[36+1];
                     31: 
                     32: 
                     33: /* The memory dialog: */
                     34: static SGOBJ memorydlg[] =
                     35: {
                     36:        { SGBOX, 0, 0, 0,0, 40,22, NULL },
                     37: 
                     38:        { SGBOX, 0, 0, 1,1, 38,7, NULL },
                     39:        { SGTEXT, 0, 0, 15,2, 12,1, "Memory setup" },
                     40:        { SGTEXT, 0, 0, 4,4, 12,1, "ST-RAM size:" },
                     41:        { SGRADIOBUT, 0, 0, 18,4, 9,1, "512 KiB" },
                     42:        { SGRADIOBUT, 0, 0, 18,5, 7,1, "1 MiB" },
                     43:        { SGRADIOBUT, 0, 0, 18,6, 7,1, "2 MiB" },
                     44:        { SGRADIOBUT, 0, 0, 29,4, 7,1, "4 MiB" },
                     45:        { SGRADIOBUT, 0, 0, 29,5, 7,1, "8 MiB" },
                     46:        { SGRADIOBUT, 0, 0, 29,6, 8,1, "14 MiB" },
                     47: 
                     48:        { SGBOX, 0, 0, 1,9, 38,10, NULL },
                     49:        { SGTEXT, 0, 0, 12,10, 17,1, "Memory state save" },
                     50:        { SGTEXT, 0, 0, 2,12, 20,1, "Snap-shot file name:" },
                     51:        { SGTEXT, 0, 0, 2,13, 36,1, dlgSnapShotName },
                     52:        { SGBUTTON, 0, 0, 8,15, 10,1, "Save" },
                     53:        { SGBUTTON, 0, 0, 22,15, 10,1, "Restore" },
                     54:        { SGCHECKBOX, 0, 0, 2,17, 37,1, "Load/save state at start-up/exit" },
                     55: 
                     56:        { SGBUTTON, SG_DEFAULT, 0, 10,20, 20,1, "Back to main menu" },
                     57:        { -1, 0, 0, 0,0, 0,0, NULL }
                     58: };
                     59: 
                     60: 
                     61: 
                     62: /**
                     63:  * Show and process the memory dialog.
                     64:  * @return  true if a memory snapshot has been loaded, false otherwise
                     65:  */
                     66: bool Dialog_MemDlg(void)
                     67: {
                     68:        int i;
                     69:        int but;
                     70: 
                     71:        SDLGui_CenterDlg(memorydlg);
                     72: 
                     73:        for (i = DLGMEM_512KB; i <= DLGMEM_14MB; i++)
                     74:        {
                     75:                memorydlg[i].state &= ~SG_SELECTED;
                     76:        }
                     77: 
                     78:        switch (ConfigureParams.Memory.nMemorySize)
                     79:        {
                     80:         case 0:
                     81:                memorydlg[DLGMEM_512KB].state |= SG_SELECTED;
                     82:                break;
                     83:         case 1:
                     84:                memorydlg[DLGMEM_1MB].state |= SG_SELECTED;
                     85:                break;
                     86:         case 2:
                     87:                memorydlg[DLGMEM_2MB].state |= SG_SELECTED;
                     88:                break;
                     89:         case 4:
                     90:                memorydlg[DLGMEM_4MB].state |= SG_SELECTED;
                     91:                break;
                     92:         case 8:
                     93:                memorydlg[DLGMEM_8MB].state |= SG_SELECTED;
                     94:                break;
                     95:         default:
                     96:                memorydlg[DLGMEM_14MB].state |= SG_SELECTED;
                     97:                break;
                     98:        }
                     99: 
                    100:        File_ShrinkName(dlgSnapShotName, ConfigureParams.Memory.szMemoryCaptureFileName, memorydlg[DLGMEM_FILENAME].w);
                    101: 
                    102: 
                    103:        if (ConfigureParams.Memory.bAutoSave)
                    104:                memorydlg[DLGMEM_AUTOSAVE].state |= SG_SELECTED;
                    105:        else
                    106:                memorydlg[DLGMEM_AUTOSAVE].state &= ~SG_SELECTED;
                    107: 
                    108:        do
                    109:        {
                    110:                but = SDLGui_DoDialog(memorydlg, NULL);
                    111: 
                    112:                switch (but)
                    113:                {
                    114:                 case DLGMEM_SAVE:              /* Save memory snap-shot */
                    115:                        if (SDLGui_FileConfSelect(dlgSnapShotName,
                    116:                                                  ConfigureParams.Memory.szMemoryCaptureFileName,
                    117:                                                  memorydlg[DLGMEM_FILENAME].w, true))
                    118:                        {
                    119:                                MemorySnapShot_Capture(ConfigureParams.Memory.szMemoryCaptureFileName, true);
                    120:                        }
                    121:                        break;
                    122:                 case DLGMEM_RESTORE:           /* Load memory snap-shot */
                    123:                        if (SDLGui_FileConfSelect(dlgSnapShotName,
                    124:                                                  ConfigureParams.Memory.szMemoryCaptureFileName,
                    125:                                                  memorydlg[DLGMEM_FILENAME].w, false))
                    126:                        {
                    127:                                MemorySnapShot_Restore(ConfigureParams.Memory.szMemoryCaptureFileName, true);
                    128:                                return true;
                    129:                        }
                    130:                        break;
                    131:                }
                    132:        }
                    133:        while (but != DLGMEM_EXIT && but != SDLGUI_QUIT
                    134:                && but != SDLGUI_ERROR && !bQuitProgram );
                    135: 
                    136:        /* Read new values from dialog: */
                    137: 
                    138:        if (memorydlg[DLGMEM_512KB].state & SG_SELECTED)
                    139:                ConfigureParams.Memory.nMemorySize = 0;
                    140:        else if (memorydlg[DLGMEM_1MB].state & SG_SELECTED)
                    141:                ConfigureParams.Memory.nMemorySize = 1;
                    142:        else if (memorydlg[DLGMEM_2MB].state & SG_SELECTED)
                    143:                ConfigureParams.Memory.nMemorySize = 2;
                    144:        else if (memorydlg[DLGMEM_4MB].state & SG_SELECTED)
                    145:                ConfigureParams.Memory.nMemorySize = 4;
                    146:        else if (memorydlg[DLGMEM_8MB].state & SG_SELECTED)
                    147:                ConfigureParams.Memory.nMemorySize = 8;
                    148:        else
                    149:                ConfigureParams.Memory.nMemorySize = 14;
                    150: 
                    151:        ConfigureParams.Memory.bAutoSave = (memorydlg[DLGMEM_AUTOSAVE].state & SG_SELECTED);
                    152: 
                    153:        return false;
                    154: }

unix.superglobalmegacorp.com

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