Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-06-04 03:46:29 +03:00
Code Issues Actions 1 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); floppy_image_device *floppy_device = dynamic_cast<floppy_image_device *>(selected_device);
if (floppy_device != nullptr) 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 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 the existing menu
reset(reset_options::REMEMBER_POSITION); reset(reset_options::REMEMBER_POSITION);

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

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

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

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

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

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