src/core/ui-services.cpp

   1 #include "core/advdumper.hpp"
   2 #include "core/command.hpp"
   3 #include "core/dispatch.hpp"
   4 #include "core/instance.hpp"
   5 #include "core/moviedata.hpp"
   6 #include "core/project.hpp"
   7 #include "core/queue.hpp"
   8 #include "core/rom.hpp"
   9 #include "core/ui-services.hpp"
  10 #include "library/keyboard.hpp"
  11
  12 namespace
  13 {
  14         void fill_namemap(project_info& p, uint64_t id, std::map<uint64_t, std::string>& namemap,
  15                 std::map<uint64_t, std::set<uint64_t>>& childmap)
  16         {
  17                 namemap[id] = p.get_branch_name(id);
  18                 auto s = p.branch_children(id);
  19                 for(auto i : s)
  20                         fill_namemap(p, i, namemap, childmap);
  21                 childmap[id] = s;
  22         }
  23
  24         void update_dumperinfo(emulator_instance& inst, std::map<std::string, dumper_information_1>& new_dumpers,
  25                 dumper_factory_base* d)
  26         {
  27                 struct dumper_information_1 inf;
  28                 inf.factory = d;
  29                 inf.name = d->name();
  30                 std::set<std::string> mset = d->list_submodes();
  31                 for(auto i : mset)
  32                         inf.modes[i] = d->modename(i);
  33                 inf.active = inst.mdumper->busy(d);
  34                 new_dumpers[d->id()] = inf;
  35         }
  36 }
  37
  38 void do_flush_slotinfo();
  39
  40 void UI_get_branch_map(emulator_instance& inst, uint64_t& cur, std::map<uint64_t, std::string>& namemap,
  41         std::map<uint64_t, std::set<uint64_t>>& childmap)
  42 {
  43         auto project = inst.project;
  44         inst.iqueue->run([project, &cur, &namemap, &childmap]() {
  45                 auto p = project->get();
  46                 if(!p) return;
  47                 fill_namemap(*p, 0, namemap, childmap);
  48                 cur = p->get_current_branch();
  49         });
  50 }
  51
  52 void UI_call_flush(emulator_instance& inst, std::function<void(std::exception&)> onerror)
  53 {
  54         auto project = inst.project;
  55         inst.iqueue->run_async([project]() {
  56                 auto p = project->get();
  57                 if(p) p->flush();
  58         }, onerror);
  59 }
  60
  61 void UI_create_branch(emulator_instance& inst, uint64_t id, const std::string& name,
  62         std::function<void(std::exception&)> onerror)
  63 {
  64         auto project = inst.project;
  65         inst.iqueue->run_async([project, id, name]() {
  66                 auto p = project->get();
  67                 if(!p) return;
  68                 p->create_branch(id, name);
  69                 p->flush();
  70         }, onerror);
  71 }
  72
  73 void UI_rename_branch(emulator_instance& inst, uint64_t id, const std::string& name,
  74         std::function<void(std::exception&)> onerror)
  75 {
  76         auto project = inst.project;
  77         auto supdater = inst.supdater;
  78         inst.iqueue->run_async([project, supdater, id, name]() {
  79                 auto p = project->get();
  80                 if(!p) return;
  81                 p->set_branch_name(id, name);
  82                 p->flush();
  83                 supdater->update();
  84         }, onerror);
  85 }
  86
  87 void UI_reparent_branch(emulator_instance& inst, uint64_t id, uint64_t pid,
  88         std::function<void(std::exception&)> onerror)
  89 {
  90         auto project = inst.project;
  91         auto supdater = inst.supdater;
  92         inst.iqueue->run_async([project, supdater, id, pid]() {
  93                 auto p = project->get();
  94                 if(!p) return;
  95                 p->set_parent_branch(id, pid);
  96                 p->flush();
  97                 supdater->update();
  98         }, onerror);
  99 }
 100
 101 void UI_delete_branch(emulator_instance& inst, uint64_t id, std::function<void(std::exception&)> onerror)
 102 {
 103         auto project = inst.project;
 104         inst.iqueue->run_async([project, id]() {
 105                 auto p = project->get();
 106                 if(!p) return;
 107                 p->delete_branch(id);
 108                 p->flush();
 109         }, onerror);
 110 }
 111
 112 void UI_switch_branch(emulator_instance& inst, uint64_t id, std::function<void(std::exception&)> onerror)
 113 {
 114         auto project = inst.project;
 115         auto supdater = inst.supdater;
 116         inst.iqueue->run_async([project, supdater, id]() {
 117                 auto p = project->get();
 118                 if(!p) return;
 119                 p->set_current_branch(id);
 120                 p->flush();
 121                 supdater->update();
 122         }, onerror);
 123 }
 124
 125 project_author_info UI_load_author_info(emulator_instance& inst)
 126 {
 127         project_author_info x;
 128         inst.iqueue->run([&inst, &x]() {
 129                 project_info* proj = inst.project->get();
 130                 x.is_project = (proj != NULL);
 131                 x.autorunlua = false;
 132                 if(proj) {
 133                         x.projectname = proj->name;
 134                         x.directory = proj->directory;
 135                         x.prefix = proj->prefix;
 136                         x.luascripts = proj->luascripts;
 137                         x.gamename = proj->gamename;
 138                         for(auto i : proj->authors)
 139                                 x.authors.push_back(i);
 140                 } else {
 141                         x.prefix = get_mprefix_for_project();
 142                         x.gamename = inst.mlogic->get_mfile().gamename;
 143                         for(auto i : inst.mlogic->get_mfile().authors)
 144                                 x.authors.push_back(i);
 145                 }
 146         });
 147         return x;
 148 }
 149
 150 void UI_save_author_info(emulator_instance& inst, project_author_info& info)
 151 {
 152         inst.iqueue->run([&inst, info]() {
 153                 project_info* proj = inst.project->get();
 154                 std::set<std::string> oldscripts;
 155                 std::vector<std::pair<std::string, std::string>> _authors(info.authors.begin(), info.authors.end());
 156                 if(proj) {
 157                         for(auto i : proj->luascripts)
 158                                 oldscripts.insert(i);
 159                         proj->gamename = info.gamename;
 160                         proj->authors = _authors;
 161                         proj->prefix = info.prefix;
 162                         proj->directory = info.directory;
 163                         proj->name = info.projectname;
 164                         proj->luascripts = info.luascripts;
 165                         proj->flush();
 166                         //For save status to immediately update.
 167                         do_flush_slotinfo();
 168                         inst.supdater->update();
 169                         inst.dispatch->title_change();
 170                 } else {
 171                         inst.mlogic->get_mfile().gamename = info.gamename;
 172                         inst.mlogic->get_mfile().authors = _authors;
 173                         set_mprefix_for_project(info.prefix);
 174                 }
 175                 if(proj && info.autorunlua)
 176                         for(auto i : info.luascripts)
 177                                 if(!oldscripts.count(i))
 178                                         inst.command->invoke("run-lua " + i);
 179         });
 180 }
 181
 182 dumper_information UI_get_dumpers(emulator_instance& inst)
 183 {
 184         dumper_information x;
 185         inst.iqueue->run([&inst, &x]() {
 186                 std::set<dumper_factory_base*> dset = dumper_factory_base::get_dumper_set();
 187                 for(auto i : dset)
 188                         update_dumperinfo(inst, x.dumpers, i);
 189         });
 190         return x;
 191 }
 192
 193 void UI_start_dump(emulator_instance& inst, dumper_factory_base& factory, const std::string& mode,
 194         const std::string& prefix)
 195 {
 196         lsnes_instance.iqueue->run([&inst, &factory, mode, prefix]() {
 197                 inst.mdumper->start(factory, mode, prefix);
 198         });
 199 }
 200
 201 void UI_end_dump(emulator_instance& inst, dumper_factory_base& factory)
 202 {
 203         lsnes_instance.iqueue->run([&inst, &factory]() {
 204                 auto in = inst.mdumper->get_instance(&factory);
 205                 delete in;
 206         });
 207 }
 208
 209 void UI_do_keypress(emulator_instance& inst, const keyboard::modifier_set& mods, keyboard::key_key& key,
 210         bool polarity)
 211 {
 212         auto _key = &key;
 213         inst.iqueue->run_async([mods, _key, polarity]() {
 214                 _key->set_state(mods, polarity ? 1 : 0);
 215         }, [](std::exception& e) {});
 216 }
 217
 218 bool UI_has_movie(emulator_instance& inst)
 219 {
 220         bool ret = false;
 221         lsnes_instance.iqueue->run([&inst, &ret]() {
 222                 ret = !!*inst.mlogic && !inst.rom->isnull();
 223         });
 224         return ret;
 225 }
 226
 227 void UI_save_movie(emulator_instance& inst, std::ostringstream& stream)
 228 {
 229         lsnes_instance.iqueue->run([&inst, &stream]() {
 230                 inst.mlogic->get_mfile().is_savestate = false;
 231                 auto prj = inst.project->get();
 232                 if(prj) {
 233                         inst.mlogic->get_mfile().gamename = prj->gamename;
 234                         inst.mlogic->get_mfile().authors = prj->authors;
 235                 }
 236                 inst.mlogic->get_mfile().active_macros.clear();
 237                 inst.mlogic->get_mfile().save(stream, inst.mlogic->get_rrdata());
 238         });
 239 }
 240
 241 std::pair<std::string, std::string> UI_lookup_platform_and_game(emulator_instance& inst)
 242 {
 243         std::string plat;
 244         std::string game;
 245         lsnes_instance.iqueue->run([&inst, &plat, &game]() {
 246                 auto prj = inst.project->get();
 247                 if(prj)
 248                         game = prj->gamename;
 249                 else
 250                         game = inst.mlogic->get_mfile().gamename;
 251                 plat = lookup_sysregion_mapping(inst.mlogic->get_mfile().gametype->get_name());
 252         });
 253         return std::make_pair(plat, game);
 254 }