src/platform/wxwidgets/settings-common.cpp

   1 #include "platform/wxwidgets/settings-common.hpp"
   2 #include "core/keymapper.hpp"
   3
   4 namespace
   5 {
   6         std::map<std::string, settings_tab_factory*>& _factories()
   7         {
   8                 static std::map<std::string, settings_tab_factory*> x;
   9                 return x;
  10         }
  11         class wxeditor_esettings2* dlg;
  12 }
  13
  14
  15 settings_tab_factory::settings_tab_factory(const std::string& tabname,
  16         std::function<settings_tab*(wxWindow* parent)> create_fn)
  17         : _tabname(tabname), _create_fn(create_fn)
  18 {
  19         _factories()[_tabname] = this;
  20 }
  21
  22 settings_tab_factory::~settings_tab_factory()
  23 {
  24         _factories().erase(_tabname);
  25 }
  26
  27 std::list<settings_tab_factory*> settings_tab_factory::factories()
  28 {
  29         std::list<settings_tab_factory*> f;
  30         for(auto i : _factories())
  31                 f.push_back(i.second);
  32         return f;
  33 }
  34
  35 settings_menu::settings_menu(wxWindow* win, int id)
  36 {
  37         parent = win;
  38         wxMenuItem* n;
  39         items[id] = NULL;
  40         n = Append(id, towxstring("All as tabs..."));
  41         win->Connect(id++, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(settings_menu::on_selected), NULL,
  42                 this);
  43         AppendSeparator();
  44         for(auto i : settings_tab_factory::factories()) {
  45                 items[id] = i;
  46                 n = Append(id, towxstring(i->get_name() + "..."));
  47                 win->Connect(id++, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(settings_menu::on_selected),
  48                         NULL, this);
  49         }
  50 }
  51
  52 void settings_menu::on_selected(wxCommandEvent& e)
  53 {
  54         int id = e.GetId();
  55         if(!items.count(id))
  56                 return;
  57         display_settings_dialog(parent, items[id]);
  58 }
  59
  60 namespace
  61 {
  62         volatile bool keygrab_active = false;
  63         std::string pkey;
  64         std::function<void(std::string key)> keygrab_callback;
  65
  66         class keygrabber : public keyboard::event_listener
  67         {
  68         public:
  69                 keygrabber() { keygrab_active = false; }
  70                 void on_key_event(keyboard::modifier_set& mods, keyboard::key& key, keyboard::event& event)
  71                 {
  72                         if(!keygrab_active)
  73                                 return;
  74                         uint32_t dev = event.get_change_mask();
  75                         auto subkeys = key.get_subkeys();
  76                         for(unsigned i = 0; i < 16 && i < subkeys.size(); i++) {
  77                                 std::string pname = key.get_name() + subkeys[i];
  78                                 if(((dev >> (2 * i)) & 3) == 3)
  79                                         pkey = pname;
  80                                 if(((dev >> (2 * i)) & 3) == 2) {
  81                                         if(pkey == pname) {
  82                                                 keygrab_active = false;
  83                                                 std::string tmp = pkey;
  84                                                 runuifun([tmp]() { keygrab_callback(tmp); });
  85                                         } else
  86                                                 pkey = "";
  87                                 }
  88                         }
  89                 }
  90         } keygrabber;
  91
  92         class wxeditor_esettings2 : public wxDialog
  93         {
  94         public:
  95                 wxeditor_esettings2(wxWindow* parent, settings_tab_factory* singletab);
  96                 ~wxeditor_esettings2();
  97                 bool ShouldPreventAppExit() const;
  98                 void on_close(wxCommandEvent& e);
  99                 void on_notify();
 100         private:
 101                 wxNotebook* tabset;
 102                 wxButton* closebutton;
 103                 std::list<settings_tab*> tabs;
 104                 std::string get_title(settings_tab_factory* singletab);
 105         };
 106
 107         std::string wxeditor_esettings2::get_title(settings_tab_factory* singletab)
 108         {
 109                 if(!singletab)
 110                         return "lsnes: Configuration";
 111                 else
 112                         return "lsnes: Configuration: " + singletab->get_name();
 113         }
 114
 115         wxeditor_esettings2::wxeditor_esettings2(wxWindow* parent, settings_tab_factory* singletab)
 116                 : wxDialog(parent, wxID_ANY, towxstring(get_title(singletab)), wxDefaultPosition, wxSize(-1, -1),
 117                         wxCAPTION | wxSYSTEM_MENU | wxCLOSE_BOX | wxRESIZE_BORDER)
 118         {
 119                 //Grab keys to prevent the joystick driver from running who knows what commands.
 120                 lsnes_kbd.set_exclusive(&keygrabber);
 121
 122                 Centre();
 123                 wxSizer* top_s = new wxBoxSizer(wxVERTICAL);
 124                 SetSizer(top_s);
 125
 126                 if(singletab) {
 127                         //If this throws, let it throw through.
 128                         settings_tab* t = singletab->create(this);
 129                         top_s->Add(t, 1, wxGROW);
 130                         t->set_notify([this]() { this->on_notify(); });
 131                         tabs.push_back(t);
 132                 } else {
 133                         int created = 0;
 134                         tabset = new wxNotebook(this, -1, wxDefaultPosition, wxDefaultSize, wxNB_TOP);
 135                         for(auto i : settings_tab_factory::factories()) {
 136                                 settings_tab* t;
 137                                 try {
 138                                         t = i->create(tabset);
 139                                 } catch(...) {
 140                                         continue;
 141                                 }
 142                                 tabset->AddPage(t, towxstring(i->get_name()));
 143                                 t->set_notify([this]() { this->on_notify(); });
 144                                 tabs.push_back(t);
 145                                 created++;
 146                         }
 147                         top_s->Add(tabset, 1, wxGROW);
 148                         if(!created)
 149                                 throw std::runtime_error("Nothing to configure here, move along");
 150                 }
 151
 152                 wxBoxSizer* pbutton_s = new wxBoxSizer(wxHORIZONTAL);
 153                 pbutton_s->AddStretchSpacer();
 154                 pbutton_s->Add(closebutton = new wxButton(this, wxID_ANY, wxT("Close")), 0, wxGROW);
 155                 closebutton->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
 156                         wxCommandEventHandler(wxeditor_esettings2::on_close), NULL, this);
 157                 top_s->Add(pbutton_s, 0, wxGROW);
 158
 159                 top_s->SetSizeHints(this);
 160                 Fit();
 161         }
 162
 163         wxeditor_esettings2::~wxeditor_esettings2()
 164         {
 165                 for(auto i : tabs)
 166                         i->notify_close();
 167                 lsnes_kbd.set_exclusive(NULL);
 168         }
 169
 170         bool wxeditor_esettings2::ShouldPreventAppExit() const
 171         {
 172                 return false;
 173         }
 174
 175         void wxeditor_esettings2::on_close(wxCommandEvent& e)
 176         {
 177                 for(auto i : tabs)
 178                         i->on_close();
 179                 EndModal(wxID_OK);
 180         }
 181
 182         void wxeditor_esettings2::on_notify()
 183         {
 184                 for(auto i : tabs)
 185                         i->on_notify();
 186         }
 187 }
 188
 189 void settings_tab::call_window_fit()
 190 {
 191         if(dlg) {
 192                 std::cerr << "Call_window_fit()" << std::endl;
 193                 dlg->Fit();
 194         }
 195 }
 196
 197 void display_settings_dialog(wxWindow* parent, settings_tab_factory* singletab)
 198 {
 199         modal_pause_holder hld;
 200         wxDialog* editor;
 201         try {
 202                 try {
 203                         editor = dlg = new wxeditor_esettings2(parent, singletab);
 204                 } catch(std::exception& e) {
 205                         std::string title = "Configure";
 206                         if(singletab)
 207                                 title = "Configure " + singletab->get_name();
 208                         show_message_ok(parent, title, e.what(), wxICON_EXCLAMATION);
 209                         return;
 210                 }
 211                 editor->ShowModal();
 212         } catch(...) {
 213         }
 214         dlg = NULL;
 215         editor->Destroy();
 216 }
 217
 218 void settings_activate_keygrab(std::function<void(std::string key)> callback)
 219 {
 220         keygrab_callback = callback;
 221         keygrab_active = true;
 222 }
 223
 224 void settings_deactivate_keygrab()
 225 {
 226         keygrab_active = false;
 227 }