1 files changed, 316 insertions, 366 deletions

diff --git a/src/gui/touchscreengui.cpp b/src/gui/touchscreengui.cpp
index 1f9da71c9..0d64aa618 100644
--- a/src/gui/touchscreengui.cpp
+++ b/src/gui/touchscreengui.cpp
@@ -36,75 +36,82 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 using namespace irr::core;
 
-const char **button_imagenames =
-		(const char *[]){"jump_btn.png", "down.png", "zoom.png", "aux_btn.png"};
-
-const char **joystick_imagenames = (const char *[]){
-		"joystick_off.png", "joystick_bg.png", "joystick_center.png"};
+const char **button_imagenames = (const char *[]) {
+	"jump_btn.png",
+	"down.png",
+	"zoom.png",
+	"aux_btn.png"
+};
+
+const char **joystick_imagenames = (const char *[]) {
+	"joystick_off.png",
+	"joystick_bg.png",
+	"joystick_center.png"
+};
 
 static irr::EKEY_CODE id2keycode(touch_gui_button_id id)
 {
 	std::string key = "";
 	switch (id) {
-	case forward_id:
-		key = "forward";
-		break;
-	case left_id:
-		key = "left";
-		break;
-	case right_id:
-		key = "right";
-		break;
-	case backward_id:
-		key = "backward";
-		break;
-	case inventory_id:
-		key = "inventory";
-		break;
-	case drop_id:
-		key = "drop";
-		break;
-	case jump_id:
-		key = "jump";
-		break;
-	case crunch_id:
-		key = "sneak";
-		break;
-	case zoom_id:
-		key = "zoom";
-		break;
-	case special1_id:
-		key = "special1";
-		break;
-	case fly_id:
-		key = "freemove";
-		break;
-	case noclip_id:
-		key = "noclip";
-		break;
-	case fast_id:
-		key = "fastmove";
-		break;
-	case debug_id:
-		key = "toggle_debug";
-		break;
-	case toggle_chat_id:
-		key = "toggle_chat";
-		break;
-	case minimap_id:
-		key = "minimap";
-		break;
-	case chat_id:
-		key = "chat";
-		break;
-	case camera_id:
-		key = "camera_mode";
-		break;
-	case range_id:
-		key = "rangeselect";
-		break;
-	default:
-		break;
+		case forward_id:
+			key = "forward";
+			break;
+		case left_id:
+			key = "left";
+			break;
+		case right_id:
+			key = "right";
+			break;
+		case backward_id:
+			key = "backward";
+			break;
+		case inventory_id:
+			key = "inventory";
+			break;
+		case drop_id:
+			key = "drop";
+			break;
+		case jump_id:
+			key = "jump";
+			break;
+		case crunch_id:
+			key = "sneak";
+			break;
+		case zoom_id:
+			key = "zoom";
+			break;
+		case special1_id:
+			key = "special1";
+			break;
+		case fly_id:
+			key = "freemove";
+			break;
+		case noclip_id:
+			key = "noclip";
+			break;
+		case fast_id:
+			key = "fastmove";
+			break;
+		case debug_id:
+			key = "toggle_debug";
+			break;
+		case toggle_chat_id:
+			key = "toggle_chat";
+			break;
+		case minimap_id:
+			key = "minimap";
+			break;
+		case chat_id:
+			key = "chat";
+			break;
+		case camera_id:
+			key = "camera_mode";
+			break;
+		case range_id:
+			key = "rangeselect";
+			break;
+		default:
+			break;
 	}
 	assert(!key.empty());
 	return keyname_to_keycode(g_settings->get("keymap_" + key).c_str());
@@ -113,18 +120,16 @@ static irr::EKEY_CODE id2keycode(touch_gui_button_id id)
 TouchScreenGUI *g_touchscreengui;
 
 static void load_button_texture(button_info *btn, const char *path,
-		const rect<s32> &button_rect, ISimpleTextureSource *tsrc,
-		video::IVideoDriver *driver)
+		const rect<s32> &button_rect, ISimpleTextureSource *tsrc, video::IVideoDriver *driver)
 {
 	unsigned int tid;
-	video::ITexture *texture =
-			guiScalingImageButton(driver, tsrc->getTexture(path, &tid),
-					button_rect.getWidth(), button_rect.getHeight());
+	video::ITexture *texture = guiScalingImageButton(driver,
+			tsrc->getTexture(path, &tid), button_rect.getWidth(),
+			button_rect.getHeight());
 	if (texture) {
 		btn->guibutton->setUseAlphaChannel(true);
 		if (g_settings->getBool("gui_scaling_filter")) {
-			rect<s32> txr_rect = rect<s32>(0, 0, button_rect.getWidth(),
-					button_rect.getHeight());
+			rect<s32> txr_rect = rect<s32>(0, 0, button_rect.getWidth(), button_rect.getHeight());
 			btn->guibutton->setImage(texture, txr_rect);
 			btn->guibutton->setPressedImage(texture, txr_rect);
 			btn->guibutton->setScaleImage(false);
@@ -138,15 +143,17 @@ static void load_button_texture(button_info *btn, const char *path,
 	}
 }
 
-AutoHideButtonBar::AutoHideButtonBar(IrrlichtDevice *device, IEventReceiver *receiver) :
-		m_driver(device->getVideoDriver()), m_guienv(device->getGUIEnvironment()),
-		m_receiver(receiver)
+AutoHideButtonBar::AutoHideButtonBar(IrrlichtDevice *device,
+		IEventReceiver *receiver) :
+			m_driver(device->getVideoDriver()),
+			m_guienv(device->getGUIEnvironment()),
+			m_receiver(receiver)
 {
 }
 
-void AutoHideButtonBar::init(ISimpleTextureSource *tsrc, const char *starter_img,
-		int button_id, const v2s32 &UpperLeft, const v2s32 &LowerRight,
-		autohide_button_bar_dir dir, float timeout)
+void AutoHideButtonBar::init(ISimpleTextureSource *tsrc,
+		const char *starter_img, int button_id, const v2s32 &UpperLeft,
+		const v2s32 &LowerRight, autohide_button_bar_dir dir, float timeout)
 {
 	m_texturesource = tsrc;
 
@@ -155,19 +162,18 @@ void AutoHideButtonBar::init(ISimpleTextureSource *tsrc, const char *starter_img
 
 	// init settings bar
 
-	irr::core::rect<int> current_button =
-			rect<s32>(UpperLeft.X, UpperLeft.Y, LowerRight.X, LowerRight.Y);
+	irr::core::rect<int> current_button = rect<s32>(UpperLeft.X, UpperLeft.Y,
+			LowerRight.X, LowerRight.Y);
 
-	m_starter.guibutton = m_guienv->addButton(
-			current_button, nullptr, button_id, L"", nullptr);
+	m_starter.guibutton         = m_guienv->addButton(current_button, nullptr, button_id, L"", nullptr);
 	m_starter.guibutton->grab();
-	m_starter.repeatcounter = -1;
-	m_starter.keycode = KEY_OEM_8; // use invalid keycode as it's not relevant
+	m_starter.repeatcounter     = -1;
+	m_starter.keycode           = KEY_OEM_8; // use invalid keycode as it's not relevant
 	m_starter.immediate_release = true;
 	m_starter.ids.clear();
 
-	load_button_texture(&m_starter, starter_img, current_button, m_texturesource,
-			m_driver);
+	load_button_texture(&m_starter, starter_img, current_button,
+			m_texturesource, m_driver);
 
 	m_dir = dir;
 	m_timeout_value = timeout;
@@ -183,13 +189,13 @@ AutoHideButtonBar::~AutoHideButtonBar()
 	}
 }
 
-void AutoHideButtonBar::addButton(touch_gui_button_id button_id, const wchar_t *caption,
-		const char *btn_image)
+void AutoHideButtonBar::addButton(touch_gui_button_id button_id,
+		const wchar_t *caption, const char *btn_image)
 {
 
 	if (!m_initialized) {
 		errorstream << "AutoHideButtonBar::addButton not yet initialized!"
-			    << std::endl;
+				<< std::endl;
 		return;
 	}
 	int button_size = 0;
@@ -206,55 +212,55 @@ void AutoHideButtonBar::addButton(touch_gui_button_id button_id, const wchar_t *
 		int x_end = 0;
 
 		if (m_dir == AHBB_Dir_Left_Right) {
-			x_start = m_lower_right.X +
-				  (button_size * 1.25 * m_buttons.size()) +
-				  (button_size * 0.25);
+			x_start = m_lower_right.X + (button_size * 1.25 * m_buttons.size())
+					+ (button_size * 0.25);
 			x_end = x_start + button_size;
 		} else {
-			x_end = m_upper_left.X - (button_size * 1.25 * m_buttons.size()) -
-				(button_size * 0.25);
+			x_end = m_upper_left.X - (button_size * 1.25 * m_buttons.size())
+					- (button_size * 0.25);
 			x_start = x_end - button_size;
 		}
 
-		current_button = rect<s32>(
-				x_start, m_upper_left.Y, x_end, m_lower_right.Y);
+		current_button = rect<s32>(x_start, m_upper_left.Y, x_end,
+				m_lower_right.Y);
 	} else {
 		double y_start = 0;
 		double y_end = 0;
 
 		if (m_dir == AHBB_Dir_Top_Bottom) {
-			y_start = m_lower_right.X +
-				  (button_size * 1.25 * m_buttons.size()) +
-				  (button_size * 0.25);
+			y_start = m_lower_right.X + (button_size * 1.25 * m_buttons.size())
+					+ (button_size * 0.25);
 			y_end = y_start + button_size;
 		} else {
-			y_end = m_upper_left.X - (button_size * 1.25 * m_buttons.size()) -
-				(button_size * 0.25);
+			y_end = m_upper_left.X - (button_size * 1.25 * m_buttons.size())
+					- (button_size * 0.25);
 			y_start = y_end - button_size;
 		}
 
-		current_button = rect<s32>(
-				m_upper_left.X, y_start, m_lower_right.Y, y_end);
+		current_button = rect<s32>(m_upper_left.X, y_start,
+				m_lower_right.Y, y_end);
 	}
 
-	auto *btn = new button_info();
-	btn->guibutton = m_guienv->addButton(
-			current_button, nullptr, button_id, caption, nullptr);
+	auto *btn              = new button_info();
+	btn->guibutton         = m_guienv->addButton(current_button,
+					nullptr, button_id, caption, nullptr);
 	btn->guibutton->grab();
 	btn->guibutton->setVisible(false);
 	btn->guibutton->setEnabled(false);
-	btn->repeatcounter = -1;
-	btn->keycode = id2keycode(button_id);
+	btn->repeatcounter     = -1;
+	btn->keycode           = id2keycode(button_id);
 	btn->immediate_release = true;
 	btn->ids.clear();
 
-	load_button_texture(btn, btn_image, current_button, m_texturesource, m_driver);
+	load_button_texture(btn, btn_image, current_button, m_texturesource,
+			m_driver);
 
 	m_buttons.push_back(btn);
 }
 
 void AutoHideButtonBar::addToggleButton(touch_gui_button_id button_id,
-		const wchar_t *caption, const char *btn_image_1, const char *btn_image_2)
+		const wchar_t *caption, const char *btn_image_1,
+		const char *btn_image_2)
 {
 	addButton(button_id, caption, btn_image_1);
 	button_info *btn = m_buttons.back();
@@ -285,11 +291,11 @@ bool AutoHideButtonBar::isButton(const SEvent &event)
 
 				auto *translated = new SEvent();
 				memset(translated, 0, sizeof(SEvent));
-				translated->EventType = irr::EET_KEY_INPUT_EVENT;
-				translated->KeyInput.Key = (*iter)->keycode;
-				translated->KeyInput.Control = false;
-				translated->KeyInput.Shift = false;
-				translated->KeyInput.Char = 0;
+				translated->EventType            = irr::EET_KEY_INPUT_EVENT;
+				translated->KeyInput.Key         = (*iter)->keycode;
+				translated->KeyInput.Control     = false;
+				translated->KeyInput.Shift       = false;
+				translated->KeyInput.Char        = 0;
 
 				// add this event
 				translated->KeyInput.PressedDown = true;
@@ -308,14 +314,12 @@ bool AutoHideButtonBar::isButton(const SEvent &event)
 				if ((*iter)->togglable == 1) {
 					(*iter)->togglable = 2;
 					load_button_texture(*iter, (*iter)->textures[1],
-							(*iter)->guibutton
-									->getRelativePosition(),
+							(*iter)->guibutton->getRelativePosition(),
 							m_texturesource, m_driver);
 				} else if ((*iter)->togglable == 2) {
 					(*iter)->togglable = 1;
 					load_button_texture(*iter, (*iter)->textures[0],
-							(*iter)->guibutton
-									->getRelativePosition(),
+							(*iter)->guibutton->getRelativePosition(),
 							m_texturesource, m_driver);
 				}
 
@@ -406,41 +410,42 @@ void AutoHideButtonBar::show()
 	}
 }
 
