//virtual ~input_code_poller();
public virtual void reset()
{
// iterate over device classes and devices
m_axis_memory.clear();
m_switch_memory.clear();
for (input_device_class classno = input_device_class.DEVICE_CLASS_FIRST_VALID; input_device_class.DEVICE_CLASS_LAST_VALID >= classno; ++classno)
{
input_class devclass = m_manager.device_class(classno);
if (devclass.enabled())
{
for (int devnum = 0; devclass.maxindex() >= devnum; ++devnum)
{
// fetch the device; ignore if nullptr
input_device device = devclass.device(devnum);
if (device != null)
{
// iterate over items within each device
for (input_item_id itemid = input_item_id.ITEM_ID_FIRST_VALID; device.maxitem() >= itemid; ++itemid)
{
// for any non-switch items, set memory to the current value
input_device_item item = device.item(itemid);
if (item != null && (item.itemclass() != input_item_class.ITEM_CLASS_SWITCH))
{
m_axis_memory.emplace_back(new std.pair <input_device_item, s32>(item, m_manager.code_value(item.code())));
}
}
}
}
}
}
m_axis_memory.Sort(); //std::sort(m_axis_memory.begin(), m_axis_memory.end());
}
// register for save states
/*-------------------------------------------------
* register_save - register for save states
* -------------------------------------------------*/
public void register_save()
{
assert(m_save_order.empty());
assert(m_save_data == null);
// make space for the data
m_save_order.clear();
m_save_order.reserve(m_itemtable.size());
m_save_data = new s32 [m_itemtable.size()]; //m_save_data = std::make_unique<s32 []>(m_itemtable.size());
// sort existing outputs by name and register for save
foreach (var item in m_itemtable)
{
m_save_order.emplace_back(item.second());
}
m_save_order.Sort((l, r) => { return(string.Compare(l.name(), r.name())); }); //std::sort(m_save_order.begin(), m_save_order.end(), [] (auto const &l, auto const &r) { return l.get().name() < r.get().name(); });
// register the reserved space for saving
//throw new emu_unimplemented();
#if false
machine().save().save_pointer(nullptr, "output", nullptr, 0, NAME(m_save_data), m_itemtable.size());
#endif
if (OUTPUT_VERBOSE)
{
osd_printf_verbose("Registered {0} outputs for save states\n", m_itemtable.size());
}
}
std.vector <KeyValuePair <string, categoryindex> > m_ini_index; //std::vector<std::pair<std::string, categoryindex> > m_ini_index;
// construction/destruction
//-------------------------------------------------
// ctor
//-------------------------------------------------
public inifile_manager(ui_options moptions)
{
m_options = moptions;
m_ini_index = new std.vector <KeyValuePair <string, categoryindex> >();
// scan directories and create index
file_enumerator path = new file_enumerator(m_options.categoryini_path());
for (osd.directory.entry dir = path.next(); dir != null; dir = path.next())
{
string name = dir.name;
if (core_filename_ends_with(name, ".ini"))
{
emu_file file = new emu_file(m_options.categoryini_path(), OPEN_FLAG_READ);
if (file.open(name) == osd_file.error.NONE)
{
init_category(name, file);
file.close();
}
}
}
//std::stable_sort(m_ini_index.begin(), m_ini_index.end());//, [] (auto const &x, auto const &y) { return 0 > core_stricmp(x.first.c_str(), y.first.c_str()); });
m_ini_index.Sort((x, y) => { return(core_stricmp(x.Key.c_str(), y.Key.c_str())); });
}
//-------------------------------------------------
// populate search list
//-------------------------------------------------
void populate_search()
{
// ensure search list is populated
if (m_searchlist.empty())
{
var sorted = m_persistent_data.sorted_list();
m_searchlist.reserve(sorted.size());
foreach (ui_system_info info in sorted)
{
m_searchlist.emplace_back(new std.pair <double, ui_system_info>(1.0, info));
}
}
// keep track of what we matched against
string ucs_search = ustr_from_utf8(normalize_unicode(m_search, unicode_normalization_form.D, true)); //const std::u32string ucs_search(ustr_from_utf8(normalize_unicode(m_search, unicode_normalization_form::D, true)));
// check available search data
if (m_persistent_data.is_available(system_list.available.AVAIL_UCS_SHORTNAME))
{
m_searched_fields |= (unsigned)system_list.available.AVAIL_UCS_SHORTNAME;
}
if (m_persistent_data.is_available(system_list.available.AVAIL_UCS_DESCRIPTION))
{
m_searched_fields |= (unsigned)system_list.available.AVAIL_UCS_DESCRIPTION;
}
if (m_persistent_data.is_available(system_list.available.AVAIL_UCS_MANUF_DESC))
{
m_searched_fields |= (unsigned)system_list.available.AVAIL_UCS_MANUF_DESC;
}
if (m_persistent_data.is_available(system_list.available.AVAIL_UCS_DFLT_DESC))
{
m_searched_fields |= (unsigned)system_list.available.AVAIL_UCS_DFLT_DESC;
}
if (m_persistent_data.is_available(system_list.available.AVAIL_UCS_MANUF_DFLT_DESC))
{
m_searched_fields |= (unsigned)system_list.available.AVAIL_UCS_MANUF_DFLT_DESC;
}
for (int i = 0; i < m_searchlist.Count; i++) //for (std::pair<double, std::reference_wrapper<ui_system_info const> > &info : m_searchlist)
{
var info = m_searchlist[i];
m_searchlist[i] = std.make_pair(1.0, info.second);
ui_system_info sys = info.second;
// match shortnames
if ((m_searched_fields & (unsigned)system_list.available.AVAIL_UCS_SHORTNAME) != 0)
{
m_searchlist[i] = std.make_pair(util.edit_distance(ucs_search, sys.ucs_shortname), info.second);
}
// match reading
if (info.first != 0 && !sys.ucs_reading_description.empty())
{
m_searchlist[i] = std.make_pair(std.min(util.edit_distance(ucs_search, sys.ucs_reading_description), info.first), info.second);
// match "<manufacturer> <reading>"
if (info.first != 0)
{
m_searchlist[i] = std.make_pair(std.min(util.edit_distance(ucs_search, sys.ucs_manufacturer_reading_description), info.first), info.second);
}
}
// match descriptions
if (info.first != 0 && (m_searched_fields & (unsigned)system_list.available.AVAIL_UCS_DESCRIPTION) != 0)
{
m_searchlist[i] = std.make_pair(std.min(util.edit_distance(ucs_search, sys.ucs_description), info.first), info.second);
}
// match "<manufacturer> <description>"
if (info.first != 0 && (m_searched_fields & (unsigned)system_list.available.AVAIL_UCS_MANUF_DESC) != 0)
{
m_searchlist[i] = std.make_pair(std.min(util.edit_distance(ucs_search, sys.ucs_manufacturer_description), info.first), info.second);
}
// match default description
if (info.first != 0 && (m_searched_fields & (unsigned)system_list.available.AVAIL_UCS_DFLT_DESC) != 0 && !sys.ucs_default_description.empty())
{
m_searchlist[i] = std.make_pair(std.min(util.edit_distance(ucs_search, sys.ucs_default_description), info.first), info.second);
// match "<manufacturer> <default description>"
if (info.first != 0 && (m_searched_fields & (unsigned)system_list.available.AVAIL_UCS_MANUF_DFLT_DESC) != 0)
{
m_searchlist[i] = std.make_pair(std.min(util.edit_distance(ucs_search, sys.ucs_manufacturer_default_description), info.first), info.second);
}
}
}
// sort according to edit distance
//std::stable_sort(
// m_searchlist.begin(),
// m_searchlist.end());
// [] (auto const &lhs, auto const &rhs) { return lhs.first < rhs.first; });
m_searchlist.Sort((lhs, rhs) => { return(lhs.first.CompareTo(rhs.first)); });
}
