src/core/ui-services.cpp

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