-TouchScreenGUI::TouchScreenGUI(IrrlichtDevice *device, IEventReceiver *receiver) :
-		m_device(device), m_guienv(device->getGUIEnvironment()),
-		m_receiver(receiver), m_settingsbar(device, receiver),
-		m_rarecontrolsbar(device, receiver)
+TouchScreenGUI::TouchScreenGUI(IrrlichtDevice *device, IEventReceiver *receiver):
+	m_device(device),
+	m_guienv(device->getGUIEnvironment()),
+	m_receiver(receiver),
+	m_settingsbar(device, receiver),
+	m_rarecontrolsbar(device, receiver)
 {
 	for (auto &button : m_buttons) {
-		button.guibutton = nullptr;
+		button.guibutton     = nullptr;
 		button.repeatcounter = -1;
-		button.repeatdelay = BUTTON_REPEAT_DELAY;
+		button.repeatdelay   = BUTTON_REPEAT_DELAY;
 	}
 
 	m_touchscreen_threshold = g_settings->getU16("touchscreen_threshold");
 	m_fixed_joystick = g_settings->getBool("fixed_virtual_joystick");
-	m_joystick_triggers_special1 =
-			g_settings->getBool("virtual_joystick_triggers_aux");
+	m_joystick_triggers_special1 = g_settings->getBool("virtual_joystick_triggers_aux");
 	m_screensize = m_device->getVideoDriver()->getScreenSize();
 	button_size = MYMIN(m_screensize.Y / 4.5f,
 			porting::getDisplayDensity() *
-					g_settings->getFloat("hud_scaling") * 65.0f);
+			g_settings->getFloat("hud_scaling") * 65.0f);
 }
 
 void TouchScreenGUI::initButton(touch_gui_button_id id, const rect<s32> &button_rect,
 		const std::wstring &caption, bool immediate_release, float repeat_delay)
 {
-	button_info *btn = &m_buttons[id];
-	btn->guibutton = m_guienv->addButton(button_rect, nullptr, id, caption.c_str());
+	button_info *btn       = &m_buttons[id];
+	btn->guibutton         = m_guienv->addButton(button_rect, nullptr, id, caption.c_str());
 	btn->guibutton->grab();
-	btn->repeatcounter = -1;
-	btn->repeatdelay = repeat_delay;
-	btn->keycode = id2keycode(id);
+	btn->repeatcounter     = -1;
+	btn->repeatdelay       = repeat_delay;
+	btn->keycode           = id2keycode(id);
 	btn->immediate_release = immediate_release;
 	btn->ids.clear();
 
-	load_button_texture(btn, button_imagenames[id], button_rect, m_texturesource,
-			m_device->getVideoDriver());
+	load_button_texture(btn, button_imagenames[id], button_rect,
+			m_texturesource, m_device->getVideoDriver());
 }
 
 button_info *TouchScreenGUI::initJoystickButton(touch_gui_button_id id,
@@ -452,8 +457,8 @@ button_info *TouchScreenGUI::initJoystickButton(touch_gui_button_id id,
 	btn->guibutton->grab();
 	btn->ids.clear();
 
-	load_button_texture(btn, joystick_imagenames[texture_id], button_rect,
-			m_texturesource, m_device->getVideoDriver());
+	load_button_texture(btn, joystick_imagenames[texture_id],
+			button_rect, m_texturesource, m_device->getVideoDriver());
 
 	return btn;
 }
@@ -462,7 +467,7 @@ void TouchScreenGUI::init(ISimpleTextureSource *tsrc)
 {
 	assert(tsrc);
 
-	m_visible = true;
+	m_visible       = true;
 	m_texturesource = tsrc;
 
 	/* Init joystick display "button"
@@ -470,21 +475,23 @@ void TouchScreenGUI::init(ISimpleTextureSource *tsrc)
 	 */
 	if (m_fixed_joystick) {
 		m_joystick_btn_off = initJoystickButton(joystick_off_id,
-				rect<s32>(button_size, m_screensize.Y - button_size * 4,
+				rect<s32>(button_size,
+						m_screensize.Y - button_size * 4,
 						button_size * 4,
-						m_screensize.Y - button_size),
-				0);
+						m_screensize.Y - button_size), 0);
 	} else {
 		m_joystick_btn_off = initJoystickButton(joystick_off_id,
-				rect<s32>(button_size, m_screensize.Y - button_size * 3,
+				rect<s32>(button_size,
+						m_screensize.Y - button_size * 3,
 						button_size * 3,
-						m_screensize.Y - button_size),
-				0);
+						m_screensize.Y - button_size), 0);
 	}
 
 	m_joystick_btn_bg = initJoystickButton(joystick_bg_id,
-			rect<s32>(button_size, m_screensize.Y - button_size * 4,
-					button_size * 4, m_screensize.Y - button_size),
+			rect<s32>(button_size,
+					m_screensize.Y - button_size * 4,
+					button_size * 4,
+					m_screensize.Y - button_size),
 			1, false);
 
 	m_joystick_btn_center = initJoystickButton(joystick_center_id,
@@ -524,48 +531,39 @@ void TouchScreenGUI::init(ISimpleTextureSource *tsrc)
 				L"spc1", false);
 
 	m_settingsbar.init(m_texturesource, "gear_icon.png", settings_starter_id,
-			v2s32(m_screensize.X - (1.25 * button_size),
-					m_screensize.Y -
-							((SETTINGS_BAR_Y_OFFSET + 1.0) *
-									button_size) +
-							(0.5 * button_size)),
-			v2s32(m_screensize.X - (0.25 * button_size),
-					m_screensize.Y -
-							(SETTINGS_BAR_Y_OFFSET *
-									button_size) +
-							(0.5 * button_size)),
-			AHBB_Dir_Right_Left, 3.0);
-
-	m_settingsbar.addButton(fly_id, L"fly", "fly_btn.png");
-	m_settingsbar.addButton(noclip_id, L"noclip", "noclip_btn.png");
-	m_settingsbar.addButton(fast_id, L"fast", "fast_btn.png");
-	m_settingsbar.addButton(debug_id, L"debug", "debug_btn.png");
-	m_settingsbar.addButton(camera_id, L"camera", "camera_btn.png");
-	m_settingsbar.addButton(range_id, L"rangeview", "rangeview_btn.png");
-	m_settingsbar.addButton(minimap_id, L"minimap", "minimap_btn.png");
+		v2s32(m_screensize.X - (1.25 * button_size),
+			m_screensize.Y - ((SETTINGS_BAR_Y_OFFSET + 1.0) * button_size)
+				+ (0.5 * button_size)),
+		v2s32(m_screensize.X - (0.25 * button_size),
+			m_screensize.Y - (SETTINGS_BAR_Y_OFFSET * button_size)
+				+ (0.5 * button_size)),
+		AHBB_Dir_Right_Left, 3.0);
+
+	m_settingsbar.addButton(fly_id,     L"fly",       "fly_btn.png");
+	m_settingsbar.addButton(noclip_id,  L"noclip",    "noclip_btn.png");
+	m_settingsbar.addButton(fast_id,    L"fast",      "fast_btn.png");
+	m_settingsbar.addButton(debug_id,   L"debug",     "debug_btn.png");
+	m_settingsbar.addButton(camera_id,  L"camera",    "camera_btn.png");
+	m_settingsbar.addButton(range_id,   L"rangeview", "rangeview_btn.png");
+	m_settingsbar.addButton(minimap_id, L"minimap",   "minimap_btn.png");
 
 	// Chat is shown by default, so chat_hide_btn.png is shown first.
