From 67c78124d58074224e38d5f48742ec01f2f5c140 Mon Sep 17 00:00:00 2001
From: Ilari Liusvaara <ilari.liusvaara@elisanet.fi>
Date: Thu, 14 Mar 2013 00:15:43 +0200
Subject: [PATCH] Support per-button autofire

---
 include/core/controllerframe.hpp           |  29 ++++++--
 include/core/dispatch.hpp                  |  18 +++++
 manual.lyx                                 |  54 ++++++++++++--
 manual.txt                                 |  38 +++++++---
 src/core/controller.cpp                    | 115 ++++++++++++++++++-----------
 src/core/controllerframe.cpp               |  46 +++++++++---
 src/core/dispatch.cpp                      |  16 ++++
 src/platform/wxwidgets/editor-autohold.cpp |  67 ++++++++++++++---
 src/platform/wxwidgets/mainwindow.cpp      |   2 +-
 9 files changed, 297 insertions(+), 88 deletions(-)

diff --git a/include/core/controllerframe.hpp b/include/core/controllerframe.hpp
index ce6a515e..96dce1a6 100644
--- a/include/core/controllerframe.hpp
+++ b/include/core/controllerframe.hpp
@@ -161,23 +161,42 @@ public:
  */
 	bool button2(unsigned port, unsigned controller, unsigned pbid) throw();
 /**
- * Set autofire pattern.
+ * Manipulate autofire.
  *
- * Parameter pattern: The new pattern.
- * Throws std::bad_alloc: Not enough memory.
+ * Parameter port: The port.
+ * Parameter controller: The controller.
+ * Parameter pbid: The physical button ID to manipulate.
+ * Parameter duty: The new duty cycle for autofire.
+ * Parameter cyclelen: The new cycle length.
+ */
+	void autofire2(unsigned port, unsigned controller, unsigned pbid, unsigned duty, unsigned cyclelen) throw();
+/**
+ * Query autofire.
+ *
+ * Parameter port: The port.
+ * Parameter controller: The controller.
+ * Parameter pbid: The physical button ID to query.
+ * Returns: The state of autofire.
  */
-	void autofire(std::vector<controller_frame> pattern) throw(std::bad_alloc);
+	std::pair<unsigned, unsigned> autofire2(unsigned port, unsigned controller, unsigned pbid) throw();
 /**
  * TODO: Document.
  */
 	bool is_present(unsigned port, unsigned controller) throw();
 private:
+	struct autofire_info
+	{
+		uint64_t first_frame;
+		unsigned duty;
+		unsigned cyclelen;
+		bool eval_at(uint64_t frame);
+	};
 	const port_type_set* types;
 	controller_frame _input;
 	controller_frame _autohold;
 	controller_frame _framehold;
+	std::map<unsigned, autofire_info> _autofire;
 	controller_frame _committed;
