ui: Added options to pause when showing menus and to open menus in active window.

* ui/ui.cpp: Dim all windows when paused.
* ui/ui.cpp, menu/menu.cpp, ui/viewgfx.cpp: Broke assumption that UI
  elements will be drawn in the first window.
* menu/menu.cpp: Allow menus to migrate between windows on activation.
* ui/ui.cpp, ui/moptions.cpp, ui/submenu.cpp: Added an option to
  automatically pause when a menu is displayed.
* Added an option to open menus in the most recently active window (alos
  affcts the profiler, speed display and popup messages).

Author: cuavas

src/emu/render.cpp

@@ -3443,66 +3443,51 @@ render_target *render_manager::target_by_index(int index) const
 //  fonts
 //-------------------------------------------------
 
-float render_manager::ui_aspect(render_container *rc)
+float render_manager::ui_aspect(render_target &target)
 {
-	// work out if this is a UI container
-	render_target *target = nullptr;
-	if (!rc)
-	{
-		target = &ui_target();
-		rc = target->ui_container();
-		assert(rc);
-	}
-	else
-	{
-		for (render_target &t : m_targetlist)
-		{
-			if (t.ui_container() == rc)
-			{
-				target = &t;
-				break;
-			}
-		}
-	}
+	assert(target.ui_container());
 
+	// based on the orientation of the target, compute height/width or width/height
+	int const orient = orientation_add(target.orientation(), target.ui_container()->orientation());
 	float aspect;
+	if (!(orient & ORIENTATION_SWAP_XY))
+		aspect = float(target.height()) / float(target.width());
+	else
+		aspect = float(target.width()) / float(target.height());
 
-	if (target)
+	// if we have a valid pixel aspect, apply that and return
+	if (target.pixel_aspect() != 0.0F)
 	{
-		// UI container, aggregated multi-screen target
+		float pixel_aspect = target.pixel_aspect();
 
-		// based on the orientation of the target, compute height/width or width/height
-		int const orient = orientation_add(target->orientation(), rc->orientation());
-		if (!(orient & ORIENTATION_SWAP_XY))
-			aspect = float(target->height()) / float(target->width());
-		else
-			aspect = float(target->width()) / float(target->height());
+		if (orient & ORIENTATION_SWAP_XY)
+			pixel_aspect = 1.0F / pixel_aspect;
 
-		// if we have a valid pixel aspect, apply that and return
-		if (target->pixel_aspect() != 0.0f)
-		{
-			float pixel_aspect = target->pixel_aspect();
+		return aspect / pixel_aspect;
+	}
 
-			if (orient & ORIENTATION_SWAP_XY)
-				pixel_aspect = 1.0f / pixel_aspect;
+	// clamp for extreme proportions
+	return std::clamp(aspect, 0.66F, 1.5F);
+}
 
-			return aspect /= pixel_aspect;
-		}
-	}
-	else
+float render_manager::ui_aspect(render_container &rc)
+{
+	// deal with UI containers
+	for (render_target &target : m_targetlist)
 	{
-		// single screen container
-
-		// based on the orientation of the target, compute height/width or width/height
-		int const orient = rc->orientation();
-		if (!(orient & ORIENTATION_SWAP_XY))
-			aspect = (float)rc->screen()->visible_area().height() / (float)rc->screen()->visible_area().width();
-		else
-			aspect = (float)rc->screen()->visible_area().width() / (float)rc->screen()->visible_area().height();
+		if (target.ui_container() == &rc)
+			return ui_aspect(target);
 	}
 
+	// based on the orientation of the target, compute height/width or width/height
+	assert(rc.screen());
+	int const orient = rc.orientation();
+	float const viswidth = rc.screen()->visible_area().width();
+	float const visheight = rc.screen()->visible_area().height();
+	float const aspect = !(orient & ORIENTATION_SWAP_XY) ? (visheight / viswidth) : (viswidth / visheight);
+
 	// clamp for extreme proportions
-	return std::clamp(aspect, 0.66f, 1.5f);
+	return std::clamp(aspect, 0.66F, 1.5F);
 }
 
 