-	m_settingsbar.addToggleButton(toggle_chat_id, L"togglechat", "chat_hide_btn.png",
-			"chat_show_btn.png");
+	m_settingsbar.addToggleButton(toggle_chat_id, L"togglechat",
+			"chat_hide_btn.png", "chat_show_btn.png");
 
 	m_rarecontrolsbar.init(m_texturesource, "rare_controls.png",
-			rare_controls_starter_id,
-			v2s32(0.25 * button_size,
-					m_screensize.Y -
-							((RARE_CONTROLS_BAR_Y_OFFSET +
-									 1.0) *
-									button_size) +
-							(0.5 * button_size)),
-			v2s32(0.75 * button_size,
-					m_screensize.Y -
-							(RARE_CONTROLS_BAR_Y_OFFSET *
-									button_size) +
-							(0.5 * button_size)),
-			AHBB_Dir_Left_Right, 2.0);
-
-	m_rarecontrolsbar.addButton(chat_id, L"Chat", "chat_btn.png");
-	m_rarecontrolsbar.addButton(inventory_id, L"inv", "inventory_btn.png");
-	m_rarecontrolsbar.addButton(drop_id, L"drop", "drop_btn.png");
+		rare_controls_starter_id,
+		v2s32(0.25 * button_size,
+			m_screensize.Y - ((RARE_CONTROLS_BAR_Y_OFFSET + 1.0) * button_size)
+				+ (0.5 * button_size)),
+		v2s32(0.75 * button_size,
+			m_screensize.Y - (RARE_CONTROLS_BAR_Y_OFFSET * button_size)
+				+ (0.5 * button_size)),
+		AHBB_Dir_Left_Right, 2.0);
+
+	m_rarecontrolsbar.addButton(chat_id,      L"Chat", "chat_btn.png");
+	m_rarecontrolsbar.addButton(inventory_id, L"inv",  "inventory_btn.png");
+	m_rarecontrolsbar.addButton(drop_id,      L"drop", "drop_btn.png");
 }
 
 touch_gui_button_id TouchScreenGUI::getButtonID(s32 x, s32 y)