-	std::vector<controller_frame> _autofire;
 };
 
 /**
diff --git a/include/core/dispatch.hpp b/include/core/dispatch.hpp
index e2db8da4..bbe96efb 100644
--- a/include/core/dispatch.hpp
+++ b/include/core/dispatch.hpp
@@ -163,6 +163,24 @@ public:
  */
 	static void do_autohold_update(unsigned port, unsigned controller, unsigned ctrlnum, bool newstate) throw();
 /**
+ * Autofire on button might have been changed.
+ *
+ * The default handler does nothing.
+ *
+ * Parameter port: The port.
+ * Parameter controller: The controller
+ * Parameter ctrlnum: Physical control number (0-15).
+ * Parameter duty: Duty cycle.
+ * Parameter cyclelen: Cycle length.
+ */
+	virtual void on_autofire_update(unsigned port, unsigned controller, unsigned ctrlnum, unsigned duty,
+		unsigned cyclelen);
+/**
+ * Call all on_autohold_update() handlers.
+ */
+	static void do_autofire_update(unsigned port, unsigned controller, unsigned ctrlnum, unsigned duty,
+		unsigned cyclelen) throw();
+/**
  * Controller configuration may have been changed.
  *
  * The default handler does nothing.
diff --git a/manual.lyx b/manual.lyx
index e5a193ba..89183b89 100644
--- a/manual.lyx
+++ b/manual.lyx
@@ -663,23 +663,39 @@ Cauntion: Does not work properly if outside frame advance.
 \end_layout
 
 \begin_layout Subsubsection
-designate-position <class>-<#>-analog<n>
++autofire-controller <class>-<#>-<button> [[<duty>] <cyclelen>]
 \end_layout
 
 \begin_layout Standard
-Designate position for analog pair.
- <n> is only there if there are multiple axis pairs.
+Start autofire.
+ If duty is not specified, defaults to 1.
+ If <cyclelen> is not specified, defaults to 2.
+\end_layout
+
+\begin_layout Subsubsection
+-autofire-controller <class>-<#>-<button> [[<duty>] <cyclelen>]
+\end_layout
+
+\begin_layout Standard
+End autofire.
 \end_layout
 
 \begin_layout Subsubsection
-autofire (<pattern>|-)...
+autofire-controller <class>-<#>-<button> [[<duty>] <cyclelen>]
 \end_layout
 
 \begin_layout Standard
-Set autofire pattern.
- Each parameter is comma-separated list of button names to hold on that
- frame.
- After reaching the end of pattern, the pattern restarts from the beginning.
+Toggle autofire.
+ If autofire is turned on, specified cycle is used.
+\end_layout
+
+\begin_layout Subsubsection
+designate-position <class>-<#>-analog<n>
+\end_layout
+
+\begin_layout Standard
+Designate position for analog pair.
+ <n> is only there if there are multiple axis pairs.
 \end_layout
 
 \begin_layout Subsubsection
@@ -3360,6 +3376,28 @@ untype
 \begin_inset Quotes eld
 \end_inset
 
+autofire <duty> <cycle>
+\begin_inset Quotes erd
+\end_inset
+
+: Autofire with specifie duty and cycle.
+\end_layout
+
+\begin_layout Itemize
+\begin_inset Quotes eld
+\end_inset
+
+autofire
+\begin_inset Quotes erd
+\end_inset
+
+: Stop autofire.
+\end_layout
+
+\begin_layout Itemize
+\begin_inset Quotes eld
+\end_inset
+
 analog
 \begin_inset Quotes erd
 \end_inset
diff --git a/manual.txt b/manual.txt
index 4e135ad4..8605c070 100644
--- a/manual.txt
+++ b/manual.txt
@@ -305,30 +305,41 @@ for the next frame. See +controller for button names.
 
 Cauntion: Does not work properly if outside frame advance.
 
-5.3.22 designate-position <class>-<#>-analog<n>
+5.3.22 +autofire-controller <class>-<#>-<button> [[<duty>] 
+  <cyclelen>]
 
-Designate position for analog pair. <n> is only there if there 
-are multiple axis pairs.
+Start autofire. If duty is not specified, defaults to 1. If 
+<cyclelen> is not specified, defaults to 2.
+
+5.3.23 -autofire-controller <class>-<#>-<button> [[<duty>] 
+  <cyclelen>]
+
+End autofire.
+
+5.3.24 autofire-controller <class>-<#>-<button> [[<duty>] 
+  <cyclelen>]
 
-5.3.23 autofire (<pattern>|-)...
+Toggle autofire. If autofire is turned on, specified cycle is 
+used.
 
-Set autofire pattern. Each parameter is comma-separated list of 
-button names to hold on that frame. After reaching the end of 
-pattern, the pattern restarts from the beginning.
+5.3.25 designate-position <class>-<#>-analog<n>
 
-5.3.24 repaint
+Designate position for analog pair. <n> is only there if there 
+are multiple axis pairs.
+
+5.3.26 repaint
 
 Force a repaint.
 
-5.3.25 toggle-pause-on-end
+5.3.27 toggle-pause-on-end
 
 Toggle pause on end flag.
 
-5.3.26 set-pause-on-end
+5.3.28 set-pause-on-end
 
 Set pause on end flag.
 
-5.3.27 clear-pause-on-end
+5.3.29 clear-pause-on-end
 
 Clear pause on end flag.
 
@@ -1690,6 +1701,11 @@ Called on controller button press, with following parameters:
 
   – “untype”: Typing input undone.
 
+  – “autofire <duty> <cycle>”: Autofire with specifie duty and 
+    cycle.
+
+  – “autofire”: Stop autofire.
+
   – “analog”: Analog action on axis.
 
 8 Movie editor
diff --git a/src/core/controller.cpp b/src/core/controller.cpp
index 13580993..1149ecea 100644
--- a/src/core/controller.cpp
+++ b/src/core/controller.cpp
@@ -87,6 +87,14 @@ namespace
 				(stringfmt() << "Controller‣" << binding.cclass << "-" << binding.number << "‣"
 				<< binding.name << " (type)").str());
 			promote_key(*k);
+			k = new controller_key(lsnes_mapper, (stringfmt() << "+autofire-controller " << name).str(),
+				(stringfmt() << "Controller‣" << binding.cclass << "-" << binding.number << "‣"
+				<< binding.name << " (autofire)").str());
+			promote_key(*k);
+			k = new controller_key(lsnes_mapper, (stringfmt() << "autofire-controller " << name).str(),
+				(stringfmt() << "Controller‣" << binding.cclass << "-" << binding.number << "‣"
+				<< binding.name << " (autofire toggle)").str());
+			promote_key(*k);
 		} else {
 			k = new controller_key(lsnes_mapper, (stringfmt() << "designate-position " << name).str(),
 				(stringfmt() << "Controller‣" << binding.cclass << "-" << binding.number << "‣"
@@ -236,8 +244,7 @@ namespace
 			if(lua_callback_do_button(x.port, x.controller, x.bind.control1, nstate ? "hold" : "unhold"))
 				return;
 			controls.autohold2(x.port, x.controller, x.bind.control1, nstate);
-			information_dispatch::do_autohold_update(x.port, x.controller, x.bind.control1,
-				controls.autohold2(x.port, x.controller, x.bind.control1));
+			information_dispatch::do_autohold_update(x.port, x.controller, x.bind.control1, nstate);
 		} else if(mode == 2) {
 			//Framehold.
 			bool nstate = controls.framehold2(x.port, x.controller, x.bind.control1) ^ newstate;
@@ -282,42 +289,6 @@ namespace
 			controls.analog(z.port, z.controller, z.bind.control2, y);
 	}
 
-	function_ptr_command<const std::string&> autofire(lsnes_cmd, "autofire", "Set autofire pattern",
-		"Syntax: autofire <buttons|->...\nSet autofire pattern\n",
-		[](const std::string& a) throw(std::bad_alloc, std::runtime_error) {
-			auto r = regex(".*[^ \t].*", a, "Need at least one frame for autofire");
-			std::vector<controller_frame> new_autofire_pattern;
-			init_buttonmap();
-			std::string pattern = a;
-			while(pattern != "") {
-				std::string fpattern;
-				extract_token(pattern, fpattern, " \t", true);
-				if(fpattern == "-")
-					new_autofire_pattern.push_back(controls.get_blank());
-				else {
-					controller_frame c(controls.get_blank());
-					while(fpattern != "") {
-						size_t split = fpattern.find_first_of(",");
-						std::string button = fpattern;
-						std::string rest;
-						if(split < fpattern.length()) {
-							button = fpattern.substr(0, split);
-							rest = fpattern.substr(split + 1);
-						}
-						if(!active_buttons.count(button))
-							(stringfmt() << "Invalid button '" << button << "'").throwex();
-						auto g = active_buttons[button];
-						if(g.bind.is_axis)
-							(stringfmt() << "Invalid button '" << button << "'").throwex();
-						c.axis3(g.port, g.controller, g.bind.control1, true);
-						fpattern = rest;
-					}
-					new_autofire_pattern.push_back(c);
-				}
-			}
-			controls.autofire(new_autofire_pattern);
-		});
-
 	void do_action(const std::string& name, short state, int mode)
 	{
 		if(mode < 3)
@@ -333,26 +304,68 @@ namespace
 		}
 	}
 
+	void do_autofire_action(const std::string& a, int mode)
+	{
+		regex_results r = regex("([^ ]+)(([ \t]+([0-9]+))?[ \t]+([0-9]+))?[ \t]*", a,
+			"Invalid autofire parameters");
+		std::string name = r[1];
+		std::string _duty = r[4];
+		std::string _cyclelen = r[5];
+		if(_duty == "") _duty = "1";
+		if(_cyclelen == "") _cyclelen = "2";
+		uint32_t duty = parse_value<uint32_t>(_duty);
+		uint32_t cyclelen = parse_value<uint32_t>(_cyclelen);
+		if(duty >= cyclelen)
+			throw std::runtime_error("Invalid autofire parameters");
+		if(!all_buttons.count(name)) {
+			messages << "No such button " << name << std::endl;
+			return;
+		}
+		if(!active_buttons.count(name))
+			return;
+		auto z = active_buttons[name];
+		if(z.bind.is_axis) {
+			std::cerr << name << " is not a button." << std::endl;
+			return;
+		}
+		auto afire = controls.autofire2(z.port, z.controller, z.bind.control1);
+		if(mode == 1 || (mode == -1 && afire.first == 0)) {
+			//Turn on.
+			if(lua_callback_do_button(z.port, z.controller, z.bind.control1, (stringfmt() << "autofire "
+				<< duty << " " << cyclelen).str().c_str()))
+				return;
+			controls.autofire2(z.port, z.controller, z.bind.control1, duty, cyclelen);
+			information_dispatch::do_autofire_update(z.port, z.controller, z.bind.control1, duty,
+				cyclelen);
+		} else if(mode == 0 || (mode == -1 && afire.first != 0)) {
+			//Turn off.
+			if(lua_callback_do_button(z.port, z.controller, z.bind.control1, "autofire"))
+				return;
+			controls.autofire2(z.port, z.controller, z.bind.control1, 0, 1);
+			information_dispatch::do_autofire_update(z.port, z.controller, z.bind.control1, 0, 1);
+		}
+	}
+
 	function_ptr_command<const std::string&> button_p(lsnes_cmd, "+controller", "Press a button",
-		"Syntax: +button <button>...\nPress a button\n",
+		"Syntax: +controller<button>...\nPress a button\n",
 		[](const std::string& a) throw(std::bad_alloc, std::runtime_error) {
 			do_action(a, 1, 0);
 		});
 
 	function_ptr_command<const std::string&> button_r(lsnes_cmd, "-controller", "Release a button",
-		"Syntax: -button <button>...\nRelease a button\n",
+		"Syntax: -controller<button>...\nRelease a button\n",
 		[](const std::string& a) throw(std::bad_alloc, std::runtime_error) {
 			do_action(a, 0, 0);
 		});
 
 	function_ptr_command<const std::string&> button_h(lsnes_cmd, "hold-controller", "Autohold a button",
-		"Syntax: hold-button <button>...\nAutohold a button\n",
+		"Syntax: hold-controller<button>...\nAutohold a button\n",
 		[](const std::string& a) throw(std::bad_alloc, std::runtime_error) {
 			do_action(a, 1, 1);
 		});
 
 	function_ptr_command<const std::string&> button_t(lsnes_cmd, "type-controller", "Type a button",
-		"Syntax: type-button <button>...\nType a button\n",
+		"Syntax: type-controller<button>...\nType a button\n",
 		[](const std::string& a) throw(std::bad_alloc, std::runtime_error) {
 			do_action(a, 1, 2);
 		});
@@ -363,6 +376,24 @@ namespace
 			do_action(a, 0, 3);
 		});
 
+	function_ptr_command<const std::string&> button_ap(lsnes_cmd, "+autofire-controller", "Start autofire",
+		"Syntax: +autofire-controller<button> [[<duty> ]<cyclelen>]...\nAutofire a button\n",
+		[](const std::string& a) throw(std::bad_alloc, std::runtime_error) {
+			do_autofire_action(a, 1);
+		});
+
+	function_ptr_command<const std::string&> button_an(lsnes_cmd, "-autofire-controller", "End autofire",
+		"Syntax: -autofire-controller<button> [[<duty> ]<cyclelen>]...\nEnd Autofire on a button\n",
+		[](const std::string& a) throw(std::bad_alloc, std::runtime_error) {
+			do_autofire_action(a, 0);
+		});
+
+	function_ptr_command<const std::string&> button_at(lsnes_cmd, "autofire-controller", "Toggle autofire",
+		"Syntax: autofire-controller<button> [[<duty> ]<cyclelen>]...\nToggle Autofire on a button\n",
+		[](const std::string& a) throw(std::bad_alloc, std::runtime_error) {
+			do_autofire_action(a, -1);
+		});
+
 	class new_core_snoop : public information_dispatch
 	{
 	public:
diff --git a/src/core/controllerframe.cpp b/src/core/controllerframe.cpp
index fc3514d3..8d884a6a 100644
--- a/src/core/controllerframe.cpp
+++ b/src/core/controllerframe.cpp
@@ -1,6 +1,7 @@
 #include "core/controllerframe.hpp"
 #include "core/dispatch.hpp"
 #include "core/misc.hpp"
+#include "core/moviedata.hpp"
 #include "interface/romtype.hpp"
 
 #include <cstdio>
@@ -35,10 +36,11 @@ std::pair<int, int> controller_state::legacy_pcid_to_pair(unsigned pcid) throw()
 
 controller_frame controller_state::get(uint64_t framenum) throw()
 {
-	if(_autofire.size())
-		return _input ^ _framehold ^ _autohold ^ _autofire[framenum % _autofire.size()];
-	else
-		return _input ^ _framehold ^ _autohold;
+	controller_frame tmp =  _input ^ _framehold ^ _autohold;
+	for(auto i : _autofire)
+		if(i.second.eval_at(framenum))
+			tmp.axis2(i.first, tmp.axis2(i.first) ^ 1);
+	return tmp;
 }
 
 void controller_state::analog(unsigned port, unsigned controller, unsigned control, short x) throw()
@@ -57,6 +59,37 @@ bool controller_state::autohold2(unsigned port, unsigned controller, unsigned pb
 	return (_autohold.axis3(port, controller, pbid) != 0);
 }
 
+void controller_state::autofire2(unsigned port, unsigned controller, unsigned pbid, unsigned duty, unsigned cyclelen)
+	throw()
+{
+	unsigned idx = _input.porttypes().triple_to_index(port, controller, pbid);
+	if(duty) {
+		_autofire[idx].first_frame = movb.get_movie().get_current_frame();
+		_autofire[idx].duty = duty;
+		_autofire[idx].cyclelen = cyclelen;
+	} else
+		_autofire.erase(idx);
+}
+
+std::pair<unsigned, unsigned> controller_state::autofire2(unsigned port, unsigned controller, unsigned pbid) throw()
+{
+	unsigned idx = _input.porttypes().triple_to_index(port, controller, pbid);
+	if(!_autofire.count(idx))
+		return std::make_pair(0, 1);
+	else
+		return std::make_pair(_autofire[idx].duty, _autofire[idx].cyclelen);
+}
+
+bool controller_state::autofire_info::eval_at(uint64_t frame)
+{
+	if(frame < first_frame) {
+		uint64_t diff = first_frame - frame;
+		frame += ((diff / cyclelen) + 1) * cyclelen;
+	}
+	uint64_t diff2 = frame - first_frame;
+	return frame % cyclelen < duty;
+}
+
 void controller_state::reset_framehold() throw()
 {
 	_framehold = _framehold.blank_frame();
@@ -82,11 +115,6 @@ bool controller_state::button2(unsigned port, unsigned controller, unsigned pbid
 	return (_input.axis3(port, controller, pbid) != 0);
 }
 
-void controller_state::autofire(std::vector<controller_frame> pattern) throw(std::bad_alloc)
-{
-	_autofire = pattern;
-}
-
 void reread_active_buttons();
 
 void controller_state::set_ports(const port_type_set& ptype) throw(std::runtime_error)
diff --git a/src/core/dispatch.cpp b/src/core/dispatch.cpp
index 10f3e771..5d405f1c 100644
--- a/src/core/dispatch.cpp
+++ b/src/core/dispatch.cpp
@@ -197,6 +197,22 @@ void information_dispatch::do_autohold_update(unsigned port, unsigned controller
 	}
 }
 
+void information_dispatch::on_autofire_update(unsigned port, unsigned controller, unsigned ctrlnum, unsigned duty,
+	unsigned cyclelen)
+{
+	//Do nothing.
+}
+
+void information_dispatch::do_autofire_update(unsigned port, unsigned controller, unsigned ctrlnum, unsigned duty,
+	unsigned cyclelen) throw()
+{
+	for(auto& i : dispatch()) {
+		START_EH_BLOCK
+		i->on_autofire_update(port, controller, ctrlnum, duty, cyclelen);
+		END_EH_BLOCK(i, "on_autofire_update");
+	}
+}
+
 void information_dispatch::on_autohold_reconfigure()
 {
 	//Do nothing.
diff --git a/src/platform/wxwidgets/editor-autohold.cpp b/src/platform/wxwidgets/editor-autohold.cpp
index 1acee27d..9fb528c0 100644
--- a/src/platform/wxwidgets/editor-autohold.cpp
+++ b/src/platform/wxwidgets/editor-autohold.cpp
@@ -29,6 +29,8 @@ public:
 	void on_wclose(wxCloseEvent& e);
 	void on_checkbox(wxCommandEvent& e);
 	void on_autohold_update(unsigned port, unsigned controller, unsigned ctrlnum, bool newstate);
+	void on_autofire_update(unsigned port, unsigned controller, unsigned ctrlnum, unsigned duty,
+		unsigned cyclelen);
 	void on_autohold_reconfigure();
 private:
 	struct control_triple
@@ -36,8 +38,10 @@ private:
 		unsigned port;
 		unsigned controller;
 		unsigned index;
+		int afid;
 		wxStaticText* label;	//Used only by UI version.
 		wxCheckBox* check;	//Used only by UI version.
+		wxCheckBox* afcheck;	//Used only by UI version.
 		bool status;		//Used only by internal version.
 		unsigned logical;	//Logical controller. Internal only.
 		std::string name;	//Name. Internal only.
@@ -67,7 +71,7 @@ namespace
 wxeditor_autohold::~wxeditor_autohold() throw() {}
 
 wxeditor_autohold::wxeditor_autohold(wxWindow* parent)
-	: wxDialog(parent, wxID_ANY, wxT("lsnes: Autohold"), wxDefaultPosition, wxSize(-1, -1)),
+	: wxDialog(parent, wxID_ANY, wxT("lsnes: Autohold/Autofire"), wxDefaultPosition, wxSize(-1, -1)),
 	information_dispatch("autohold-listener")
 {
 	closing = false;
@@ -93,6 +97,19 @@ void wxeditor_autohold::on_autohold_update(unsigned port, unsigned controller, u
 	});
 }
 
+void wxeditor_autohold::on_autofire_update(unsigned port, unsigned controller, unsigned ctrlnum, unsigned duty,
+	unsigned cyclelen)
+{
+	runuifun([this, port, controller, ctrlnum, duty]() { 
+		for(auto i : this->autoholds) {
+			if(i.second.port != port) continue;
+			if(i.second.controller != controller) continue;
+			if(i.second.index != ctrlnum) continue;
+			i.second.afcheck->SetValue(duty != 0);
+		}
+	});
+}
+
 void wxeditor_autohold::on_autohold_reconfigure()
 {
 	runuifun([this]() { this->update_controls(); });
@@ -104,16 +121,30 @@ void wxeditor_autohold::on_checkbox(wxCommandEvent& e)
 	if(!autoholds.count(id))
 		return;
 	auto t = autoholds[id];
-	bool newstate = t.check->IsChecked();
+	bool isaf = (t.afid == id);
+	bool newstate = isaf ? t.afcheck->IsChecked() : t.check->IsChecked();
 	bool state = false;
-	runemufn([t, newstate, &state]() {
-		state = controls.autohold2(t.port, t.controller, t.index);
-		if(lua_callback_do_button(t.port, t.controller, t.index, newstate ? "hold" : "unhold"))
-			return;
-		controls.autohold2(t.port, t.controller, t.index, newstate);
-		state = newstate;
+	runemufn([t, newstate, &state, isaf]() {
+		if(isaf) {
+			auto _state = controls.autofire2(t.port, t.controller, t.index);
+			state = (_state.first != 0);
+			if(lua_callback_do_button(t.port, t.controller, t.index, newstate ? "autofire 1 2" :
+				"autofire"))
+				return;
+			controls.autofire2(t.port, t.controller, t.index, newstate ? 1 : 0, newstate ? 2 : 1);
+			state = newstate;
+		} else {
+			state = controls.autohold2(t.port, t.controller, t.index);
+			if(lua_callback_do_button(t.port, t.controller, t.index, newstate ? "hold" : "unhold"))
+				return;
+			controls.autohold2(t.port, t.controller, t.index, newstate);
+			state = newstate;
+		}
 	});
-	t.check->SetValue(newstate);
+	if(isaf)
+		t.afcheck->SetValue(state);
+	else
+		t.check->SetValue(state);
 }
 
 void wxeditor_autohold::update_controls()
@@ -121,8 +152,12 @@ void wxeditor_autohold::update_controls()
 	if(nocontrollers)
 		nocontrollers->Destroy();
 	for(auto i : autoholds) {
-		i.second.label->Destroy();
-		i.second.check->Destroy();
+		if(i.first != i.second.afid)
+			i.second.label->Destroy();
+		if(i.first != i.second.afid)
+			i.second.check->Destroy();
+		if(i.first == i.second.afid)
+			i.second.afcheck->Destroy();
 	}
 	for(auto i : panels) {
 		hsizer->Detach(i.panel);
@@ -199,7 +234,7 @@ void wxeditor_autohold::update_controls()
 			d.label = new wxStaticText(d.panel, wxID_ANY, towxstring(_controller_labels[i.logical]));
 			d.top->Add(d.label);
 #endif
-			current = d.grid = new wxFlexGridSizer(0, 2, 0, 0);
+			current = d.grid = new wxFlexGridSizer(0, 3, 0, 0);
 			d.top->Add(d.grid);
 			d.rtop->Add(d.top);
 			hsizer->Add(d.panel);
@@ -208,17 +243,25 @@ void wxeditor_autohold::update_controls()
 		}
 		wxStaticText* label = new wxStaticText(current_p, wxID_ANY, towxstring(i.name));
 		wxCheckBox* check = new wxCheckBox(current_p, next_id, wxT("Hold"));
+		wxCheckBox* afcheck = new wxCheckBox(current_p, next_id + 1, wxT("Rapid"));
 		struct control_triple t;
 		t.port = i.port;
 		t.controller = i.controller;
 		t.index = i.index;
 		t.label = label;
 		t.check = check;
+		t.afcheck = afcheck;
+		t.afid = next_id + 1;
 		check->SetValue(i.status);
 		check->Connect(wxEVT_COMMAND_CHECKBOX_CLICKED,  wxCommandEventHandler(wxeditor_autohold::on_checkbox),
 			NULL, this);
+		afcheck->SetValue(i.status);
+		afcheck->Connect(wxEVT_COMMAND_CHECKBOX_CLICKED,
+			wxCommandEventHandler(wxeditor_autohold::on_checkbox), NULL, this);
 		current->Add(label);
 		current->Add(check);
+		current->Add(afcheck);
+		autoholds[next_id++] = t;
 		autoholds[next_id++] = t;
 	}
 	if(_autoholds.empty()) {
diff --git a/src/platform/wxwidgets/mainwindow.cpp b/src/platform/wxwidgets/mainwindow.cpp
index 51b6f806..d37010d9 100644
--- a/src/platform/wxwidgets/mainwindow.cpp
+++ b/src/platform/wxwidgets/mainwindow.cpp
@@ -701,7 +701,7 @@ wxwin_mainwindow::wxwin_mainwindow()
 	menu_separator();
 	menu_entry(wxID_RESET_LUA, wxT("Reset Lua VM"));
 	menu_separator();
-	menu_entry(wxID_AUTOHOLD, wxT("Autohold..."));
+	menu_entry(wxID_AUTOHOLD, wxT("Autohold/Autofire..."));
 	menu_separator();
 	menu_entry(wxID_EDIT_MEMORYWATCH, wxT("Edit memory watch..."));
 	menu_separator();
-- 
2.11.4.GIT