platform/wxwidgets/src/callrom.cpp

   1 #include "callrom.hpp"
   2 #include "common.hpp"
   3
   4 #define TNAME_SNES "SNES"
   5 #define TNAME_BSX_NS "BS-X (non-slotted)"
   6 #define TNAME_BSX_S "BS-X (slotted)"
   7 #define TNAME_SUFAMITURBO "Sufami Turbo"
   8 #define TNAME_SGB "SGB"
   9 #define RNAME_AUTO "Autodetect"
  10 #define RNAME_NTSC "NTSC"
  11 #define RNAME_PAL "PAL"
  12 #define WNAME_SNES_MAIN "ROM"
  13 #define WNAME_SNES_MAIN_XML "ROM XML"
  14 #define WNAME_BS_MAIN "BS-X BIOS"
  15 #define WNAME_BS_MAIN_XML "BS-X BIOS XML"
  16 #define WNAME_BS_SLOTA "BS FLASH"
  17 #define WNAME_BS_SLOTA_XML "BS FLASH XML"
  18 #define WNAME_ST_MAIN "ST BIOS"
  19 #define WNAME_ST_MAIN_XML "ST BIOS XML"
  20 #define WNAME_ST_SLOTA "SLOT A ROM"
  21 #define WNAME_ST_SLOTA_XML "SLOT A XML"
  22 #define WNAME_ST_SLOTB "SLOT B ROM"
  23 #define WNAME_ST_SLOTB_XML "SLOT B XML"
  24 #define WNAME_SGB_MAIN "SGB BIOS"
  25 #define WNAME_SGB_MAIN_XML "SGB BIOS XML"
  26 #define WNAME_SGB_SLOTA "DMG ROM"
  27 #define WNAME_SGB_SLOTA_XML "BMG XML"
  28
  29
  30 enum rom_type romtype_from_string(const std::string& str)
  31 {
  32         if(str == TNAME_SNES)
  33                 return ROMTYPE_SNES;
  34         if(str == TNAME_BSX_NS)
  35                 return ROMTYPE_BSX;
  36         if(str == TNAME_BSX_S)
  37                 return ROMTYPE_BSXSLOTTED;
  38         if(str == TNAME_SUFAMITURBO)
  39                 return ROMTYPE_SUFAMITURBO;
  40         if(str == TNAME_SGB)
  41                 return ROMTYPE_SGB;
  42         return ROMTYPE_NONE;
  43 }
  44
  45 enum rom_type romtype_from_string(const wxString& str)
  46 {
  47         return romtype_from_string(tostdstring(str));
  48 }
  49
  50 wxString romname_wxs(enum rom_type rtype, unsigned index)
  51 {
  52         return towxstring(romname_stds(rtype, index));
  53 }
  54
  55 std::string romname_stds(enum rom_type rtype, unsigned index)
  56 {
  57         switch(rtype) {
  58         case ROMTYPE_SNES:
  59                 switch(index) {
  60                 case 0:         return WNAME_SNES_MAIN;
  61                 case 1:         return WNAME_SNES_MAIN_XML;
  62                 };
  63                 break;
  64         case ROMTYPE_BSX:
  65         case ROMTYPE_BSXSLOTTED:
  66                 switch(index) {
  67                 case 0:         return WNAME_BS_MAIN;
  68                 case 1:         return WNAME_BS_MAIN_XML;
  69                 case 2:         return WNAME_BS_SLOTA;
  70                 case 3:         return WNAME_BS_SLOTA_XML;
  71                 };
  72                 break;
  73         case ROMTYPE_SUFAMITURBO:
  74                 switch(index) {
  75                 case 0:         return WNAME_ST_MAIN;
  76                 case 1:         return WNAME_ST_MAIN_XML;
  77                 case 2:         return WNAME_ST_SLOTA;
  78                 case 3:         return WNAME_ST_SLOTA_XML;
  79                 case 4:         return WNAME_ST_SLOTB;
  80                 case 5:         return WNAME_ST_SLOTB_XML;
  81                 };
  82                 break;
  83         case ROMTYPE_SGB:
  84                 switch(index) {
  85                 case 0:         return WNAME_SGB_MAIN;
  86                 case 1:         return WNAME_SGB_MAIN_XML;
  87                 case 2:         return WNAME_SGB_SLOTA;
  88                 case 3:         return WNAME_SGB_SLOTA_XML;
  89                 };
  90                 break;
  91         case ROMTYPE_NONE:
  92                 if(index == 0)  return "dummy";
  93                 break;
  94         }
  95         return "";
  96 }
  97
  98 unsigned fill_rom_names(enum rom_type rtype, wxString* array)
  99 {
 100         unsigned r = 0;
 101         for(unsigned i = 0; i < 6; i++) {
 102                 wxString s = romname_wxs(rtype, i);
 103                 if(s.Length())
 104                         array[r++] = s;
 105         }
 106         return r;
 107 }
 108
 109 unsigned romname_to_index(enum rom_type rtype, const wxString& name)
 110 {
 111         std::string s = tostdstring(name);
 112         for(unsigned i = 0; i < 6; i++)
 113                 if(romname_stds(rtype, i) == s)
 114                         return i;
 115         return 6;
 116
 117 }
 118
 119 struct loaded_slot& get_rom_slot(struct loaded_rom& rom, unsigned index)
 120 {
 121         switch(index) {
 122         case 0:         return rom.rom;
 123         case 1:         return rom.rom_xml;
 124         case 2:         return rom.slota;
 125         case 3:         return rom.slota_xml;
 126         case 4:         return rom.slotb;
 127         case 5:         return rom.slotb_xml;
 128         }
 129         return rom.rom;
 130 }
 131
 132 enum rom_region region_from_string(const std::string& str)
 133 {
 134         if(str == RNAME_NTSC)
 135                 return REGION_NTSC;
 136         if(str == RNAME_PAL)
 137                 return REGION_PAL;
 138         return REGION_AUTO;
 139 }
 140
 141 enum rom_region region_from_string(const wxString& str)
 142 {
 143         return region_from_string(tostdstring(str));
 144 }
 145
 146 bool has_forced_region(enum rom_type rtype)
 147 {
 148         return (rtype != ROMTYPE_SNES && rtype != ROMTYPE_SGB);
 149 }
 150
 151 bool has_forced_region(const std::string& str)
 152 {
 153         return has_forced_region(romtype_from_string(str));
 154 }
 155
 156 bool has_forced_region(const wxString& str)
 157 {
 158         return has_forced_region(romtype_from_string(str));
 159 }
 160
 161 wxString forced_region_for_romtype(enum rom_type rtype)
 162 {
 163         if(has_forced_region(rtype))
 164                 return wxT(RNAME_NTSC);
 165         else
 166                 return wxT("");
 167 }
 168
 169 wxString forced_region_for_romtype(const std::string& str)
 170 {
 171         return forced_region_for_romtype(romtype_from_string(str));
 172 }
 173
 174 wxString forced_region_for_romtype(const wxString& str)
 175 {
 176         return forced_region_for_romtype(romtype_from_string(str));
 177 }
 178
 179 unsigned populate_region_choices(wxString* array)
 180 {
 181         array[0] = wxT(RNAME_AUTO);
 182         array[1] = wxT(RNAME_NTSC);
 183         array[2] = wxT(RNAME_PAL);
 184         return 3;
 185 }
 186
 187 unsigned populate_system_choices(wxString* array)
 188 {
 189         array[0] = wxT(TNAME_SNES);
 190         array[1] = wxT(TNAME_BSX_NS);
 191         array[2] = wxT(TNAME_BSX_S);
 192         array[3] = wxT(TNAME_SUFAMITURBO);
 193         array[4] = wxT(TNAME_SGB);
 194         return 5;
 195 }