@@ -573,13 +571,13 @@ touch_gui_button_id TouchScreenGUI::getButtonID(s32 x, s32 y)
 	IGUIElement *rootguielement = m_guienv->getRootGUIElement();
 
 	if (rootguielement != nullptr) {
-		gui::IGUIElement *element = rootguielement->getElementFromPoint(
-				core::position2d<s32>(x, y));
+		gui::IGUIElement *element =
+				rootguielement->getElementFromPoint(core::position2d<s32>(x, y));
 
 		if (element)
 			for (unsigned int i = 0; i < after_last_element_id; i++)
 				if (element == m_buttons[i].guibutton)
-					return (touch_gui_button_id)i;
+					return (touch_gui_button_id) i;
 	}
 
 	return after_last_element_id;
@@ -593,7 +591,7 @@ touch_gui_button_id TouchScreenGUI::getButtonID(size_t eventID)
 		auto id = std::find(btn->ids.begin(), btn->ids.end(), eventID);
 
 		if (id != btn->ids.end())
-			return (touch_gui_button_id)i;
+			return (touch_gui_button_id) i;
 	}
 
 	return after_last_element_id;
@@ -603,18 +601,17 @@ bool TouchScreenGUI::isHUDButton(const SEvent &event)
 {
 	// check if hud item is pressed
 	for (auto &hud_rect : m_hud_rects) {
-		if (hud_rect.second.isPointInside(
-				    v2s32(event.TouchInput.X, event.TouchInput.Y))) {
+		if (hud_rect.second.isPointInside(v2s32(event.TouchInput.X,
+				event.TouchInput.Y))) {
 			auto *translated = new SEvent();
 			memset(translated, 0, sizeof(SEvent));
 			translated->EventType = irr::EET_KEY_INPUT_EVENT;
-			translated->KeyInput.Key =
-					(irr::EKEY_CODE)(KEY_KEY_1 + hud_rect.first);
-			translated->KeyInput.Control = false;
-			translated->KeyInput.Shift = false;
+			translated->KeyInput.Key         = (irr::EKEY_CODE) (KEY_KEY_1 + hud_rect.first);
+			translated->KeyInput.Control     = false;
+			translated->KeyInput.Shift       = false;
 			translated->KeyInput.PressedDown = true;
 			m_receiver->OnEvent(*translated);
-			m_hud_ids[event.TouchInput.ID] = translated->KeyInput.Key;
+			m_hud_ids[event.TouchInput.ID]   = translated->KeyInput.Key;
 			delete translated;
 			return true;
 		}
@@ -622,27 +619,25 @@ bool TouchScreenGUI::isHUDButton(const SEvent &event)
 	return false;
 }
 
-void TouchScreenGUI::handleButtonEvent(
-		touch_gui_button_id button, size_t eventID, bool action)
+void TouchScreenGUI::handleButtonEvent(touch_gui_button_id button,
+		size_t eventID, bool action)
 {
 	button_info *btn = &m_buttons[button];
 	auto *translated = new SEvent();
 	memset(translated, 0, sizeof(SEvent));
-	translated->EventType = irr::EET_KEY_INPUT_EVENT;
-	translated->KeyInput.Key = btn->keycode;
-	translated->KeyInput.Control = false;
-	translated->KeyInput.Shift = false;
-	translated->KeyInput.Char = 0;
+	translated->EventType            = irr::EET_KEY_INPUT_EVENT;
+	translated->KeyInput.Key         = btn->keycode;
+	translated->KeyInput.Control     = false;
+	translated->KeyInput.Shift       = false;
+	translated->KeyInput.Char        = 0;
 
 	// add this event
 	if (action) {
-		assert(std::find(btn->ids.begin(), btn->ids.end(), eventID) ==
-				btn->ids.end());
+		assert(std::find(btn->ids.begin(), btn->ids.end(), eventID) == btn->ids.end());
 
 		btn->ids.push_back(eventID);
 
-		if (btn->ids.size() > 1)
-			return;
+		if (btn->ids.size() > 1) return;
 
 		btn->repeatcounter = 0;
 		translated->KeyInput.PressedDown = true;
@@ -661,7 +656,7 @@ void TouchScreenGUI::handleButtonEvent(
 			return;
 
 		translated->KeyInput.PressedDown = false;
-		btn->repeatcounter = -1;
+		btn->repeatcounter               = -1;
 		m_receiver->OnEvent(*translated);
 	}
 	delete translated;
@@ -671,6 +666,7 @@ void TouchScreenGUI::handleReleaseEvent(size_t evt_id)
 {
 	touch_gui_button_id button = getButtonID(evt_id);
 
+
 	if (button != after_last_element_id) {
 		// handle button events
 		handleButtonEvent(button, evt_id, false);
@@ -682,13 +678,13 @@ void TouchScreenGUI::handleReleaseEvent(size_t evt_id)
 		if (m_move_sent_as_mouse_event) {
 			auto *translated = new SEvent;
 			memset(translated, 0, sizeof(SEvent));
-			translated->EventType = EET_MOUSE_INPUT_EVENT;
-			translated->MouseInput.X = m_move_downlocation.X;
-			translated->MouseInput.Y = m_move_downlocation.Y;
-			translated->MouseInput.Shift = false;
-			translated->MouseInput.Control = false;
+			translated->EventType               = EET_MOUSE_INPUT_EVENT;
+			translated->MouseInput.X            = m_move_downlocation.X;
+			translated->MouseInput.Y            = m_move_downlocation.Y;
+			translated->MouseInput.Shift        = false;
+			translated->MouseInput.Control      = false;
 			translated->MouseInput.ButtonStates = 0;
-			translated->MouseInput.Event = EMIE_LMOUSE_LEFT_UP;
+			translated->MouseInput.Event        = EMIE_LMOUSE_LEFT_UP;
 			m_receiver->OnEvent(*translated);
 			delete translated;
 		} else {
@@ -710,11 +706,13 @@ void TouchScreenGUI::handleReleaseEvent(size_t evt_id)
 		m_joystick_btn_bg->guibutton->setVisible(false);
 		m_joystick_btn_center->guibutton->setVisible(false);
 	} else {
-		infostream << "TouchScreenGUI::translateEvent released unknown button: "
-			   << evt_id << std::endl;
+		infostream
+			<< "TouchScreenGUI::translateEvent released unknown button: "
+			<< evt_id << std::endl;
 	}
 
-	for (auto iter = m_known_ids.begin(); iter != m_known_ids.end(); ++iter) {
+	for (auto iter = m_known_ids.begin();
+			iter != m_known_ids.end(); ++iter) {
 		if (iter->id == evt_id) {
 			m_known_ids.erase(iter);
 			break;
@@ -725,8 +723,9 @@ void TouchScreenGUI::handleReleaseEvent(size_t evt_id)
 void TouchScreenGUI::translateEvent(const SEvent &event)
 {
 	if (!m_visible) {
-		infostream << "TouchScreenGUI::translateEvent got event but not visible!"
-			   << std::endl;
+		infostream
+			<< "TouchScreenGUI::translateEvent got event but not visible!"
+			<< std::endl;
 		return;
 	}
 
@@ -741,8 +740,8 @@ void TouchScreenGUI::translateEvent(const SEvent &event)
 		 */
 		id_status toadd{};
 		toadd.id = event.TouchInput.ID;
-		toadd.X = event.TouchInput.X;
-		toadd.Y = event.TouchInput.Y;
+		toadd.X  = event.TouchInput.X;
+		toadd.Y  = event.TouchInput.Y;
 		m_known_ids.push_back(toadd);
 
 		size_t eventID = event.TouchInput.ID;
@@ -771,67 +770,49 @@ void TouchScreenGUI::translateEvent(const SEvent &event)
 			m_rarecontrolsbar.deactivate();
 
 			s32 dxj = event.TouchInput.X - button_size * 5.0f / 2.0f;
-			s32 dyj = event.TouchInput.Y - m_screensize.Y +
-				  button_size * 5.0f / 2.0f;
+			s32 dyj = event.TouchInput.Y - m_screensize.Y + button_size * 5.0f / 2.0f;
 
 			/* Select joystick when left 1/3 of screen dragged or
 			 * when joystick tapped (fixed joystick position)
 			 */
-			if ((m_fixed_joystick &&
-					    dxj * dxj + dyj * dyj <=
-							    button_size * button_size *
-									    1.5 * 1.5) ||
-					(!m_fixed_joystick &&
-							event.TouchInput.X <
-									m_screensize.X /
-											3.0f)) {
-				// If we don't already have a starting point for joystick
-				// make this the one.
+			if ((m_fixed_joystick && dxj * dxj + dyj * dyj <= button_size * button_size * 1.5 * 1.5) ||
+					(!m_fixed_joystick && event.TouchInput.X < m_screensize.X / 3.0f)) {
+				// If we don't already have a starting point for joystick make this the one.
 				if (m_joystick_id == -1) {
-					m_joystick_id = event.TouchInput.ID;
+					m_joystick_id               = event.TouchInput.ID;
 					m_joystick_has_really_moved = false;
 
 					m_joystick_btn_off->guibutton->setVisible(false);
 					m_joystick_btn_bg->guibutton->setVisible(true);
-					m_joystick_btn_center->guibutton->setVisible(
-							true);
+					m_joystick_btn_center->guibutton->setVisible(true);
 
-					// If it's a fixed joystick, don't move the
-					// joystick "button".
+					// If it's a fixed joystick, don't move the joystick "button".
 					if (!m_fixed_joystick)
 						m_joystick_btn_bg->guibutton->setRelativePosition(v2s32(
-								event.TouchInput.X -
-										button_size * 3.0f /
-												2.0f,
-								event.TouchInput.Y -
-										button_size * 3.0f /
-												2.0f));
+								event.TouchInput.X - button_size * 3.0f / 2.0f,
+								event.TouchInput.Y - button_size * 3.0f / 2.0f));
 
 					m_joystick_btn_center->guibutton->setRelativePosition(v2s32(
-							event.TouchInput.X -
-									button_size / 2.0f,
-							event.TouchInput.Y -
-									button_size / 2.0f));
+							event.TouchInput.X - button_size / 2.0f,
+							event.TouchInput.Y - button_size / 2.0f));
 				}
 			} else {
-				// If we don't already have a moving point make this the
-				// moving one.
+				// If we don't already have a moving point make this the moving one.
 				if (m_move_id == -1) {
-					m_move_id = event.TouchInput.ID;
-					m_move_has_really_moved = false;
-					m_move_downtime = porting::getTimeMs();
-					m_move_downlocation = v2s32(event.TouchInput.X,
-							event.TouchInput.Y);
+					m_move_id                  = event.TouchInput.ID;
+					m_move_has_really_moved    = false;
+					m_move_downtime            = porting::getTimeMs();
+					m_move_downlocation        = v2s32(event.TouchInput.X, event.TouchInput.Y);
 					m_move_sent_as_mouse_event = false;
 				}
 			}
 		}
 
-		m_pointerpos[event.TouchInput.ID] =
-				v2s32(event.TouchInput.X, event.TouchInput.Y);
-	} else if (event.TouchInput.Event == ETIE_LEFT_UP) {
-		verbosestream << "Up event for pointerid: " << event.TouchInput.ID
-			      << std::endl;
+		m_pointerpos[event.TouchInput.ID] = v2s32(event.TouchInput.X, event.TouchInput.Y);
+	}
+	else if (event.TouchInput.Event == ETIE_LEFT_UP) {
+		verbosestream
+			<< "Up event for pointerid: " << event.TouchInput.ID << std::endl;
 		handleReleaseEvent(event.TouchInput.ID);
 	} else {
 		assert(event.TouchInput.Event == ETIE_MOVED);
@@ -842,19 +823,13 @@ void TouchScreenGUI::translateEvent(const SEvent &event)
 
 		if (m_move_id != -1) {
 			if ((event.TouchInput.ID == m_move_id) &&
-					(!m_move_sent_as_mouse_event)) {
+				(!m_move_sent_as_mouse_event)) {
 
 				double distance = sqrt(
-						(m_pointerpos[event.TouchInput.ID].X -
-								event.TouchInput.X) *
-								(m_pointerpos[event.TouchInput.ID]
-												.X -
-										event.TouchInput.X) +
-						(m_pointerpos[event.TouchInput.ID].Y -
-								event.TouchInput.Y) *
-								(m_pointerpos[event.TouchInput.ID]
-												.Y -
-										event.TouchInput.Y));
+						(m_pointerpos[event.TouchInput.ID].X - event.TouchInput.X) *
+						(m_pointerpos[event.TouchInput.ID].X - event.TouchInput.X) +
+						(m_pointerpos[event.TouchInput.ID].Y - event.TouchInput.Y) *
+						(m_pointerpos[event.TouchInput.ID].Y - event.TouchInput.Y));
 
 				if ((distance > m_touchscreen_threshold) ||
 						(m_move_has_really_moved)) {
@@ -867,31 +842,25 @@ void TouchScreenGUI::translateEvent(const SEvent &event)
 					s32 dy = Y - m_pointerpos[event.TouchInput.ID].Y;
 
 					// adapt to similar behaviour as pc screen
-					double d = g_settings->getFloat(
-								   "mouse_sensitivity") *
-						   3.0f;
+					double d = g_settings->getFloat("mouse_sensitivity") * 3.0f;
 
 					m_camera_yaw_change -= dx * d;
-					m_camera_pitch = MYMIN(
-							MYMAX(m_camera_pitch + (dy * d),
-									-180),
-							180);
+					m_camera_pitch = MYMIN(MYMAX(m_camera_pitch + (dy * d), -180), 180);
 
 					// update shootline
-					m_shootline = m_device->getSceneManager()
-								      ->getSceneCollisionManager()
-								      ->getRayFromScreenCoordinates(v2s32(
-										      X,
-										      Y));
+					m_shootline = m_device
+							->getSceneManager()
+							->getSceneCollisionManager()
+							->getRayFromScreenCoordinates(v2s32(X, Y));
 					m_pointerpos[event.TouchInput.ID] = v2s32(X, Y);
 				}
 			} else if ((event.TouchInput.ID == m_move_id) &&
 					(m_move_sent_as_mouse_event)) {
-				m_shootline = m_device->getSceneManager()
-							      ->getSceneCollisionManager()
-							      ->getRayFromScreenCoordinates(v2s32(
-									      event.TouchInput.X,
-									      event.TouchInput.Y));
+				m_shootline = m_device
+						->getSceneManager()
+						->getSceneCollisionManager()
+						->getRayFromScreenCoordinates(
+								v2s32(event.TouchInput.X, event.TouchInput.Y));
 			}
 		}
 
@@ -909,17 +878,13 @@ void TouchScreenGUI::translateEvent(const SEvent &event)
 			double distance_sq = dx * dx + dy * dy;
 
 			s32 dxj = event.TouchInput.X - button_size * 5.0f / 2.0f;
-			s32 dyj = event.TouchInput.Y - m_screensize.Y +
-				  button_size * 5.0f / 2.0f;
-			bool inside_joystick = (dxj * dxj + dyj * dyj <=
-						button_size * button_size * 1.5 * 1.5);
+			s32 dyj = event.TouchInput.Y - m_screensize.Y + button_size * 5.0f / 2.0f;
+			bool inside_joystick = (dxj * dxj + dyj * dyj <= button_size * button_size * 1.5 * 1.5);
 
 			if (m_joystick_has_really_moved ||
-					(!m_joystick_has_really_moved &&
-							inside_joystick) ||
+					(!m_joystick_has_really_moved && inside_joystick) ||
 					(!m_fixed_joystick &&
-							distance_sq > m_touchscreen_threshold *
-											m_touchscreen_threshold)) {
+					distance_sq > m_touchscreen_threshold * m_touchscreen_threshold)) {
 				m_joystick_has_really_moved = true;
 				double distance = sqrt(distance_sq);
 
@@ -931,7 +896,7 @@ void TouchScreenGUI::translateEvent(const SEvent &event)
 				angle = fmod(angle + 180 + 22.5, 360);
 
 				// reset state before applying
-				for (bool &joystick_status : m_joystick_status)
+				for (bool & joystick_status : m_joystick_status)
 					joystick_status = false;
 
 				if (distance <= m_touchscreen_threshold) {
@@ -961,31 +926,20 @@ void TouchScreenGUI::translateEvent(const SEvent &event)
 				if (distance > button_size) {
 					m_joystick_status[j_special1] = true;
 					// move joystick "button"
-					s32 ndx = button_size * dx / distance -
-						  button_size / 2.0f;
-					s32 ndy = button_size * dy / distance -
-						  button_size / 2.0f;
+					s32 ndx = button_size * dx / distance - button_size / 2.0f;
+					s32 ndy = button_size * dy / distance - button_size / 2.0f;
 					if (m_fixed_joystick) {
 						m_joystick_btn_center->guibutton->setRelativePosition(v2s32(
-								button_size * 5 / 2 + ndx,
-								m_screensize.Y -
-										button_size * 5 /
-												2 +
-										ndy));
+							button_size * 5 / 2 + ndx,
+							m_screensize.Y - button_size * 5 / 2 + ndy));
 					} else {
 						m_joystick_btn_center->guibutton->setRelativePosition(v2s32(
-								m_pointerpos[event.TouchInput.ID]
-												.X +
-										ndx,
-								m_pointerpos[event.TouchInput.ID]
-												.Y +
-										ndy));
+							m_pointerpos[event.TouchInput.ID].X + ndx,
+							m_pointerpos[event.TouchInput.ID].Y + ndy));
 					}
 				} else {
-					m_joystick_btn_center->guibutton
-							->setRelativePosition(v2s32(
-									X - button_size / 2,
-									Y - button_size / 2));
+					m_joystick_btn_center->guibutton->setRelativePosition(
+							v2s32(X - button_size / 2, Y - button_size / 2));
 				}
 			}
 		}
