Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-28 16:43:04 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Miscellaneous cleanups to imgcntrl.[cpp|h] and calling code

Browse Source
This commit is contained in:
Nathan Woods 2016-07-18 17:41:22 -04:00
parent 9e1b8814fb
commit f4774fc776
5 changed files with 122 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/frontend/mame/ui/filemngr.cpp
View File

@ -184,11 +184,11 @@ void menu_file_manager::handle()
floppy_image_device *floppy_device = dynamic_cast<floppy_image_device *>(selected_device);
if (floppy_device != nullptr)
{
menu::stack_push<menu_control_floppy_image>(ui(), container(), floppy_device);
menu::stack_push<menu_control_floppy_image>(ui(), container(), *floppy_device);
}
else
{
menu::stack_push<menu_control_device_image>(ui(), container(), selected_device);
menu::stack_push<menu_control_device_image>(ui(), container(), *selected_device);
}
// reset the existing menu
reset(reset_options::REMEMBER_POSITION);

42
src/frontend/mame/ui/floppycntrl.cpp
View File

@ -20,9 +20,9 @@ namespace ui {
IMPLEMENTATION
***************************************************************************/
menu_control_floppy_image::menu_control_floppy_image(mame_ui_manager &mui, render_container &container, device_image_interface *_image) : menu_control_device_image(mui, container, _image)
menu_control_floppy_image::menu_control_floppy_image(mame_ui_manager &mui, render_container &container, device_image_interface &image) : menu_control_device_image(mui, container, image)
{
floppy_image_device *fd = static_cast<floppy_image_device *>(image);
floppy_image_device *fd = static_cast<floppy_image_device *>(&m_image);
const floppy_image_format_t *fif_list = fd->get_formats();
int fcnt = 0;
for(const floppy_image_format_t *i = fif_list; i; i = i->next)
@ -40,7 +40,7 @@ menu_control_floppy_image::~menu_control_floppy_image()
void menu_control_floppy_image::do_load_create()
{
floppy_image_device *fd = static_cast<floppy_image_device *>(image);
floppy_image_device *fd = static_cast<floppy_image_device *>(&m_image);
if(input_filename.compare("")==0) {
int err = fd->create(output_filename.c_str(), nullptr, nullptr);
if (err != 0) {
@ -66,17 +66,17 @@ void menu_control_floppy_image::hook_load(std::string filename, bool softlist)
if (softlist)
{
machine().popmessage("When loaded from software list, the disk is Read-only.\n");
image->load(filename.c_str());
m_image.load(filename.c_str());
stack_pop();
return;
}
input_filename = filename;
input_format = static_cast<floppy_image_device *>(image)->identify(filename);
input_format = static_cast<floppy_image_device &>(m_image).identify(filename);
if (!input_format)
{
machine().popmessage("Error: %s\n", image->error());
machine().popmessage("Error: %s\n", m_image.error());
stack_pop();
return;
}
@ -93,15 +93,15 @@ void menu_control_floppy_image::hook_load(std::string filename, bool softlist)
else
can_in_place = false;
}
submenu_result.rw = menu_select_rw::result::INVALID;
menu::stack_push<menu_select_rw>(ui(), container(), can_in_place, submenu_result.rw);
state = SELECT_RW;
m_submenu_result.rw = menu_select_rw::result::INVALID;
menu::stack_push<menu_select_rw>(ui(), container(), can_in_place, m_submenu_result.rw);
m_state = SELECT_RW;
}
void menu_control_floppy_image::handle()
{
floppy_image_device *fd = static_cast<floppy_image_device *>(image);
switch (state) {
floppy_image_device *fd = static_cast<floppy_image_device *>(&m_image);
switch (m_state) {
case DO_CREATE: {
floppy_image_format_t *fif_list = fd->get_formats();
int ext_match;
@ -119,27 +119,27 @@ void menu_control_floppy_image::handle()
if (!i->extension_matches(m_current_file.c_str()))
format_array[total_usable++] = i;
}
submenu_result.i = -1;
menu::stack_push<menu_select_format>(ui(), container(), format_array, ext_match, total_usable, &submenu_result.i);
m_submenu_result.i = -1;
menu::stack_push<menu_select_format>(ui(), container(), format_array, ext_match, total_usable, &m_submenu_result.i);
state = SELECT_FORMAT;
m_state = SELECT_FORMAT;
break;
}
case SELECT_FORMAT:
if(submenu_result.i == -1) {
state = START_FILE;
if(m_submenu_result.i == -1) {
m_state = START_FILE;
handle();
} else {
output_filename = util::zippath_combine(m_current_directory.c_str(), m_current_file.c_str());
output_format = format_array[submenu_result.i];
output_format = format_array[m_submenu_result.i];
do_load_create();
stack_pop();
}
break;
case SELECT_RW:
switch(submenu_result.rw) {
switch(m_submenu_result.rw) {
case menu_select_rw::result::READONLY:
do_load_create();
stack_pop();
@ -157,12 +157,12 @@ void menu_control_floppy_image::handle()
break;
case menu_select_rw::result::WRITE_OTHER:
menu::stack_push<menu_file_create>(ui(), container(), image, m_current_directory, m_current_file, create_ok);
state = CHECK_CREATE;
menu::stack_push<menu_file_create>(ui(), container(), &m_image, m_current_directory, m_current_file, m_create_ok);
m_state = CHECK_CREATE;
break;
case menu_select_rw::result::INVALID:
state = START_FILE;
m_state = START_FILE;
break;
}
break;

2
src/frontend/mame/ui/floppycntrl.h
View File

@ -20,7 +20,7 @@ namespace ui {
class menu_control_floppy_image : public menu_control_device_image
{
public:
menu_control_floppy_image(mame_ui_manager &ui, render_container &container, device_image_interface *image);
menu_control_floppy_image(mame_ui_manager &ui, render_container &container, device_image_interface &image);
virtual ~menu_control_floppy_image() override;
private:

162
src/frontend/mame/ui/imgcntrl.cpp
View File

@ -33,39 +33,42 @@ namespace ui {
// ctor
//-------------------------------------------------
menu_control_device_image::menu_control_device_image(mame_ui_manager &mui, render_container &container, device_image_interface *_image)
: menu(mui, container),
create_ok(false),
create_confirmed(false)
menu_control_device_image::menu_control_device_image(mame_ui_manager &mui, render_container &container, device_image_interface &image)
: menu(mui, container)
, m_image(image)
, m_create_ok(false)
, m_create_confirmed(false)
{
image = _image;
submenu_result.i = -1;
m_submenu_result.i = -1;
if (image->software_list_name())
sld = software_list_device::find_by_name(mui.machine().config(), image->software_list_name());
if (m_image.software_list_name())
m_sld = software_list_device::find_by_name(mui.machine().config(), m_image.software_list_name());
else
sld = nullptr;
swi = image->software_entry();
swp = image->part_entry();
m_sld = nullptr;
m_swi = m_image.software_entry();
m_swp = m_image.part_entry();
if(swi)
if (m_swi != nullptr)
{
state = START_OTHER_PART;
m_current_directory.assign(image->working_directory());
m_state = START_OTHER_PART;
m_current_directory.assign(m_image.working_directory());
}
else
{
state = START_FILE;
m_state = START_FILE;
/* if the image exists, set the working directory to the parent directory */
if (image->exists())
// if the image exists, set the working directory to the parent directory
if (m_image.exists())
{
m_current_file.assign(image->filename());
m_current_file.assign(m_image.filename());
util::zippath_parent(m_current_directory, m_current_file.c_str());
} else
m_current_directory.assign(image->working_directory());
}
else
{
m_current_directory.assign(m_image.working_directory());
}
/* check to see if the path exists; if not clear it */
// check to see if the path exists; if not clear it
if (util::zippath_opendir(m_current_directory.c_str(), nullptr) != osd_file::error::NONE)
m_current_directory.clear();
}
@ -87,31 +90,29 @@ menu_control_device_image::~menu_control_device_image()
void menu_control_device_image::test_create(bool &can_create, bool &need_confirm)
{
osd::directory::entry::entry_type file_type;
/* assemble the full path */
// assemble the full path
auto path = util::zippath_combine(m_current_directory.c_str(), m_current_file.c_str());
/* does a file or a directory exist at the path */
// does a file or a directory exist at the path
auto entry = osd_stat(path.c_str());
file_type = (entry != nullptr) ? entry->type : osd::directory::entry::entry_type::NONE;
auto file_type = (entry != nullptr) ? entry->type : osd::directory::entry::entry_type::NONE;
switch(file_type)
{
case osd::directory::entry::entry_type::NONE:
/* no file/dir here - always create */
// no file/dir here - always create
can_create = true;
need_confirm = false;
break;
case osd::directory::entry::entry_type::FILE:
/* a file exists here - ask for permission from the user */
// a file exists here - ask for permission from the user
can_create = true;
need_confirm = true;
break;
case osd::directory::entry::entry_type::DIR:
/* a directory exists here - we can't save over it */
// a directory exists here - we can't save over it
ui().popup_time(5, "%s", _("Cannot save over directory"));
can_create = false;
need_confirm = false;
@ -131,19 +132,19 @@ void menu_control_device_image::test_create(bool &can_create, bool &need_confirm
void menu_control_device_image::load_software_part()
{
std::string temp_name = std::string(sld->list_name()).append(":").append(swi->shortname()).append(":").append(swp->name());
std::string temp_name = string_format("%s:%s:%s", m_sld->list_name(), m_swi->shortname(), m_swp->name());
driver_enumerator drivlist(machine().options(), machine().options().system_name());
drivlist.next();
media_auditor auditor(drivlist);
media_auditor::summary summary = auditor.audit_software(sld->list_name(), (software_info *)swi, AUDIT_VALIDATE_FAST);
media_auditor::summary summary = auditor.audit_software(m_sld->list_name(), (software_info *)m_swi, AUDIT_VALIDATE_FAST);
// if everything looks good, load software
if (summary == media_auditor::CORRECT || summary == media_auditor::BEST_AVAILABLE || summary == media_auditor::NONE_NEEDED)
hook_load(temp_name, true);
else
{
machine().popmessage(_("The software selected is missing one or more required ROM or CHD images. Please select a different one."));
state = SELECT_SOFTLIST;
m_state = SELECT_SOFTLIST;
}
}
@ -154,8 +155,8 @@ void menu_control_device_image::load_software_part()
void menu_control_device_image::hook_load(std::string name, bool softlist)
{
if (image->is_reset_on_load()) image->set_init_phase();
image->load(name.c_str());
if (m_image.is_reset_on_load()) m_image.set_init_phase();
m_image.load(name.c_str());
stack_pop();
}
@ -175,87 +176,87 @@ void menu_control_device_image::populate()
void menu_control_device_image::handle()
{
switch(state) {
case START_FILE: {
submenu_result.filesel = menu_file_selector::result::INVALID;
menu::stack_push<menu_file_selector>(ui(), container(), image, m_current_directory, m_current_file, true, image->image_interface()!=nullptr, image->is_creatable(), submenu_result.filesel);
state = SELECT_FILE;
switch(m_state)
{
case START_FILE:
m_submenu_result.filesel = menu_file_selector::result::INVALID;
menu::stack_push<menu_file_selector>(ui(), container(), &m_image, m_current_directory, m_current_file, true, m_image.image_interface()!=nullptr, m_image.is_creatable(), m_submenu_result.filesel);
m_state = SELECT_FILE;
break;
}
case START_SOFTLIST:
sld = nullptr;
menu::stack_push<menu_software>(ui(), container(), image->image_interface(), &sld);
state = SELECT_SOFTLIST;
m_sld = nullptr;
menu::stack_push<menu_software>(ui(), container(), m_image.image_interface(), &m_sld);
m_state = SELECT_SOFTLIST;
break;
case START_OTHER_PART: {
submenu_result.swparts = menu_software_parts::result::INVALID;
menu::stack_push<menu_software_parts>(ui(), container(), swi, swp->interface(), &swp, true, submenu_result.swparts);
state = SELECT_OTHER_PART;
case START_OTHER_PART:
m_submenu_result.swparts = menu_software_parts::result::INVALID;
menu::stack_push<menu_software_parts>(ui(), container(), m_swi, m_swp->interface(), &m_swp, true, m_submenu_result.swparts);
m_state = SELECT_OTHER_PART;
break;
}
case SELECT_SOFTLIST:
if(!sld) {
if (!m_sld)
{
stack_pop();
break;
}
software_info_name = "";
menu::stack_push<menu_software_list>(ui(), container(), sld, image->image_interface(), software_info_name);
state = SELECT_PARTLIST;
m_software_info_name.clear();
menu::stack_push<menu_software_list>(ui(), container(), m_sld, m_image.image_interface(), m_software_info_name);
m_state = SELECT_PARTLIST;
break;
case SELECT_PARTLIST:
swi = sld->find(software_info_name.c_str());
if (!swi)
state = START_SOFTLIST;
else if(swi->has_multiple_parts(image->image_interface()))
m_swi = m_sld->find(m_software_info_name.c_str());
if (!m_swi)
m_state = START_SOFTLIST;
else if (m_swi->has_multiple_parts(m_image.image_interface()))
{
submenu_result.swparts = menu_software_parts::result::INVALID;
swp = nullptr;
menu::stack_push<menu_software_parts>(ui(), container(), swi, image->image_interface(), &swp, false, submenu_result.swparts);
state = SELECT_ONE_PART;
m_submenu_result.swparts = menu_software_parts::result::INVALID;
m_swp = nullptr;
menu::stack_push<menu_software_parts>(ui(), container(), m_swi, m_image.image_interface(), &m_swp, false, m_submenu_result.swparts);
m_state = SELECT_ONE_PART;
}
else
{
swp = swi->first_part();
m_swp = m_swi->first_part();
load_software_part();
}
break;
case SELECT_ONE_PART:
switch(submenu_result.swparts) {
switch(m_submenu_result.swparts) {
case menu_software_parts::result::ENTRY: {
load_software_part();
break;
}
default: // return to list
state = SELECT_SOFTLIST;
m_state = SELECT_SOFTLIST;
break;
}
break;
case SELECT_OTHER_PART:
switch(submenu_result.swparts) {
switch(m_submenu_result.swparts) {
case menu_software_parts::result::ENTRY:
load_software_part();
break;
case menu_software_parts::result::FMGR:
state = START_FILE;
m_state = START_FILE;
handle();
break;
case menu_software_parts::result::EMPTY:
image->unload();
m_image.unload();
stack_pop();
break;
case menu_software_parts::result::SWLIST:
state = START_SOFTLIST;
m_state = START_SOFTLIST;
handle();
break;
@ -267,9 +268,10 @@ void menu_control_device_image::handle()
break;
case SELECT_FILE:
switch(submenu_result.filesel) {
switch(m_submenu_result.filesel)
{
case menu_file_selector::result::EMPTY:
image->unload();
m_image.unload();
stack_pop();
break;
@ -278,12 +280,12 @@ void menu_control_device_image::handle()
break;
case menu_file_selector::result::CREATE:
menu::stack_push<menu_file_create>(ui(), container(), image, m_current_directory, m_current_file, create_ok);
state = CHECK_CREATE;
menu::stack_push<menu_file_create>(ui(), container(), &m_image, m_current_directory, m_current_file, m_create_ok);
m_state = CHECK_CREATE;
break;
case menu_file_selector::result::SOFTLIST:
state = START_SOFTLIST;
m_state = START_SOFTLIST;
handle();
break;
@ -298,34 +300,34 @@ void menu_control_device_image::handle()
test_create(can_create, need_confirm);
if(can_create) {
if(need_confirm) {
menu::stack_push<menu_confirm_save_as>(ui(), container(), &create_confirmed);
state = CREATE_CONFIRM;
menu::stack_push<menu_confirm_save_as>(ui(), container(), &m_create_confirmed);
m_state = CREATE_CONFIRM;
} else {
state = DO_CREATE;
m_state = DO_CREATE;
handle();
}
} else {
state = START_FILE;
m_state = START_FILE;
handle();
}
break;
}
case CREATE_CONFIRM:
state = create_confirmed ? DO_CREATE : START_FILE;
m_state = m_create_confirmed ? DO_CREATE : START_FILE;
handle();
break;
case CHECK_CREATE:
state = create_ok ? CREATE_FILE : START_FILE;
m_state = m_create_ok ? CREATE_FILE : START_FILE;
handle();
break;
case DO_CREATE: {
auto path = util::zippath_combine(m_current_directory.c_str(), m_current_file.c_str());
int err = image->create(path.c_str(), nullptr, nullptr);
int err = m_image.create(path.c_str(), nullptr, nullptr);
if (err != 0)
machine().popmessage("Error: %s", image->error());
machine().popmessage("Error: %s", m_image.error());
stack_pop();
break;
}

35
src/frontend/mame/ui/imgcntrl.h
View File

@ -23,21 +23,18 @@ namespace ui {
class menu_control_device_image : public menu
{
public:
menu_control_device_image(mame_ui_manager &mui, render_container &container, device_image_interface *image);
menu_control_device_image(mame_ui_manager &mui, render_container &container, device_image_interface &image);
virtual ~menu_control_device_image() override;
protected:
enum {
enum
{
START_FILE, START_OTHER_PART, START_SOFTLIST,
SELECT_PARTLIST, SELECT_ONE_PART, SELECT_OTHER_PART,
SELECT_FILE, CREATE_FILE, CREATE_CONFIRM, CHECK_CREATE, DO_CREATE, SELECT_SOFTLIST,
LAST_ID
};
// protected instance variables
int state;
device_image_interface *image;
// this is a single union that contains all of the different types of
// results we could get from child menus
union
@ -46,27 +43,27 @@ protected:
menu_software_parts::result swparts;
menu_select_rw::result rw;
int i;
} submenu_result;
} m_submenu_result;
std::string m_current_directory;
std::string m_current_file;
// instance variables - made protected so they can be shared with floppycntrl.cpp
int m_state;
device_image_interface & m_image;
std::string m_current_directory;
std::string m_current_file;
bool m_create_ok;
// methods
virtual void hook_load(std::string filename, bool softlist);
virtual void handle() override;
bool create_ok;
private:
virtual void populate() override;
private:
// instance variables
bool create_confirmed;
//bool softlist_done;
const software_info *swi;
const software_part *swp;
class software_list_device *sld;
std::string software_info_name;
bool m_create_confirmed;
const software_info * m_swi;
const software_part * m_swp;
class software_list_device * m_sld;
std::string m_software_info_name;
// methods
void test_create(bool &can_create, bool &need_confirm);