src/emu/render.h

@@ -679,7 +679,8 @@ class render_manager
 	// UI targets
 	render_target &ui_target() const { assert(m_ui_target != nullptr); return *m_ui_target; }
 	void set_ui_target(render_target &target) { m_ui_target = ⌖ }
-	float ui_aspect(render_container *rc = nullptr);
+	float ui_aspect(render_target &target);     // gets result for target's UI container - target must not be a hidden target with no UI container
+	float ui_aspect(render_container &rc);      // rc must be a screen container or a UI container for a render target; requires an O(n) scan of render targets
 
 	// UI containers
 	render_container &ui_container() const { assert(ui_target().ui_container()); return *ui_target().ui_container(); }

src/emu/uiinput.cpp

@@ -35,6 +35,8 @@ enum
 
 ui_input_manager::ui_input_manager(running_machine &machine)
 	: m_machine(machine)
+	, m_focused_target(nullptr)
+	, m_last_focused_target(nullptr)
 	, m_presses_enabled(true)
 	, m_events_start(0)
 	, m_events_end(0)
@@ -192,6 +194,8 @@ bool ui_input_manager::pressed_repeat(int code, int speed)
 
 void ui_input_manager::push_window_focus_event(render_target *target)
 {
+	m_focused_target = m_last_focused_target = target;
+
 	ui_event event = { ui_event::type::NONE };
 	event.event_type = ui_event::type::WINDOW_FOCUS;
 	event.target = target;
@@ -205,6 +209,9 @@ void ui_input_manager::push_window_focus_event(render_target *target)
 
 void ui_input_manager::push_window_defocus_event(render_target *target)
 {
+	if (m_focused_target == target)
+		m_focused_target = nullptr;
+
 	ui_event event = { ui_event::type::NONE };
 	event.event_type = ui_event::type::WINDOW_DEFOCUS;
 	event.target = target;

src/emu/uiinput.h

@@ -88,6 +88,10 @@ class ui_input_manager final : public osd::ui_event_handler
 	// return true if a key down for the given user interface sequence is detected, or if autorepeat at the given speed is triggered
 	bool pressed_repeat(int code, int speed);
 
+	// get current or most recently focused render target
+	render_target *focused_target() const { return m_focused_target; }
+	render_target *last_focused_target() const { return m_last_focused_target; }
+
 	// getters
 	running_machine &machine() const { return m_machine; }
 
@@ -109,6 +113,10 @@ class ui_input_manager final : public osd::ui_event_handler
 	// internal state
 	running_machine &   m_machine;
 
+	// track focused render target;
+	render_target *     m_focused_target;
+	render_target *     m_last_focused_target;
+
 	// pressed states; retrieved with pressed() or pressed_repeat()
 	bool                m_presses_enabled;
 	osd_ticks_t         m_next_repeat[IPT_COUNT];

src/frontend/mame/cheat.cpp

@@ -1238,21 +1238,25 @@ bool cheat_manager::save_all(std::string const &filename)
 //  render text
 //-------------------------------------------------
 
-void cheat_manager::render_text(mame_ui_manager &mui, render_container &container)
+void cheat_manager::render_text(mame_ui_manager &mui, render_target &target)
 {
 	// render any text and free it along the way
-	for (int linenum = 0; linenum < m_output.size(); linenum++)
+	if (!m_output.size())
 	{
-		if (!m_output[linenum].empty())
+		float const lineheight = mui.get_line_height(target);
+		for (int linenum = 0; linenum < m_output.size(); linenum++)
 		{
-			// output the text
-			mui.draw_text_full(
-					container,
-					m_output[linenum],
-					0.0f, float(linenum) * mui.get_line_height(), 1.0f,
-					m_justify[linenum], ui::text_layout::word_wrapping::NEVER,
-					mame_ui_manager::OPAQUE_, rgb_t::white(), rgb_t::black(),
-					nullptr, nullptr);
+			if (!m_output[linenum].empty())
+			{
+				// output the text
+				mui.draw_text_full(
+						target,
+						m_output[linenum],
+						0.0f, float(linenum) * lineheight, 1.0f,
+						m_justify[linenum], ui::text_layout::word_wrapping::NEVER,
+						mame_ui_manager::OPAQUE_, rgb_t::white(), rgb_t::black(),
+						nullptr, nullptr);
+			}
 		}
 	}
 }
@@ -1371,9 +1375,10 @@ uint64_t cheat_manager::execute_tobcd(int params, const uint64_t *param)
 
 void cheat_manager::frame_update()
 {
+	// FIXME: this assumes the overlay will always be on the default UI target
 	// set up for accumulating output
 	m_lastline = 0;
-	m_numlines = floor(1.0f / mame_machine_manager::instance()->ui().get_line_height());
+	m_numlines = floor(1.0f / mame_machine_manager::instance()->ui().get_line_height(machine().render().ui_target()));
 	m_numlines = std::min<uint8_t>(m_numlines, m_output.size());
 	for (auto & elem : m_output)
 		elem.clear();

src/frontend/mame/cheat.h

@@ -319,7 +319,7 @@ class cheat_manager
 	// actions
 	void reload();
 	bool save_all(std::string const &filename);
-	void render_text(mame_ui_manager &mui, render_container &container);
+	void render_text(mame_ui_manager &mui, render_target &target);
 
 	// output helpers
 	std::string &get_output_string(int row, ui::text_layout::text_justify justify);

src/frontend/mame/luaengine.cpp

@@ -946,8 +946,8 @@ void lua_engine::initialize()
 		[this](const char *name)
 		{
 			mame_ui_manager &mui = mame_machine_manager::instance()->ui();
-			render_container &container = machine().render().ui_container();
-			ui::menu_plugin::show_menu(mui, container, name);
+			render_target &target = machine().render().ui_target(); // FIXME: it should really ask the UI manager where to show this
+			ui::menu_plugin::show_menu(mui, target, name);
 		};
 	emu["register_callback"] =
 		[this] (sol::function cb, const std::string &name)
@@ -1811,7 +1811,9 @@ void lua_engine::initialize()
 						msg,
 						x, y, (1.0F - x),
 						justify, ui::text_layout::word_wrapping::WORD,
-						mame_ui_manager::OPAQUE_, *fgcolor, *bgcolor);
+						mame_ui_manager::OPAQUE_, *fgcolor, *bgcolor,
+						nullptr, nullptr,
+						ui.get_line_height(ui.machine().render().ui_target())); // FIXME: line height quantisation assumes text is displayed on default UI target
 			});
 	screen_dev_type.set_function(
 			"orientation",
@@ -2224,15 +2226,15 @@ void lua_engine::initialize()
 
 	auto ui_type = sol().registry().new_usertype<mame_ui_manager>("ui", sol::no_constructor);
 	// sol converts char32_t to a string
-	ui_type.set_function("get_char_width", [] (mame_ui_manager &m, uint32_t utf8char) { return m.get_char_width(utf8char); });
-	ui_type.set_function("get_string_width", static_cast<float (mame_ui_manager::*)(std::string_view)>(&mame_ui_manager::get_string_width));
+	ui_type.set_function("get_char_width", [] (mame_ui_manager &m, uint32_t utf8char) { return m.get_char_width(m.machine().render().ui_target(), utf8char); }); // FIXME: allow render target to be supplied
+	ui_type.set_function("get_string_width", [] (mame_ui_manager &m, std::string_view s) { return m.get_string_width(m.machine().render().ui_target(), s); }); // FIXME: allow render target to be supplied
 	ui_type.set_function("set_aggressive_input_focus", [] (mame_ui_manager &m, bool aggressive_focus) { osd_set_aggressive_input_focus(aggressive_focus); });
 	ui_type["get_general_input_setting"] = sol::overload(
 			// TODO: overload with sequence type string - parser isn't available here
 			[] (mame_ui_manager &ui, ioport_type type, int player) { return ui.get_general_input_setting(type, player, SEQ_TYPE_STANDARD); },
 			[] (mame_ui_manager &ui, ioport_type type) { return ui.get_general_input_setting(type, 0, SEQ_TYPE_STANDARD); });
 	ui_type["options"] = sol::property([] (mame_ui_manager &m) { return static_cast<core_options *>(&m.options()); });
-	ui_type["line_height"] = sol::property([] (mame_ui_manager &m) { return m.get_line_height(); });
+	ui_type["line_height"] = sol::property([] (mame_ui_manager &m) { return m.get_line_height(m.machine().render().ui_target()); }); // FIXME: allow render target to be supplied
 	ui_type["menu_active"] = sol::property(&mame_ui_manager::is_menu_active);
 	ui_type["ui_active"] = sol::property(&mame_ui_manager::ui_active, &mame_ui_manager::set_ui_active);
 	ui_type["single_step"] = sol::property(&mame_ui_manager::single_step, &mame_ui_manager::set_single_step);

src/frontend/mame/luaengine_render.cpp

@@ -1191,7 +1191,9 @@ void lua_engine::initialize_render(sol::table &emu)
 						msg,
 						x, y, (1.0f - x),
 						justify, ui::text_layout::word_wrapping::WORD,
-						mame_ui_manager::OPAQUE_, *fgcolor, *bgcolor);
+						mame_ui_manager::OPAQUE_, *fgcolor, *bgcolor,
+						nullptr, nullptr,
+						ui.get_line_height(ui.machine().render().ui_target())); // FIXME: line height quantisation assumes text is displayed on default UI target
 			});
 	render_container_type["user_settings"] = sol::property(&render_container::get_user_settings, &render_container::set_user_settings);
 	render_container_type["orientation"] = sol::property(

src/frontend/mame/mame.cpp

@@ -440,11 +440,11 @@ void emulator_info::display_ui_chooser(running_machine& machine)
 {
 	// force the UI to show the game select screen
 	mame_ui_manager &mui = mame_machine_manager::instance()->ui();
-	render_container &container = machine.render().ui_container();
+	render_target &target = machine.render().ui_target();
 	if (machine.options().ui() == emu_options::UI_SIMPLE)
-		ui::simple_menu_select_game::force_game_select(mui, container);
+		ui::simple_menu_select_game::force_game_select(mui, target);
 	else
-		ui::menu_select_game::force_game_select(mui, container);
+		ui::menu_select_game::force_game_select(mui, target);
 }
 
 int emulator_info::start_frontend(emu_options &options, osd_interface &osd, std::vector<std::string> &args)
@@ -461,7 +461,7 @@ int emulator_info::start_frontend(emu_options &options, osd_interface &osd, int
 
 bool emulator_info::draw_user_interface(running_machine& machine)
 {
-	return mame_machine_manager::instance()->ui().update_and_render(machine.render().ui_container());
+	return mame_machine_manager::instance()->ui().update_and_render(machine.render().ui_target());
 }
 
 void emulator_info::periodic_check()

src/frontend/mame/ui/about.cpp

@@ -34,8 +34,8 @@ namespace {
 //  ctor
 //-------------------------------------------------
 
-menu_about::menu_about(mame_ui_manager &mui, render_container &container)
-	: menu_textbox(mui, container)
+menu_about::menu_about(mame_ui_manager &mui, render_target &target)
+	: menu_textbox(mui, target)
 	, m_header{
 			util::string_format(
 #ifdef MAME_DEBUG