@@ -1001,23 +955,22 @@ void TouchScreenGUI::handleChangedButton(const SEvent &event)
 		if (m_buttons[i].ids.empty())
 			continue;
 
-		for (auto iter = m_buttons[i].ids.begin(); iter != m_buttons[i].ids.end();
-				++iter) {
+		for (auto iter = m_buttons[i].ids.begin();
+				iter != m_buttons[i].ids.end(); ++iter) {
 			if (event.TouchInput.ID == *iter) {
-				int current_button_id = getButtonID(
-						event.TouchInput.X, event.TouchInput.Y);
+				int current_button_id =
+						getButtonID(event.TouchInput.X, event.TouchInput.Y);
 
 				if (current_button_id == i)
 					continue;
 
 				// remove old button
-				handleButtonEvent((touch_gui_button_id)i, *iter, false);
+				handleButtonEvent((touch_gui_button_id) i, *iter, false);
 
 				if (current_button_id == after_last_element_id)
 					return;
 
-				handleButtonEvent((touch_gui_button_id)current_button_id,
-						*iter, true);
+				handleButtonEvent((touch_gui_button_id) current_button_id, *iter, true);
 				return;
 			}
 		}
@@ -1029,48 +982,48 @@ void TouchScreenGUI::handleChangedButton(const SEvent &event)
 		return;
 
 	button_info *btn = &m_buttons[current_button_id];
-	if (std::find(btn->ids.begin(), btn->ids.end(), event.TouchInput.ID) ==
-			btn->ids.end())
-		handleButtonEvent((touch_gui_button_id)current_button_id,
+	if (std::find(btn->ids.begin(), btn->ids.end(), event.TouchInput.ID)
+			== btn->ids.end())
+		handleButtonEvent((touch_gui_button_id) current_button_id,
 				event.TouchInput.ID, true);
 }
 
 bool TouchScreenGUI::doubleTapDetection()
 {
 	m_key_events[0].down_time = m_key_events[1].down_time;
-	m_key_events[0].x = m_key_events[1].x;
-	m_key_events[0].y = m_key_events[1].y;
+	m_key_events[0].x         = m_key_events[1].x;
+	m_key_events[0].y         = m_key_events[1].y;
 	m_key_events[1].down_time = m_move_downtime;
-	m_key_events[1].x = m_move_downlocation.X;
-	m_key_events[1].y = m_move_downlocation.Y;
+	m_key_events[1].x         = m_move_downlocation.X;
+	m_key_events[1].y         = m_move_downlocation.Y;
 
 	u64 delta = porting::getDeltaMs(m_key_events[0].down_time, porting::getTimeMs());
 	if (delta > 400)
 		return false;
 
-	double distance = sqrt((m_key_events[0].x - m_key_events[1].x) *
-					       (m_key_events[0].x - m_key_events[1].x) +
-			       (m_key_events[0].y - m_key_events[1].y) *
-					       (m_key_events[0].y - m_key_events[1].y));
+	double distance = sqrt(
+			(m_key_events[0].x - m_key_events[1].x) *
+			(m_key_events[0].x - m_key_events[1].x) +
+			(m_key_events[0].y - m_key_events[1].y) *
+			(m_key_events[0].y - m_key_events[1].y));
 
 	if (distance > (20 + m_touchscreen_threshold))
 		return false;
 
 	auto *translated = new SEvent();
 	memset(translated, 0, sizeof(SEvent));
-	translated->EventType = EET_MOUSE_INPUT_EVENT;
-	translated->MouseInput.X = m_key_events[0].x;
-	translated->MouseInput.Y = m_key_events[0].y;
-	translated->MouseInput.Shift = false;
-	translated->MouseInput.Control = false;
+	translated->EventType               = EET_MOUSE_INPUT_EVENT;
+	translated->MouseInput.X            = m_key_events[0].x;
+	translated->MouseInput.Y            = m_key_events[0].y;
+	translated->MouseInput.Shift        = false;
+	translated->MouseInput.Control      = false;
 	translated->MouseInput.ButtonStates = EMBSM_RIGHT;
 
 	// update shootline
-	m_shootline = m_device->getSceneManager()
-				      ->getSceneCollisionManager()
-				      ->getRayFromScreenCoordinates(
-						      v2s32(m_key_events[0].x,
-								      m_key_events[0].y));
+	m_shootline = m_device
+			->getSceneManager()
+			->getSceneCollisionManager()
+			->getRayFromScreenCoordinates(v2s32(m_key_events[0].x, m_key_events[0].y));
 
 	translated->MouseInput.Event = EMIE_RMOUSE_PRESSED_DOWN;
 	verbosestream << "TouchScreenGUI::translateEvent right click press" << std::endl;
@@ -1078,8 +1031,7 @@ bool TouchScreenGUI::doubleTapDetection()
 
 	translated->MouseInput.ButtonStates = 0;
 	translated->MouseInput.Event = EMIE_RMOUSE_LEFT_UP;
-	verbosestream << "TouchScreenGUI::translateEvent right click release"
-		      << std::endl;
+	verbosestream << "TouchScreenGUI::translateEvent right click release" << std::endl;
 	m_receiver->OnEvent(*translated);
 	delete translated;
 	return true;
@@ -1092,8 +1044,8 @@ void TouchScreenGUI::applyJoystickStatus()
 			continue;
 
 		SEvent translated{};
-		translated.EventType = irr::EET_KEY_INPUT_EVENT;
-		translated.KeyInput.Key = id2keycode(m_joystick_names[i]);
+		translated.EventType            = irr::EET_KEY_INPUT_EVENT;
+		translated.KeyInput.Key         = id2keycode(m_joystick_names[i]);
 		translated.KeyInput.PressedDown = false;
 		m_receiver->OnEvent(translated);
 
@@ -1143,11 +1095,11 @@ void TouchScreenGUI::step(float dtime)
 			if (button.repeatcounter < button.repeatdelay)
 				continue;
 
-			button.repeatcounter = 0;
+			button.repeatcounter            = 0;
 			SEvent translated;
 			memset(&translated, 0, sizeof(SEvent));
-			translated.EventType = irr::EET_KEY_INPUT_EVENT;
-			translated.KeyInput.Key = button.keycode;
+			translated.EventType            = irr::EET_KEY_INPUT_EVENT;
+			translated.KeyInput.Key         = button.keycode;
 			translated.KeyInput.PressedDown = false;
 			m_receiver->OnEvent(translated);
 
@@ -1165,33 +1117,31 @@ void TouchScreenGUI::step(float dtime)
 	}
 
 	// if a new placed pointer isn't moved for some time start digging
-	if ((m_move_id != -1) && (!m_move_has_really_moved) &&
+	if ((m_move_id != -1) &&
+			(!m_move_has_really_moved) &&
 			(!m_move_sent_as_mouse_event)) {
 
 		u64 delta = porting::getDeltaMs(m_move_downtime, porting::getTimeMs());
 
 		if (delta > MIN_DIG_TIME_MS) {
-			m_shootline = m_device->getSceneManager()
-						      ->getSceneCollisionManager()
-						      ->getRayFromScreenCoordinates(v2s32(
-								      m_move_downlocation
-										      .X,
-								      m_move_downlocation
-										      .Y));
+			m_shootline = m_device
+					->getSceneManager()
+					->getSceneCollisionManager()
+					->getRayFromScreenCoordinates(
+							v2s32(m_move_downlocation.X,m_move_downlocation.Y));
 
 			SEvent translated;
 			memset(&translated, 0, sizeof(SEvent));
-			translated.EventType = EET_MOUSE_INPUT_EVENT;
-			translated.MouseInput.X = m_move_downlocation.X;
-			translated.MouseInput.Y = m_move_downlocation.Y;
-			translated.MouseInput.Shift = false;
-			translated.MouseInput.Control = false;
+			translated.EventType               = EET_MOUSE_INPUT_EVENT;
+			translated.MouseInput.X            = m_move_downlocation.X;
+			translated.MouseInput.Y            = m_move_downlocation.Y;
+			translated.MouseInput.Shift        = false;
+			translated.MouseInput.Control      = false;
 			translated.MouseInput.ButtonStates = EMBSM_LEFT;
-			translated.MouseInput.Event = EMIE_LMOUSE_PRESSED_DOWN;
-			verbosestream << "TouchScreenGUI::step left click press"
-				      << std::endl;
+			translated.MouseInput.Event        = EMIE_LMOUSE_PRESSED_DOWN;
+			verbosestream << "TouchScreenGUI::step left click press" << std::endl;
 			m_receiver->OnEvent(translated);
-			m_move_sent_as_mouse_event = true;
+			m_move_sent_as_mouse_event         = true;
 		}
 	}