diff --git a/Marlin/GuiAction.cpp b/Marlin/GuiAction.cpp
index 979c519423e0..b0689cbf4eec 100644
--- a/Marlin/GuiAction.cpp
+++ b/Marlin/GuiAction.cpp
@@ -44,6 +44,33 @@
 #include "LightManager.h"
 #include "cardreader.h"
 
+#ifdef AUTO_BED_LEVELING_GRID
+	#include "config/hephestos_2/Configuration.h"
+	#include "qr_solve.h"
+	static void set_bed_level_equation_lsq(double *plane_equation_coefficients)
+	{
+    vector_3 planeNormal = vector_3(-plane_equation_coefficients[0], -plane_equation_coefficients[1], 1);
+    planeNormal.debug("planeNormal");
+    plan_bed_level_matrix = matrix_3x3::create_look_at(planeNormal);
+    //bedLevel.debug("bedLevel");
+
+    //plan_bed_level_matrix.debug("bed level before");
+    //vector_3 uncorrected_position = plan_get_position_mm();
+    //uncorrected_position.debug("position before");
+
+    vector_3 corrected_position = plan_get_position();
+//    corrected_position.debug("position after");
+    current_position[X_AXIS] = corrected_position.x;
+    current_position[Y_AXIS] = corrected_position.y;
+    current_position[Z_AXIS] = corrected_position.z;
+
+    // put the bed at 0 so we don't go below it.
+    current_position[Z_AXIS] = zprobe_zoffset; // in the lsq we reach here after raising the extruder due to the loop structure
+
+    plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
+	}
+#endif
+
 #ifdef DOGLCD
 	#include "StatsManager.h"
 	#include "HeatedbedManager.h"
@@ -301,9 +328,9 @@ void action_get_plane()
 	if(HeatedbedManager::single::instance().detected())
 	{
 		temp::TemperatureManager::single::instance().setBedTargetTemperature(0);
+		unsigned long curtime = millis();
 		while(HeatedbedManager::single::instance().detected() && temp::TemperatureManager::single::instance().getBedCurrentTemperature() > BED_AUTOLEVEL_TEMP)
 		{
-			unsigned long curtime = millis();
 			if(( millis() - curtime) > 1000 ) //Print Temp Reading every 1 second while heating up.
 			{
 				float tt=temp::TemperatureManager::single::instance().getCurrentTemperature();
@@ -316,6 +343,8 @@ void action_get_plane()
 				SERIAL_PROTOCOLLN("");
 				curtime = millis();
 			}
+			temp::TemperatureManager::single::instance().manageTemperatureControl();
+			lcd_update();
 		};
 	}
 #endif // HEATER_BED_PIN > -1
@@ -698,6 +727,11 @@ void action_start_print()
 		StatsManager::single::instance().increaseTotalPrints();
 #endif //DOGLCD
 
+
+
+
+
+
 #ifdef FAN_BOX_PIN
 	if(FanManager::single::instance().state() == true)
 	{
@@ -904,6 +938,11 @@ void action_offset()
 	current_position[Z_AXIS] = 0;
 	z_saved_homing = OffsetManager::single::instance().getOffset();
 
+
+	SERIAL_PROTOCOLPGM("actual Offset: ");
+	SERIAL_PROTOCOL(OffsetManager::single::instance().getOffset());
+	SERIAL_PROTOCOLPGM("\n");
+
 	plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
 	setup_for_endstop_move();
 
@@ -951,9 +990,11 @@ void action_offset()
 	{
 		current_position[Z_AXIS] = -(z_saved_homing - z_offset);
 	}
+
 	do_blocking_move_to(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS]);
 
 	current_position[Z_AXIS] = plan_get_axis_position(Z_AXIS);
+
 }
 #endif //LEVEL_SENSOR
 
@@ -987,6 +1028,10 @@ void action_offset_rest()
 void action_save_offset()
 {
 	OffsetManager::single::instance().saveOffset();
+
+	SERIAL_PROTOCOLPGM("actual Offset: ");
+	SERIAL_PROTOCOL(OffsetManager::single::instance().getOffset());
+	SERIAL_PROTOCOLPGM("\n");
 }
 
 void action_wizard_init()
diff --git a/Marlin/HeatedbedManager.cpp b/Marlin/HeatedbedManager.cpp
index 7adeffd247d0..b01c3535ed24 100644
--- a/Marlin/HeatedbedManager.cpp
+++ b/Marlin/HeatedbedManager.cpp
@@ -103,7 +103,7 @@ uint8_t HeatedbedManager::mode()
 {
 	if(m_bed_detected)
 	{
-		uint8_t const num_modes = 3;
+		uint8_t const num_modes = 2;
 		
 		mode((m_mode+1) % num_modes);
 	}
diff --git a/Marlin/Language.h b/Marlin/Language.h
index 47e2f5680213..cca53a82a44d 100644
--- a/Marlin/Language.h
+++ b/Marlin/Language.h
@@ -49,7 +49,7 @@ enum class Language
 	FR,     // French
 	PT,     // Portuguese
 	IT,     // Italian
-	SE,     // Swedish
+	//SE,     // Swedish
 	RU,		// Russian
 	MAX_LANGUAGES
 };
@@ -83,17 +83,19 @@ const char * MSG_##label() \
    { \
       text = IT_##label; \
    } \
-   else if (LANG == Language::SE) \
-   { \
-      text = SE_##label; \
-   } \
-   else if (LANG == Language::RU) \
+      else if (LANG == Language::RU) \
    { \
       text = RU_##label; \
    } \
    return text; \
 }
 
+/*
+else if (LANG == Language::SE) \
+   { \
+      text = SE_##label; \
+   } \
+*/
 enum class Label
 {
 	NONE = 0,
diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp
index 72b7e0fff183..1fd784de5e8c 100644
--- a/Marlin/Marlin_main.cpp
+++ b/Marlin/Marlin_main.cpp
@@ -1281,32 +1281,6 @@ static void do_blocking_extrude_to(float e) {
 	feedrate = oldFeedRate;
 }
 
-#ifdef AUTO_BED_LEVELING_GRID
-static void set_bed_level_equation_lsq(double *plane_equation_coefficients)
-{
-    vector_3 planeNormal = vector_3(-plane_equation_coefficients[0], -plane_equation_coefficients[1], 1);
-    planeNormal.debug("planeNormal");
-    plan_bed_level_matrix = matrix_3x3::create_look_at(planeNormal);
-    //bedLevel.debug("bedLevel");
-
-    //plan_bed_level_matrix.debug("bed level before");
-    //vector_3 uncorrected_position = plan_get_position_mm();
-    //uncorrected_position.debug("position before");
-
-    vector_3 corrected_position = plan_get_position();
-//    corrected_position.debug("position after");
-    current_position[X_AXIS] = corrected_position.x;
-    current_position[Y_AXIS] = corrected_position.y;
-    current_position[Z_AXIS] = corrected_position.z;
-
-    // put the bed at 0 so we don't go below it.
-    current_position[Z_AXIS] = zprobe_zoffset; // in the lsq we reach here after raising the extruder due to the loop structure
-
-    plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
-}
-
-#endif // AUTO_BED_LEVELING_GRID
-
 static void run_z_probe() {
     plan_bed_level_matrix.set_to_identity();
     feedrate = homing_feedrate[Z_AXIS];
@@ -1320,18 +1294,28 @@ static void run_z_probe() {
     zPosition = st_get_position_mm(Z_AXIS);
     plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], zPosition, current_position[E_AXIS]);
 
-    // move up the retract distance
-    zPosition += home_retract_mm(Z_AXIS);
-    plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], zPosition, current_position[E_AXIS], feedrate/60, active_extruder);
-    st_synchronize();
 
-    // move back down slowly to find bed
-    feedrate = homing_slow_feedrate[Z_AXIS];
-    zPosition -= home_retract_mm(Z_AXIS) * 2;
-    plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], zPosition, current_position[E_AXIS], feedrate/60, active_extruder);
-    st_synchronize();
 
-    current_position[Z_AXIS] = st_get_position_mm(Z_AXIS);
+    float zpos=0;
+    for (int8_t prob = 1; prob <= Z_PROBE_REPEAT_SENSOR; prob++)
+    {
+      // move up the retract distance
+      zPosition += home_retract_mm(Z_AXIS);
+      plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], zPosition, current_position[E_AXIS], feedrate/60, active_extruder);
+      st_synchronize();
+
+      // move back down slowly to find bed
+      feedrate = homing_slow_feedrate[Z_AXIS];
+      zPosition -= home_retract_mm(Z_AXIS) * 2;
+      plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], zPosition, current_position[E_AXIS], feedrate/60, active_extruder);
+      st_synchronize();
+
+      zpos = zpos + st_get_position_mm(Z_AXIS);
+
+    }
+
+    current_position[Z_AXIS] = zpos / Z_PROBE_REPEAT_SENSOR;//st_get_position_mm(Z_AXIS); //st_get_position_mm(Z_AXIS);
+
     // make sure the planner knows where we are as it may be a bit different than we last said to move to
     plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
 }
@@ -1857,9 +1841,9 @@ void process_commands()
 	
 		if(HeatedbedManager::single::instance().getMode() == eeprom::HEATEDBED_ON && PrintManager::single::instance().state() != SERIAL_CONTROL)
 		{
-			char cmd[LONG_FILENAME_LENGTH];
-			sprintf_P(cmd, PSTR("M190 S%d"), ABS_PREHEAT_HPB_TEMP);
-			enquecommand(cmd);
+			//char cmd[LONG_FILENAME_LENGTH];               !!!!!!!!!!!!!!!!!!!!!!!AGUS
+			//sprintf_P(cmd, PSTR("M190 S%d"), ABS_PREHEAT_HPB_TEMP);
+			//enquecommand(cmd);
 		}
 	  }
       else if(PrintManager::single::instance().state() == SERIAL_CONTROL && card.isFileAtBegin() == false)
diff --git a/Marlin/TemperatureManager.cpp b/Marlin/TemperatureManager.cpp
index 6e6c8c68e5cd..1061b75d11d6 100644
--- a/Marlin/TemperatureManager.cpp
+++ b/Marlin/TemperatureManager.cpp
@@ -43,6 +43,9 @@
 	#include "ViewManager.h"
 	#include "FanManager.h"
 	#include "HeatedbedManager.h"
+#else
+	#include "Serial.h"
+	#include "ultralcd.h"
 #endif
 
 namespace temp
@@ -59,6 +62,9 @@ namespace temp
 		, m_control()
 #endif // DOGLCD
 		, m_blower_control(true)
+		, m_temp_protection_counter(0)
+		, m_check_temp_protection(false)
+		, m_force_disable_hotend(false)
 	{
 		setTargetTemperature(0);
 		SET_OUTPUT(HEATER_0_PIN);
@@ -237,6 +243,31 @@ namespace temp
 			notify();
 		}
 		fanControl();
+
+		if(m_check_temp_protection)
+		{
+			--m_temp_protection_counter;
+			if(m_temp_protection_counter == 0)
+			{
+				if(temp < THERMISTOR_PROTECTION_MIN_TARGET_TEMP)
+				{
+					setTargetTemperature(0);
+#ifdef DOGLCD
+					lcd_disable_button();
+					ui::ViewManager::getInstance().activeView(ui::screen_error_temperature);
+#else
+					SERIAL_ERROR_START;
+					SERIAL_ERRORLNPGM(MSG_ERR_NO_THERMISTORS);
+					LCD_MESSAGEPGM("thermistor error");
+					m_force_disable_hotend = true;
+#endif // DOGLCD
+				}
+				else
+				{
+					m_check_temp_protection = false;
+				}
+			}
+		}
 	}
 
 	void TemperatureManager::updateCurrentTemperatureRaw(uint16_t temp)
@@ -253,20 +284,37 @@ namespace temp
 	void TemperatureManager::setTargetTemperature(uint16_t target)
 	{
 		m_target_temperature = target;
-	#ifdef DOGLCD
+
 		if(target > HEATER_0_MINTEMP)
 		{
+#ifdef DOGLCD
 			TCCR2A |= 0x20;
+#endif // DOGLCD
+			// enable temperature check if starting temperature
+			// is lower than mintemp
+			if(getCurrentTemperature() < THERMISTOR_PROTECTION_MAX_ENABLE_TEMP
+			   && target > THERMISTOR_PROTECTION_MIN_TARGET_TEMP)
+			{
+				m_check_temp_protection = true;
+				m_temp_protection_counter = THERMISTOR_PROTECTION_WAIT_CYCLES;
+			}
 		}
 		else
 		{
+#ifdef DOGLCD
 			TCCR2A &= 0xDF;
+#endif // DOGLCD
+			m_check_temp_protection = false;
+			m_temp_protection_counter = 0;
 		}
-		
+#ifdef DOGLCD
 		m_control->setTargetControl(target);
-	#else
-		target_temperature[0] = target;
-	#endif // DOGLCD
+#else
+		if(!m_force_disable_hotend)
+		{
+			target_temperature[0] = target;
+		}
+#endif // DOGLCD
 	}
 
 	uint16_t const & TemperatureManager::getTargetTemperature() const
@@ -433,6 +481,10 @@ namespace temp
 			}
 		#endif // MB(BQ_ZUM_MEGA_3D)
 	#else
+		if(m_force_disable_hotend)
+		{
+			target_temperature[0] = 0;
+		}
 		manage_heater();
 	#endif
 	}
diff --git a/Marlin/TemperatureManager.h b/Marlin/TemperatureManager.h
index 60b154fd8a0e..128f684cc835 100644
--- a/Marlin/TemperatureManager.h
+++ b/Marlin/TemperatureManager.h
@@ -120,6 +120,10 @@ namespace temp
 			
 			LookUpTableEntry m_bed_cache[4];
 			uint16_t m_bed_round_temperature;
+
+			uint16_t m_temp_protection_counter;
+			bool m_check_temp_protection;
+			bool m_force_disable_hotend;
 	};
 }
 
diff --git a/Marlin/boards.h b/Marlin/boards.h
index f9921cb9e7d4..adc65b5a5d68 100644
--- a/Marlin/boards.h
+++ b/Marlin/boards.h
@@ -61,6 +61,6 @@
 #define BOARD_99                99   // This is in pins.h but...?
 
 #define MB(board) (MOTHERBOARD == BOARD_##board)
-#define IS_RAMPS (MB(RAMPS_OLD) || MB(RAMPS_13_EFB) || MB(RAMPS_13_EEB) || MB(RAMPS_13_EFF) || MB(RAMPS_13_EEF) || MB(BQCNC)) 
+#define IS_RAMPS (MB(RAMPS_OLD) || MB(RAMPS_13_EFB) || MB(RAMPS_13_EEB) || MB(RAMPS_13_EFF) || MB(RAMPS_13_EEF) || MB(BQCNC) || MB(BQ_ZUM_MEGA_3D))
 
 #endif //__BOARDS_H
diff --git a/Marlin/config/hephestos_2/Configuration.h b/Marlin/config/hephestos_2/Configuration.h
index 0800ef999cc7..c789656665e9 100644
--- a/Marlin/config/hephestos_2/Configuration.h
+++ b/Marlin/config/hephestos_2/Configuration.h
@@ -11,7 +11,7 @@
 #define MACHINE_NAME "Hephestos 2"
 #define FIRMWARE_URL "http://www.bq.com/gb/support/prusa"
 #define SOURCE_CODE_URL "http://github.com/bq/Marlin"
-#define FIRMWARE_VER "2.5.1"
+#define FIRMWARE_VER "2.5.3"
 #define BUILD_VER ""
 #define STRING_VERSION_CONFIG_H __DATE__ " " __TIME__ // build date and time
 
@@ -133,7 +133,7 @@
 
 // Heated bed is considered hot at this temperature
 #define BED_HOT_TEMP 45
-#define BED_AUTOLEVEL_TEMP 50
+#define BED_AUTOLEVEL_TEMP 100
 
 // Heated bed control update frequency
 // Value is in CPU cycles. Calculation as follows:
@@ -233,6 +233,11 @@
 #define EXTRUDE_MINTEMP 170
 #define EXTRUDE_MAXLENGTH (X_MAX_LENGTH+Y_MAX_LENGTH) //prevent extrusion of very large distances.
 
+// Protection for thermistor not reading hotend temperature (incorrect mounting)
+#define THERMISTOR_PROTECTION_MAX_ENABLE_TEMP 80
+#define THERMISTOR_PROTECTION_WAIT_CYCLES 1200
+#define THERMISTOR_PROTECTION_MIN_TARGET_TEMP 100
+
 //===========================================================================
 //=============================Mechanical Settings===========================
 //===========================================================================
@@ -341,7 +346,7 @@ const bool Z_MAX_ENDSTOP_INVERTING = true; // set to true to invert the logic of
 //    Probe 3 arbitrary points on the bed (that aren't colinear)
 //    You must specify the X & Y coordinates of all 3 points
 
-  //#define AUTO_BED_LEVELING_GRID
+  #define AUTO_BED_LEVELING_GRID
   // with AUTO_BED_LEVELING_GRID, the bed is sampled in a
   // AUTO_BED_LEVELING_GRID_POINTSxAUTO_BED_LEVELING_GRID_POINTS grid
   // and least squares solution is calculated
@@ -349,35 +354,35 @@ const bool Z_MAX_ENDSTOP_INVERTING = true; // set to true to invert the logic of
   #ifdef AUTO_BED_LEVELING_GRID
 
     // set the rectangle in which to probe
-    #define LEFT_PROBE_BED_POSITION 30
-    #define RIGHT_PROBE_BED_POSITION 200
-    #define BACK_PROBE_BED_POSITION 185
-    #define FRONT_PROBE_BED_POSITION 30
+    #define LEFT_PROBE_BED_POSITION 5
+    #define RIGHT_PROBE_BED_POSITION 170
+    #define BACK_PROBE_BED_POSITION 275
+    #define FRONT_PROBE_BED_POSITION 10
 
      // set the number of grid points per dimension
      // I wouldn't see a reason to go above 3 (=9 probing points on the bed)
-    #define AUTO_BED_LEVELING_GRID_POINTS 2
-
+    #define AUTO_BED_LEVELING_GRID_POINTS 3
 
-  #else  // not AUTO_BED_LEVELING_GRID
+  #endif // AUTO_BED_LEVELING_GRID
+   // not AUTO_BED_LEVELING_GRID
     // with no grid, just probe 3 arbitrary points.  A simple cross-product
     // is used to esimate the plane of the print bed
 
-      #define ABL_PROBE_PT_1_X X_MIN_POS + 40 + X_PROBE_OFFSET_FROM_EXTRUDER
-      #define ABL_PROBE_PT_1_Y Y_MIN_POS + 40 + Y_PROBE_OFFSET_FROM_EXTRUDER
-      #define ABL_PROBE_PT_2_X X_MAX_POS - 40 + X_PROBE_OFFSET_FROM_EXTRUDER 
-      #define ABL_PROBE_PT_2_Y Y_MIN_POS + 40 + Y_PROBE_OFFSET_FROM_EXTRUDER
-      #define ABL_PROBE_PT_3_X (X_MAX_POS+X_MIN_POS)/2 + X_PROBE_OFFSET_FROM_EXTRUDER
-      #define ABL_PROBE_PT_3_Y Y_MAX_POS - 40 + Y_PROBE_OFFSET_FROM_EXTRUDER
+  #define ABL_PROBE_PT_1_X X_MIN_POS + 40 + X_PROBE_OFFSET_FROM_EXTRUDER
+  #define ABL_PROBE_PT_1_Y Y_MIN_POS + 40 + Y_PROBE_OFFSET_FROM_EXTRUDER
+  #define ABL_PROBE_PT_2_X X_MAX_POS - 40 + X_PROBE_OFFSET_FROM_EXTRUDER
+  #define ABL_PROBE_PT_2_Y Y_MIN_POS + 40 + Y_PROBE_OFFSET_FROM_EXTRUDER
+  #define ABL_PROBE_PT_3_X (X_MAX_POS+X_MIN_POS)/2 + X_PROBE_OFFSET_FROM_EXTRUDER
+  #define ABL_PROBE_PT_3_Y Y_MAX_POS - 40 + Y_PROBE_OFFSET_FROM_EXTRUDER
 
-      #define ABL_MANUAL_PT_1_X ABL_PROBE_PT_1_X
-      #define ABL_MANUAL_PT_1_Y ABL_PROBE_PT_1_Y
-      #define ABL_MANUAL_PT_2_X ABL_PROBE_PT_2_X 
-      #define ABL_MANUAL_PT_2_Y ABL_PROBE_PT_2_Y
-      #define ABL_MANUAL_PT_3_X ABL_PROBE_PT_3_X
-      #define ABL_MANUAL_PT_3_Y ABL_PROBE_PT_3_Y
+  #define ABL_MANUAL_PT_1_X ABL_PROBE_PT_1_X
+  #define ABL_MANUAL_PT_1_Y ABL_PROBE_PT_1_Y
+  #define ABL_MANUAL_PT_2_X ABL_PROBE_PT_2_X
+  #define ABL_MANUAL_PT_2_Y ABL_PROBE_PT_2_Y
+  #define ABL_MANUAL_PT_3_X ABL_PROBE_PT_3_X
+  #define ABL_MANUAL_PT_3_Y ABL_PROBE_PT_3_Y
 
-  #endif // AUTO_BED_LEVELING_GRID
+  #define Z_PROBE_REPEAT_SENSOR 1
 
   #define Z_RAISE_BEFORE_HOMING 0       // (in mm) Raise Z before homing (G28) for Probe Clearance.
                                         // Be sure you have this distance over your Z_MAX_POS in case
@@ -414,7 +419,7 @@ const bool Z_MAX_ENDSTOP_INVERTING = true; // set to true to invert the logic of
 //// MOVEMENT SETTINGS
 #define NUM_AXIS 4 // The axis order in all axis related arrays is X, Y, Z, E
 #define HOMING_FEEDRATE {150*60, 150*60, 3.3*60, 0}  //{50*60, 50*60, 4*60, 0} set the homing speeds (mm/min)
-#define HOMING_SLOW_FEEDRATE {150*60, 150*60, 3.3*60, 0}
+#define HOMING_SLOW_FEEDRATE {150*60, 150*60, 2.5*60, 0}
 
 // default settings
 
@@ -448,27 +453,20 @@ const bool Z_MAX_ENDSTOP_INVERTING = true; // set to true to invert the logic of
 
 #define WITBOX_2
 
-#ifdef WITBOX_2
-  #define WITBOX
-#endif
+#define EXTRUSION_SPEED 300
+#define LEVEL_PLATE_TEMP_PROTECTION 60
+#define FILAMENT_CHANGE_TEMP 210
 
-#ifdef WITBOX
-	#define EXTRUSION_SPEED 300
-	#define LEVEL_PLATE_TEMP_PROTECTION 60
-	#define FILAMENT_CHANGE_TEMP 210
+#define FILAMENT_EXTRUSION_LENGTH 30
+#define FILAMENT_UNLOAD_EXTRUSION_LENGTH 5
+#define FILAMENT_UNLOAD_RETRACTION_LENGTH 40
 
-	#define FILAMENT_EXTRUSION_LENGTH 30
-	#define FILAMENT_UNLOAD_EXTRUSION_LENGTH 5
-	#define FILAMENT_UNLOAD_RETRACTION_LENGTH 40
+#define PREHEAT_HOTEND_TEMP 200
+#define PREHEAT_FAN_SPEED 0
+#define COOLDOWN_FAN_SPEED 255
 
-    #define PREHEAT_HOTEND_TEMP 200
-    #define PREHEAT_FAN_SPEED 0
-    #define COOLDOWN_FAN_SPEED 255
-#endif
+#define XY_TRAVEL_SPEED 200//8000		// X and Y axis travel speed between probes and Witbox movements, in mm/s
 
-#if defined(WITBOX)
-  #define XY_TRAVEL_SPEED 200//8000		// X and Y axis travel speed between probes and Witbox movements, in mm/s
-#endif
 //===========================================================================
 //=============================Additional Features===========================
 //===========================================================================
diff --git a/Marlin/language/Language_EN.h b/Marlin/language/Language_EN.h
index b7007d9e0c97..d68b79862fd5 100644
--- a/Marlin/language/Language_EN.h
+++ b/Marlin/language/Language_EN.h
@@ -84,7 +84,7 @@ const char EN_SCREEN_TEMP_TITLE[] PROGMEM               = "Temperature";
 const char EN_SCREEN_TEMP_HEATING_TITLE[] PROGMEM       = "Temperature";
 const char EN_SCREEN_INFO_TITLE[] PROGMEM               = "Version";
 const char EN_SCREEN_CONTACT_TITLE[] PROGMEM            = "Support";
-const char EN_SCREEN_CONTACT_TEXT[] PROGMEM             = "www.bq.com support.3d@bq.com";
+const char EN_SCREEN_CONTACT_TEXT[] PROGMEM             = "www.bq.com support.3d.en@bq.com";
 const char EN_SCREEN_OFFSET_INIT_TITLE[] PROGMEM        = "Adjust offset";
 const char EN_SCREEN_OFFSET_INIT_TEXT[] PROGMEM         = "Start process?";
 const char EN_SCREEN_OFFSET_PREHEATING_TITLE[] PROGMEM  = "Temperature";
diff --git a/Marlin/language/Language_ES.h b/Marlin/language/Language_ES.h
index 469db5b295b8..dba47145cb10 100644
--- a/Marlin/language/Language_ES.h
+++ b/Marlin/language/Language_ES.h
@@ -84,7 +84,7 @@ const char ES_SCREEN_TEMP_TITLE[] PROGMEM               = "Temperatura";
 const char ES_SCREEN_TEMP_HEATING_TITLE[] PROGMEM       = "Temperatura";
 const char ES_SCREEN_INFO_TITLE[] PROGMEM               = "Versi""\xf3""n";
 const char ES_SCREEN_CONTACT_TITLE[] PROGMEM            = "Soporte";
-const char ES_SCREEN_CONTACT_TEXT[] PROGMEM             = "www.bq.com soporte3d@bq.com";
+const char ES_SCREEN_CONTACT_TEXT[] PROGMEM             = "www.bq.com soporte.3d@bq.com";
 const char ES_SCREEN_OFFSET_INIT_TITLE[] PROGMEM        = "Ajustar offset";
 const char ES_SCREEN_OFFSET_INIT_TEXT[] PROGMEM         = """\xbf""Iniciar proceso?";
 const char ES_SCREEN_OFFSET_PREHEATING_TITLE[] PROGMEM  = "Temperatura";
diff --git a/Marlin/language/Language_RU.h b/Marlin/language/Language_RU.h
index baa76148f98c..80cfa5eb1553 100644
--- a/Marlin/language/Language_RU.h
+++ b/Marlin/language/Language_RU.h
@@ -84,7 +84,7 @@ const char RU_SCREEN_TEMP_TITLE[] PROGMEM               = """\xc2""""\xd5""""\xd
 const char RU_SCREEN_TEMP_HEATING_TITLE[] PROGMEM       = """\xc2""""\xd5""""\xdc""""\xdf""""\xd5""""\xe0""""\xd0""""\xe2""""\xe3""""\xe0""""\xd0""";
 const char RU_SCREEN_INFO_TITLE[] PROGMEM               = """\xb2""""\xd5""""\xe0""""\xe1""""\xd8""""\xef""";
 const char RU_SCREEN_CONTACT_TITLE[] PROGMEM            = """\xbf""""\xde""""\xd4""""\xd4""""\xd5""""\xe0""""\xd6""""\xda""""\xd0""";
-const char RU_SCREEN_CONTACT_TEXT[] PROGMEM             = "www.bq.com support.3d@bq.com";
+const char RU_SCREEN_CONTACT_TEXT[] PROGMEM             = "www.bq.com support.3d.ru@bq.com";
 const char RU_SCREEN_OFFSET_INIT_TITLE[] PROGMEM        = """\xbe""""\xe2""""\xe0""""\xd5""""\xd3""""\xe3""""\xdb""""\xd8""""\xe0""""\xde""""\xd2""""\xd0""""\xe2""""\xec"" ""\xd7""""\xd0""""\xd7""""\xde""""\xe0""";
 const char RU_SCREEN_OFFSET_INIT_TEXT[] PROGMEM         = """\xbd""""\xd0""""\xe7""""\xd0""""\xe2""""\xec"" ""\xdf""""\xe0""""\xde""""\xe6""""\xd5""""\xe1""""\xe1""?";
 const char RU_SCREEN_OFFSET_PREHEATING_TITLE[] PROGMEM  = """\xc2""""\xd5""""\xdc""""\xdf""""\xd5""""\xe0""""\xd0""""\xe2""""\xe3""""\xe0""""\xd0""";
diff --git a/Marlin/libraries/U8glib/U8glib.h b/Marlin/libraries/U8glib/U8glib.h
index 2b9c7e010772..7508ed5138c5 100644
--- a/Marlin/libraries/U8glib/U8glib.h
+++ b/Marlin/libraries/U8glib/U8glib.h
@@ -161,9 +161,8 @@ class U8GLIB : public Print
 
     void drawXBM(u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, const uint8_t *bitmap)
       { u8g_DrawXBM(&u8g, x, y, w, h, bitmap); }
-    void drawXBMP(u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, const u8g_pgm_uint8_t *bitmap)
-      { u8g_DrawXBMP(&u8g, x, y, w, h, bitmap); }
-    
+    void drawXBMP(u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, const u8g_pgm_uint8_t *bitmap, uint8_t inverse)
+      { u8g_DrawXBMP(&u8g, x, y, w, h, bitmap, inverse); }
       
     /* font handling */
     void setFont(const u8g_fntpgm_uint8_t *font) {u8g_SetFont(&u8g, font); }
diff --git a/Marlin/libraries/U8glib/utility/u8g.h b/Marlin/libraries/U8glib/utility/u8g.h
index e15ea5ee8a03..8955b6d6d0fe 100644
--- a/Marlin/libraries/U8glib/utility/u8g.h
+++ b/Marlin/libraries/U8glib/utility/u8g.h
@@ -1236,7 +1236,7 @@ void u8g_DrawBitmap(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t cnt, u8g_
 void u8g_DrawBitmapP(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t cnt, u8g_uint_t h, const u8g_pgm_uint8_t *bitmap);
 
 void u8g_DrawXBM(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, const uint8_t *bitmap);
-void u8g_DrawXBMP(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, const u8g_pgm_uint8_t *bitmap);
+void u8g_DrawXBMP(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, const u8g_pgm_uint8_t *bitmap, uint8_t inverse);
 
 
 /* u8g_line.c */
diff --git a/Marlin/libraries/U8glib/utility/u8g_bitmap.c b/Marlin/libraries/U8glib/utility/u8g_bitmap.c
index dc742d1d7850..3faf4a5929f5 100644
--- a/Marlin/libraries/U8glib/utility/u8g_bitmap.c
+++ b/Marlin/libraries/U8glib/utility/u8g_bitmap.c
@@ -132,13 +132,37 @@ void u8g_DrawXBM(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_
   }
 }
 
-static void u8g_DrawHXBMP(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, const u8g_pgm_uint8_t *bitmap)
+static void u8g_DrawHXBMP(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, const u8g_pgm_uint8_t *bitmap, uint8_t inverse, uint8_t actual_y)
 {
   uint8_t d;
   x+=7;
+  uint8_t first=0;
+  uint8_t iconfocusedheight = 22;
+
   while( w >= 8 )
   {
-    u8g_Draw8Pixel(u8g, x, y, 2, u8g_pgm_read(bitmap));
+    if(inverse==0){
+      d = u8g_pgm_read(bitmap);
+    }else{
+      d = ~u8g_pgm_read(bitmap);
+      if(first==0){
+        d ^= (1u << 0);
+        if(actual_y<2 || actual_y+3>iconfocusedheight){
+          d ^= (1u << 1);
+        }
+        first=1;
+      }
+
+      if(w ==8){
+        d ^= (1u << 7);
+        if(actual_y<2 || actual_y+3>iconfocusedheight){
+          d ^= (1u << 6);
+        }
+      }
+
+    }
+
+    u8g_Draw8Pixel(u8g, x, y, 2, d);
     bitmap++;
     w-= 8;
     x+=8;
@@ -149,8 +173,14 @@ static void u8g_DrawHXBMP(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w,
     x -= 7;
     do
     {
-      if ( d & 1 )
+      if(inverse==1&& w !=1){
         u8g_DrawPixel(u8g, x, y);
+      }else{
+        if ( d & 1 ){
+          u8g_DrawPixel(u8g, x, y);
+        }
+      }
+
       x++;
       w--;
       d >>= 1;      
@@ -158,18 +188,22 @@ static void u8g_DrawHXBMP(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w,
   }
 }
 
-void u8g_DrawXBMP(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, const u8g_pgm_uint8_t *bitmap)
+void u8g_DrawXBMP(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, const u8g_pgm_uint8_t *bitmap, uint8_t inverse)
 {
   u8g_uint_t b;
   b = w;
   b += 7;
   b >>= 3;
-  
+  u8g_uint_t init_h;
+  u8g_uint_t init_y;
+  init_h=h;
+  init_y=y;
+
   if ( u8g_IsBBXIntersection(u8g, x, y, w, h) == 0 )
     return;
   while( h > 0 )
   {
-    u8g_DrawHXBMP(u8g, x, y, w, bitmap);
+    u8g_DrawHXBMP(u8g, x, y, w, bitmap, (h==init_h || h==1) ? 0 : inverse, y-init_y);
     bitmap += b;
     y++;
     h--;
diff --git a/Marlin/pins/pins_BQ_ZUM_MEGA_3D.h b/Marlin/pins/pins_BQ_ZUM_MEGA_3D.h
index 5a176fbca3f2..732b31956ded 100644
--- a/Marlin/pins/pins_BQ_ZUM_MEGA_3D.h
+++ b/Marlin/pins/pins_BQ_ZUM_MEGA_3D.h
@@ -76,8 +76,8 @@
  #define HBP_HEATER_AUX		5
 
  // Cooling Fans
- #define FAN_BLOWER_PIN     12
- #define FAN_BLOCK_PIN		11 
+ #define FAN_BLOWER_PIN     2
+ #define FAN_BLOCK_PIN		6
  
  #define FAN_PIN            FAN_BLOWER_PIN 
   
diff --git a/Marlin/ui/GuiBitmaps_witbox_2.h b/Marlin/ui/GuiBitmaps_witbox_2.h
index e6d2b13f3fb1..31f497ae8722 100644
--- a/Marlin/ui/GuiBitmaps_witbox_2.h
+++ b/Marlin/ui/GuiBitmaps_witbox_2.h
@@ -42,8 +42,10 @@ const static uint8_t serial_width = 27;
 const static uint8_t serial_height = 42;
 const static uint8_t widget_width = 50;
 const static uint8_t widget_height = 22;
-const static uint8_t splash_width = 60;
-const static uint8_t splash_height = 45;
+const static uint8_t splash_x = 48;
+const static uint8_t splash_y = 16;
+const static uint8_t splash_width = 33;
+const static uint8_t splash_height = 33;
 const static uint8_t emergency_width = 24;
 const static uint8_t emergency_height = 23;
 const static uint8_t progress_width = 108;
@@ -61,14 +63,6 @@ const uint8_t bits_nosd_normal[] PROGMEM = {
   0xc1, 0xff, 0x83, 0xc1, 0xff, 0x83, 0xc1, 0xff, 0x83, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_nosd_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x01, 0xfc,
-  0xff, 0x50, 0xfd, 0x7f, 0x54, 0xfd, 0x3f, 0x54, 0xfd, 0x3f, 0x00, 0xfc,
-  0x3f, 0x00, 0xfc, 0x3f, 0x00, 0xfc, 0x7f, 0x88, 0xfc, 0x7f, 0x50, 0xfc,
-  0x7f, 0x00, 0xfc, 0x3f, 0x50, 0xfc, 0x3f, 0x88, 0xfc, 0x3f, 0x00, 0xfc,
-  0x3f, 0x00, 0xfc, 0x3f, 0x00, 0xfc, 0x3f, 0x00, 0xfc, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_sd_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0xfe, 0x83,
   0x01, 0xaf, 0x82, 0x81, 0xab, 0x82, 0xc1, 0xab, 0x82, 0xc1, 0xff, 0x83,
@@ -77,14 +71,6 @@ const uint8_t bits_sd_normal[] PROGMEM = {
   0xc1, 0xff, 0x83, 0xc1, 0xff, 0x83, 0xc1, 0xff, 0x83, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_sd_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x01, 0xfc,
-  0xff, 0x50, 0xfd, 0x7f, 0x54, 0xfd, 0x3f, 0x54, 0xfd, 0x3f, 0x00, 0xfc,
-  0x3f, 0x00, 0xfc, 0x3f, 0x00, 0xfc, 0x7f, 0x6c, 0xfc, 0x7f, 0xa2, 0xfc,
-  0x7f, 0xa4, 0xfc, 0x3f, 0xa8, 0xfc, 0x3f, 0x66, 0xfc, 0x3f, 0x00, 0xfc,
-  0x3f, 0x00, 0xfc, 0x3f, 0x00, 0xfc, 0x3f, 0x00, 0xfc, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_filament_unload_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x08, 0x88,
   0x01, 0x08, 0x88, 0x01, 0x18, 0x8c, 0xf1, 0xe9, 0x8b, 0x01, 0xe8, 0x8b,
@@ -93,14 +79,6 @@ const uint8_t bits_filament_unload_normal[] PROGMEM = {
   0x41, 0x18, 0x8c, 0x41, 0x08, 0x88, 0x41, 0x08, 0x88, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_filament_unload_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7,
-  0xff, 0xf7, 0xf7, 0xff, 0xe7, 0xf3, 0x0f, 0x16, 0xf4, 0xff, 0x17, 0xf4,
-  0xff, 0x17, 0xf4, 0xff, 0x17, 0xf4, 0xff, 0x17, 0xf4, 0xbf, 0x17, 0xf4,
-  0x1f, 0x17, 0xf4, 0x0f, 0x16, 0xf4, 0xbf, 0x17, 0xf4, 0xbf, 0x17, 0xf4,
-  0xbf, 0xe7, 0xf3, 0xbf, 0xf7, 0xf7, 0xbf, 0xf7, 0xf7, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_filament_load_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x08, 0x88,
   0x41, 0x08, 0x88, 0x41, 0x18, 0x8c, 0xf1, 0xe9, 0x8b, 0x41, 0xe8, 0x8b,
@@ -109,14 +87,6 @@ const uint8_t bits_filament_load_normal[] PROGMEM = {
   0xf1, 0x99, 0x8c, 0xe1, 0x88, 0x88, 0x41, 0x88, 0x88, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_filament_load_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7,
-  0xbf, 0xf7, 0xf7, 0xbf, 0xe7, 0xf3, 0x0f, 0x16, 0xf4, 0xbf, 0x17, 0xf4,
-  0xbf, 0x17, 0xf4, 0xff, 0x17, 0xf4, 0xff, 0x17, 0xf4, 0xbf, 0x17, 0xf4,
-  0xbf, 0x17, 0xf4, 0xbf, 0x17, 0xf4, 0xbf, 0x17, 0xf4, 0xbf, 0x17, 0xf4,
-  0x0f, 0x66, 0xf3, 0x1f, 0x77, 0xf7, 0xbf, 0x77, 0xf7, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_leveling_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x81, 0x00, 0x81, 0xc1, 0x01, 0x81, 0xe1, 0x03, 0x81, 0x81, 0xc0, 0x87,
@@ -125,14 +95,6 @@ const uint8_t bits_leveling_normal[] PROGMEM = {
   0x01, 0x3c, 0x80, 0x81, 0xff, 0x81, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_leveling_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0x7f, 0xff, 0xfe, 0x3f, 0xfe, 0xfe, 0x1f, 0xfc, 0xfe, 0x7f, 0x3f, 0xf8,
-  0x7f, 0x7f, 0xfc, 0x7f, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x1f, 0x00, 0xf8,
-  0xbf, 0xe7, 0xfd, 0xff, 0xe7, 0xff, 0xff, 0xe7, 0xff, 0xff, 0xe7, 0xff,
-  0xff, 0xc3, 0xff, 0x7f, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_homing_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x01, 0x18, 0x80, 0x01, 0xa4, 0x83, 0x01, 0xda, 0x82, 0x01, 0xa5, 0x82,
@@ -141,14 +103,6 @@ const uint8_t bits_homing_normal[] PROGMEM = {
   0x41, 0x24, 0x82, 0xc1, 0xff, 0x83, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_homing_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xe7, 0xff, 0xff, 0x5b, 0xfc, 0xff, 0x25, 0xfd, 0xff, 0x5a, 0xfd,
-  0x7f, 0xbd, 0xfc, 0xbf, 0x7e, 0xfd, 0x5f, 0xff, 0xfa, 0x9f, 0xff, 0xf9,
-  0xbf, 0xc3, 0xfd, 0xbf, 0xdb, 0xfd, 0xbf, 0xdb, 0xfd, 0xbf, 0xdb, 0xfd,
-  0xbf, 0xdb, 0xfd, 0x3f, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_steppers_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x3c, 0x80,
   0x01, 0x24, 0x80, 0x01, 0x24, 0x80, 0x01, 0xe7, 0x80, 0xc1, 0xff, 0x83,
@@ -157,14 +111,6 @@ const uint8_t bits_steppers_normal[] PROGMEM = {
   0xc1, 0xff, 0x83, 0x41, 0x00, 0x82, 0xc1, 0xff, 0x83, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_steppers_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xc3, 0xff,
-  0xff, 0xdb, 0xff, 0xff, 0xdb, 0xff, 0xff, 0x18, 0xff, 0x3f, 0x00, 0xfc,
-  0xbf, 0xff, 0xfd, 0x3f, 0x00, 0xfc, 0x7f, 0x00, 0xfe, 0x7f, 0x00, 0xfe,
-  0x7f, 0x00, 0xfe, 0x7f, 0x00, 0xfe, 0x7f, 0x00, 0xfe, 0x7f, 0x00, 0xfe,
-  0x3f, 0x00, 0xfc, 0xbf, 0xff, 0xfd, 0x3f, 0x00, 0xfc, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_steppers_off_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x3c, 0x80,
   0x01, 0x24, 0x80, 0x01, 0x24, 0x84, 0x01, 0xe7, 0x82, 0xc1, 0x7f, 0x81,
@@ -173,14 +119,6 @@ const uint8_t bits_steppers_off_normal[] PROGMEM = {
   0x81, 0xfe, 0x83, 0x41, 0x00, 0x82, 0xa1, 0xff, 0x83, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_steppers_off_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xc3, 0xff,
-  0xff, 0xdb, 0xff, 0xff, 0xdb, 0xfb, 0xff, 0x18, 0xfd, 0x3f, 0x80, 0xfe,
-  0xbf, 0x7f, 0xfd, 0x3f, 0xa0, 0xfc, 0x7f, 0x50, 0xfe, 0x7f, 0x28, 0xfe,
-  0x7f, 0x14, 0xfe, 0x7f, 0x0a, 0xfe, 0x7f, 0x05, 0xfe, 0xff, 0x02, 0xfe,
-  0x7f, 0x01, 0xfc, 0xbf, 0xff, 0xfd, 0x5f, 0x00, 0xfc, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_moveaxis_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x18, 0x80,
   0x01, 0x3c, 0x80, 0x01, 0x7e, 0x80, 0x01, 0x18, 0x80, 0x01, 0x18, 0x80,
@@ -189,14 +127,6 @@ const uint8_t bits_moveaxis_normal[] PROGMEM = {
   0x01, 0x7e, 0x80, 0x01, 0x3c, 0x80, 0x01, 0x18, 0x80, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_moveaxis_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xff,
-  0xff, 0xc3, 0xff, 0xff, 0x81, 0xff, 0xff, 0xe7, 0xff, 0xff, 0xe7, 0xff,
-  0xbf, 0xe7, 0xfd, 0x9f, 0xff, 0xf9, 0x0f, 0x3c, 0xf0, 0x0f, 0x3c, 0xf0,
-  0x9f, 0xff, 0xf9, 0xbf, 0xe7, 0xfd, 0xff, 0xe7, 0xff, 0xff, 0xe7, 0xff,
-  0xff, 0x81, 0xff, 0xff, 0xc3, 0xff, 0xff, 0xe7, 0xff, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_temperature_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x03, 0x80,
   0x81, 0x04, 0x82, 0x41, 0x0b, 0x82, 0x41, 0x8a, 0x8f, 0x41, 0x0b, 0x82,
@@ -205,14 +135,6 @@ const uint8_t bits_temperature_normal[] PROGMEM = {
   0x91, 0x27, 0x80, 0x21, 0x10, 0x80, 0xc1, 0x0f, 0x80, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_temperature_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xff,
-  0x7f, 0xfb, 0xfd, 0xbf, 0xf4, 0xfd, 0xbf, 0x75, 0xf0, 0xbf, 0xf4, 0xfd,
-  0xbf, 0xf5, 0xfd, 0xbf, 0xf4, 0xff, 0xbf, 0xf5, 0xff, 0xbf, 0xf4, 0xff,
-  0xbf, 0xf4, 0xff, 0xdf, 0xec, 0xff, 0x6f, 0xd8, 0xff, 0x2f, 0x50, 0xf0,
-  0x6f, 0xd8, 0xff, 0xdf, 0xef, 0xff, 0x3f, 0xf0, 0xff, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_settings_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0xe0, 0x80,
   0x01, 0x10, 0x81, 0x01, 0x88, 0x80, 0x01, 0x48, 0x84, 0x01, 0x48, 0x8a,
@@ -221,14 +143,6 @@ const uint8_t bits_settings_normal[] PROGMEM = {
   0x11, 0x02, 0x80, 0x11, 0x01, 0x80, 0xe1, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_settings_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xff,
-  0xff, 0xef, 0xfe, 0xff, 0x77, 0xff, 0xff, 0xb7, 0xfb, 0xff, 0xb7, 0xf5,
-  0xff, 0x77, 0xf6, 0xff, 0xfb, 0xf7, 0xff, 0xfd, 0xfb, 0xff, 0x3e, 0xfc,
-  0x7f, 0xdf, 0xff, 0xbf, 0xef, 0xff, 0xdf, 0xf7, 0xff, 0xef, 0xfb, 0xff,
-  0xef, 0xfd, 0xff, 0xef, 0xfe, 0xff, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_play_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x04, 0x80, 0x01, 0x0c, 0x80,
@@ -237,14 +151,6 @@ const uint8_t bits_play_normal[] PROGMEM = {
   0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_play_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xf3, 0xff,
-  0xff, 0xe3, 0xff, 0xff, 0xc3, 0xff, 0xff, 0x83, 0xff, 0xff, 0x83, 0xff,
-  0xff, 0xc3, 0xff, 0xff, 0xe3, 0xff, 0xff, 0xf3, 0xff, 0xff, 0xfb, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_pause_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x81, 0xc3, 0x81, 0x81, 0xc3, 0x81,
@@ -253,14 +159,6 @@ const uint8_t bits_pause_normal[] PROGMEM = {
   0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_pause_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x3c, 0xfe, 0x7f, 0x3c, 0xfe,
-  0x7f, 0x3c, 0xfe, 0x7f, 0x3c, 0xfe, 0x7f, 0x3c, 0xfe, 0x7f, 0x3c, 0xfe,
-  0x7f, 0x3c, 0xfe, 0x7f, 0x3c, 0xfe, 0x7f, 0x3c, 0xfe, 0x7f, 0x3c, 0xfe,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_stop_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x81, 0xff, 0x81, 0x81, 0xff, 0x81,
@@ -269,14 +167,6 @@ const uint8_t bits_stop_normal[] PROGMEM = {
   0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f }; 
 
-const uint8_t bits_stop_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0xfe, 0x7f, 0x00, 0xfe,
-  0x7f, 0x00, 0xfe, 0x7f, 0x00, 0xfe, 0x7f, 0x00, 0xfe, 0x7f, 0x00, 0xfe,
-  0x7f, 0x00, 0xfe, 0x7f, 0x00, 0xfe, 0x7f, 0x00, 0xfe, 0x7f, 0x00, 0xfe,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_change_filament_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x08, 0x88,
   0x41, 0x08, 0x88, 0x41, 0x18, 0x8c, 0xf1, 0xe9, 0x8b, 0x41, 0xe8, 0x8b,
@@ -285,14 +175,6 @@ const uint8_t bits_change_filament_normal[] PROGMEM = {
   0x01, 0x18, 0x8c, 0x01, 0x08, 0x88, 0x01, 0x08, 0x88, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_change_filament_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7,
-  0xbf, 0xf7, 0xf7, 0xbf, 0xe7, 0xf3, 0x0f, 0x16, 0xf4, 0xbf, 0x17, 0xf4,
-  0xbf, 0x17, 0xf4, 0xff, 0x17, 0xf4, 0xff, 0x17, 0xf4, 0xff, 0x17, 0xf4,
-  0xff, 0x17, 0xf4, 0xff, 0x17, 0xf4, 0xff, 0x17, 0xf4, 0x0f, 0x16, 0xf4,
-  0xff, 0xe7, 0xf3, 0xff, 0xf7, 0xf7, 0xff, 0xf7, 0xf7, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_change_speed_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x41, 0x00, 0x82,
   0x61, 0x00, 0x86, 0xf1, 0xc3, 0x8f, 0x61, 0x00, 0x86, 0x41, 0x00, 0x82,
@@ -301,14 +183,6 @@ const uint8_t bits_change_speed_normal[] PROGMEM = {
   0x61, 0x18, 0x86, 0x21, 0x3c, 0x84, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_change_speed_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xfd,
-  0x9f, 0xff, 0xf9, 0x0f, 0x3c, 0xf0, 0x9f, 0xff, 0xf9, 0xbf, 0xff, 0xfd,
-  0xff, 0xff, 0xff, 0xff, 0xc3, 0xff, 0xff, 0x24, 0xff, 0x7f, 0x7e, 0xfe,
-  0xbf, 0x7f, 0xfd, 0x3f, 0xbf, 0xfc, 0xdf, 0xdf, 0xfb, 0xdf, 0xef, 0xfb,
-  0x9f, 0xe7, 0xf9, 0xdf, 0xc3, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_back_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x02, 0x80,
@@ -317,14 +191,6 @@ const uint8_t bits_back_normal[] PROGMEM = {
   0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_back_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff,
-  0xff, 0xfc, 0xff, 0x7f, 0x80, 0xff, 0xff, 0x7c, 0xff, 0xff, 0xfd, 0xfe,
-  0xff, 0xff, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0x87, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_retry_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x01, 0x3c, 0x80, 0x01, 0xc3, 0x80, 0x81, 0x00, 0x81, 0x41, 0x00, 0x82,
@@ -333,14 +199,6 @@ const uint8_t bits_retry_normal[] PROGMEM = {
   0x01, 0xc3, 0x80, 0x01, 0x3c, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_retry_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xc3, 0xff, 0xff, 0x3c, 0xff, 0x7f, 0xff, 0xfe, 0xbf, 0xff, 0xfd,
-  0xbf, 0xff, 0xfd, 0xdf, 0x7f, 0xf0, 0xdf, 0xff, 0xf8, 0xdf, 0xff, 0xfd,
-  0xdf, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xbf, 0xff, 0xff, 0x7f, 0xff, 0xfe,
-  0xff, 0x3c, 0xff, 0xff, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_ok_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x81, 0x13, 0x81,
@@ -349,14 +207,6 @@ const uint8_t bits_ok_normal[] PROGMEM = {
   0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_ok_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xec, 0xfe,
-  0xbf, 0x6b, 0xff, 0xbf, 0xab, 0xff, 0xbf, 0xcb, 0xff, 0xbf, 0xab, 0xff,
-  0xbf, 0x6b, 0xff, 0x7f, 0xec, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_about[] PROGMEM = {
   0x00, 0x80, 0x03, 0x00, 0x00, 0x00, 0xc0, 0x07, 0x00, 0x00, 0x00, 0xc0,
   0x07, 0x00, 0x00, 0x80, 0xc3, 0x87, 0x03, 0x00, 0xc0, 0x87, 0xc3, 0x07,
@@ -378,14 +228,6 @@ const uint8_t bits_x_axis_normal[] PROGMEM = {
   0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_x_axis_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xdd, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xeb, 0xff, 0xff, 0xf7, 0xff,
-  0xff, 0xeb, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_y_axis_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
@@ -394,14 +236,6 @@ const uint8_t bits_y_axis_normal[] PROGMEM = {
   0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_y_axis_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xdd, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xeb, 0xff,
-  0xff, 0xf7, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_z_axis_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
@@ -410,14 +244,6 @@ const uint8_t bits_z_axis_normal[] PROGMEM = {
   0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_z_axis_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xc1, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xef, 0xff, 0xff, 0xf7, 0xff,
-  0xff, 0xfb, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xc1, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_e_axis_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
@@ -426,14 +252,6 @@ const uint8_t bits_e_axis_normal[] PROGMEM = {
   0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_e_axis_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xc1, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xe1, 0xff,
-  0xff, 0xfd, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xc1, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_01mm_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0xe1, 0x40, 0x80, 0x11, 0x61, 0x80, 0x91, 0x41, 0x80, 0x51, 0x41, 0x80,
@@ -442,14 +260,6 @@ const uint8_t bits_01mm_normal[] PROGMEM = {
   0x01, 0xa2, 0x88, 0x01, 0xa2, 0x88, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_01mm_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0x1f, 0xbf, 0xff, 0xef, 0x9e, 0xff, 0x6f, 0xbe, 0xff, 0xaf, 0xbe, 0xff,
-  0xcf, 0xbe, 0xff, 0xef, 0xb2, 0xff, 0x1f, 0x13, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0x69, 0xfa, 0xff, 0x55, 0xf5, 0xff, 0x55, 0xf5,
-  0xff, 0x5d, 0xf7, 0xff, 0x5d, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_1mm_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x21, 0x00, 0x80, 0x31, 0x00, 0x80, 0x21, 0x00, 0x80, 0x21, 0x00, 0x80,
@@ -458,14 +268,6 @@ const uint8_t bits_1mm_normal[] PROGMEM = {
   0x01, 0xa2, 0x88, 0x01, 0xa2, 0x88, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_1mm_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xdf, 0xff, 0xff, 0xcf, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xdf, 0xff, 0xff,
-  0xdf, 0xff, 0xff, 0xdf, 0xff, 0xff, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0x69, 0xfa, 0xff, 0x55, 0xf5, 0xff, 0x55, 0xf5,
-  0xff, 0x5d, 0xf7, 0xff, 0x5d, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_10mm_normal[] PROGMEM = {
   0xfc, 0xff, 0x3f, 0x02, 0x00, 0x40, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x21, 0x0e, 0x80, 0x31, 0x11, 0x80, 0x21, 0x19, 0x80, 0x21, 0x15, 0x80,
@@ -474,14 +276,6 @@ const uint8_t bits_10mm_normal[] PROGMEM = {
   0x01, 0xa2, 0x88, 0x01, 0xa2, 0x88, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
   0x02, 0x00, 0x40, 0xfc, 0xff, 0x3f };
 
-const uint8_t bits_10mm_focused[] PROGMEM = {
-  0xfc, 0xff, 0x3f, 0xfe, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xdf, 0xf1, 0xff, 0xcf, 0xee, 0xff, 0xdf, 0xe6, 0xff, 0xdf, 0xea, 0xff,
-  0xdf, 0xec, 0xff, 0xdf, 0xee, 0xff, 0x8f, 0xf1, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0x69, 0xfa, 0xff, 0x55, 0xf5, 0xff, 0x55, 0xf5,
-  0xff, 0x5d, 0xf7, 0xff, 0x5d, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xfe, 0xff, 0x7f, 0xfc, 0xff, 0x3f };
-
 const uint8_t bits_sd_small[] PROGMEM = {
   0x1c, 0x16, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f };
 
@@ -500,38 +294,6 @@ const uint8_t bits_folder_small[] PROGMEM = {
 const uint8_t bits_updir_small[] PROGMEM = {
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x15 };
 
-const uint8_t bits_logo_splash[] PROGMEM = {
-  0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8,
-  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc,
-  0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x01, 0xf0,
-  0x00, 0x78, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0xfc, 0x00, 0x00,
-  0x00, 0xf8, 0x07, 0x00, 0x00, 0xfe, 0x01, 0x00, 0x00, 0xf8, 0x07, 0x00,
-  0x00, 0xfe, 0x01, 0x00, 0x00, 0xf8, 0x07, 0x00, 0x00, 0xfe, 0x01, 0x00,
-  0x00, 0xf8, 0x07, 0x00, 0x00, 0xfe, 0x01, 0x00, 0x00, 0xf0, 0x03, 0x00,
-  0x00, 0xfc, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x78, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x07,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0xf0, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x03,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-
 const uint8_t bits_logo_about[] PROGMEM = {
   0x00, 0x80, 0x03, 0x00, 0x00, 0x00, 0xc0, 0x07, 0x00, 0x00, 0x00, 0xc0,
   0x07, 0x00, 0x00, 0x80, 0xc3, 0x07, 0x00, 0x00, 0xc0, 0x87, 0x83, 0x03,
@@ -579,21 +341,6 @@ const uint8_t bits_temperature_widget_normal[] PROGMEM = {
   0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x01, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 };
 
-const uint8_t bits_temperature_widget_focused[] PROGMEM = {
-  0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xe7, 0xff,
-  0xff, 0xff, 0xff, 0x03, 0xff, 0xdb, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff,
-  0xa5, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xad, 0xff, 0xff, 0xff, 0xff,
-  0x03, 0xff, 0xa5, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xad, 0xff, 0xff,
-  0xff, 0xff, 0x03, 0xff, 0xa5, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xad,
-  0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xa5, 0xff, 0xff, 0xff, 0xff, 0x03,
-  0xff, 0xa5, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0x66, 0xff, 0xff, 0xff,
-  0xff, 0x03, 0x7f, 0xc3, 0xfe, 0xff, 0xff, 0xff, 0x03, 0x7f, 0x81, 0xfe,
-  0xff, 0xff, 0xff, 0x03, 0x7f, 0xc3, 0xfe, 0xff, 0xff, 0xff, 0x03, 0xff,
-  0x7e, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0x81, 0xff, 0xff, 0xff, 0xff,
-  0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xfe, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0x01, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 };
-
 const uint8_t bits_cold_bed_widget_normal[] PROGMEM = {
    0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x00,
@@ -623,36 +370,6 @@ const uint8_t bits_hot_bed_widget_normal[] PROGMEM = {
    0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0xf1, 0xff, 0x01, 0x00, 0x00, 0x00,
    0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x01, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 };
-	
-const uint8_t bits_cold_bed_widget_focused[] PROGMEM = {
-   0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff,
-   0xff, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff,
-   0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff,
-   0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-   0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff,
-   0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff,
-   0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03,
-   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x3f, 0x00, 0xf8, 0xff, 0xff,
-   0xff, 0x03, 0xbf, 0xff, 0xfb, 0xff, 0xff, 0xff, 0x03, 0xdf, 0xff, 0xfd,
-   0xff, 0xff, 0xff, 0x03, 0xdf, 0xff, 0xfd, 0xff, 0xff, 0xff, 0x03, 0xef,
-   0xff, 0xfe, 0xff, 0xff, 0xff, 0x03, 0x0f, 0x00, 0xfe, 0xff, 0xff, 0xff,
-   0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xfe, 0xff, 0xff, 0xff,
-   0xff, 0xff, 0x01, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 };
-  
-const uint8_t bits_hot_bed_widget_focused[] PROGMEM = {
-   0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff,
-   0xff, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff,
-   0xff, 0xff, 0xff, 0x03, 0xff, 0xde, 0xfb, 0xff, 0xff, 0xff, 0x03, 0xff,
-   0xde, 0xfb, 0xff, 0xff, 0xff, 0x03, 0x7f, 0xef, 0xfd, 0xff, 0xff, 0xff,
-   0x03, 0x7f, 0xef, 0xfd, 0xff, 0xff, 0xff, 0x03, 0x7f, 0xef, 0xfd, 0xff,
-   0xff, 0xff, 0x03, 0x7f, 0xef, 0xfd, 0xff, 0xff, 0xff, 0x03, 0xbf, 0xf7,
-   0xfe, 0xff, 0xff, 0xff, 0x03, 0xbf, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0x03,
-   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x3f, 0x00, 0xf8, 0xff, 0xff,
-   0xff, 0x03, 0xbf, 0xff, 0xfb, 0xff, 0xff, 0xff, 0x03, 0xdf, 0xff, 0xfd,
-   0xff, 0xff, 0xff, 0x03, 0xdf, 0xff, 0xfd, 0xff, 0xff, 0xff, 0x03, 0xef,
-   0xff, 0xfe, 0xff, 0xff, 0xff, 0x03, 0x0f, 0x00, 0xfe, 0xff, 0xff, 0xff,
-   0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xfe, 0xff, 0xff, 0xff,
-   0xff, 0xff, 0x01, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 };
 
 const uint8_t bits_emergency[] PROGMEM = {
   0x00, 0x18, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x7e, 0x00,
diff --git a/Marlin/ui/GuiImpl_witbox_2.cpp b/Marlin/ui/GuiImpl_witbox_2.cpp
index 102ed9e76eb6..fe7d002fbff3 100644
--- a/Marlin/ui/GuiImpl_witbox_2.cpp
+++ b/Marlin/ui/GuiImpl_witbox_2.cpp
@@ -174,8 +174,8 @@ namespace ui
 
 	static ScreenMenu * make_screen_wizard_offset_finish()
 	{
-		Icon * icon_retry = new Icon(icon_size, bits_retry_normal, bits_retry_focused, MSG_ICON_RETRY());
-		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, bits_ok_focused, MSG_ICON_OK2());
+		Icon * icon_retry = new Icon(icon_size, bits_retry_normal, MSG_ICON_RETRY());
+		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, MSG_ICON_OK2());
 
 		ScreenMenu * local_view = new ScreenMenu(MSG_SCREEN_OFFSET_FINISH_TITLE(), MSG_SCREEN_OFFSET_FINISH_TEXT());
 		local_view->add(screen_wizard_offset_home);
@@ -221,25 +221,25 @@ namespace ui
 
 	static ScreenMenu * make_screen_main()
 	{
-		IconStatus<bool> * icon_sd = new IconStatus<bool>(icon_size, bits_nosd_normal, bits_nosd_focused, bits_sd_normal, bits_sd_focused, MSG_ICON_SD_NOSD(), MSG_ICON_SD_SD(), &SDManager::single::instance());
-		Icon * icon_filament_unload = new Icon(icon_size, bits_filament_unload_normal, bits_filament_unload_focused, MSG_ICON_FILAMENT_UNLOAD());
-		Icon * icon_filament_load = new Icon(icon_size, bits_filament_load_normal, bits_filament_load_focused, MSG_ICON_FILAMENT_LOAD());
-		Icon * icon_leveling = new Icon(icon_size, bits_leveling_normal, bits_leveling_focused, MSG_ICON_LEVELING());
-		Icon * icon_homing = new Icon(icon_size, bits_homing_normal, bits_homing_focused, MSG_ICON_HOMING());
-		Icon * icon_settings = new Icon(icon_size, bits_settings_normal, bits_settings_focused, MSG_ICON_SETTINGS());
-		Icon * icon_moveaxis = new Icon(icon_size, bits_moveaxis_normal, bits_moveaxis_focused, MSG_ICON_MOVEAXIS());
-		IconStatus<bool> * icon_steppers = new IconStatus<bool>(icon_size, bits_steppers_normal, bits_steppers_focused, bits_steppers_off_normal, bits_steppers_off_focused, MSG_ICON_STEPPERS(), MSG_ICON_STEPPERS_OFF(), &SteppersManager::single::instance());
+		IconStatus<bool> * icon_sd = new IconStatus<bool>(icon_size, bits_nosd_normal, bits_sd_normal, MSG_ICON_SD_NOSD(), MSG_ICON_SD_SD(), &SDManager::single::instance());
+		Icon * icon_filament_unload = new Icon(icon_size, bits_filament_unload_normal, MSG_ICON_FILAMENT_UNLOAD());
+		Icon * icon_filament_load = new Icon(icon_size, bits_filament_load_normal, MSG_ICON_FILAMENT_LOAD());
+		Icon * icon_leveling = new Icon(icon_size, bits_leveling_normal, MSG_ICON_LEVELING());
+		Icon * icon_homing = new Icon(icon_size, bits_homing_normal, MSG_ICON_HOMING());
+		Icon * icon_settings = new Icon(icon_size, bits_settings_normal, MSG_ICON_SETTINGS());
+		Icon * icon_moveaxis = new Icon(icon_size, bits_moveaxis_normal, MSG_ICON_MOVEAXIS());
+		IconStatus<bool> * icon_steppers = new IconStatus<bool>(icon_size, bits_steppers_normal, bits_steppers_off_normal, MSG_ICON_STEPPERS(), MSG_ICON_STEPPERS_OFF(), &SteppersManager::single::instance());
 	
 		Icon * widget_temperature;
 #if MB(BQ_ZUM_MEGA_3D)
 		if(HeatedbedManager::single::instance().detected())
 		{
-			widget_temperature = new IconWidgetBed<float>(widget_size, bits_cold_bed_widget_normal, bits_cold_bed_widget_focused, bits_hot_bed_widget_normal, bits_hot_bed_widget_focused, MSG_ICON_TEMPERATURE(), &temp::TemperatureManager::single::instance());
+			widget_temperature = new IconWidgetBed<float>(widget_size, bits_cold_bed_widget_normal, bits_hot_bed_widget_normal, MSG_ICON_TEMPERATURE(), &temp::TemperatureManager::single::instance());
 		}
 		else
 #endif // MB(BQ_ZUM_MEGA_3D)
 		{
-			widget_temperature = new IconWidgetBed<float>(widget_size, bits_temperature_widget_normal, bits_temperature_widget_focused, NULL, NULL, MSG_ICON_TEMPERATURE(), &temp::TemperatureManager::single::instance());
+			widget_temperature = new IconWidgetBed<float>(widget_size, bits_temperature_widget_normal, NULL, MSG_ICON_TEMPERATURE(), &temp::TemperatureManager::single::instance());
 		}
 
 		ScreenMenu * local_view = new ScreenMenu();
@@ -275,8 +275,8 @@ namespace ui
 	
 	static ScreenFile * make_screen_SD_confirm()
 	{
-		Icon * icon_back = new Icon(icon_size, bits_back_normal, bits_back_focused, MSG_BACK());
-		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, bits_ok_focused, MSG_ICON_OK2());
+		Icon * icon_back = new Icon(icon_size, bits_back_normal, MSG_BACK());
+		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, MSG_ICON_OK2());
 
 		ScreenFile * local_view = new ScreenFile(MSG_SCREEN_SD_LIST_CONFIRM(), &SDManager::single::instance());
 		local_view->add(screen_SD_list);
@@ -295,8 +295,8 @@ namespace ui
 
 	static ScreenMenu * make_screen_unload_init()
 	{
-		Icon * icon_back = new Icon(icon_size, bits_back_normal, bits_back_focused, MSG_BACK());
-		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, bits_ok_focused, MSG_ICON_OK2());
+		Icon * icon_back = new Icon(icon_size, bits_back_normal, MSG_BACK());
+		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, MSG_ICON_OK2());
 
 		ScreenMenu * local_view = new ScreenMenu(MSG_SCREEN_UNLOAD_INIT_TITLE(), MSG_SCREEN_UNLOAD_INIT_TEXT());
 		local_view->add(screen_main);
@@ -358,8 +358,8 @@ namespace ui
 
 	static ScreenMenu * make_screen_unload_confirm()
 	{
-		Icon * icon_retry = new Icon(icon_size, bits_retry_normal, bits_retry_focused, MSG_ICON_RETRY());
-		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, bits_ok_focused, MSG_ICON_OK2());
+		Icon * icon_retry = new Icon(icon_size, bits_retry_normal, MSG_ICON_RETRY());
+		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, MSG_ICON_OK2());
 
 		ScreenMenu * local_view = new ScreenMenu(MSG_SCREEN_UNLOAD_CONFIRM_TITLE(), MSG_SCREEN_UNLOAD_CONFIRM_TEXT());
 		local_view->add(screen_unload_info);
@@ -378,8 +378,8 @@ namespace ui
 
 	static ScreenMenu * make_screen_load_init()
 	{
-		Icon * icon_back = new Icon(icon_size, bits_back_normal, bits_back_focused, MSG_BACK());
-		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, bits_ok_focused, MSG_ICON_OK2());
+		Icon * icon_back = new Icon(icon_size, bits_back_normal, MSG_BACK());
+		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, MSG_ICON_OK2());
 
 		ScreenMenu * local_view = new ScreenMenu(MSG_SCREEN_LOAD_INIT_TITLE(), MSG_SCREEN_LOAD_INIT_TEXT());
 		local_view->add(screen_main);
@@ -441,8 +441,8 @@ namespace ui
 
 	static ScreenMenu * make_screen_load_confirm()
 	{
-		Icon * icon_retry = new Icon(icon_size, bits_retry_normal, bits_retry_focused, MSG_ICON_RETRY());
-		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, bits_ok_focused, MSG_ICON_OK2());
+		Icon * icon_retry = new Icon(icon_size, bits_retry_normal, MSG_ICON_RETRY());
+		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, MSG_ICON_OK2());
 
 		ScreenMenu * local_view = new ScreenMenu(MSG_SCREEN_LOAD_CONFIRM_TITLE(), MSG_SCREEN_LOAD_CONFIRM_TEXT());
 		local_view->add(screen_load_info);
@@ -461,8 +461,8 @@ namespace ui
 
 	static ScreenMenu * make_screen_level_init()
 	{
-		Icon * icon_back = new Icon(icon_size, bits_back_normal, bits_back_focused, MSG_BACK());
-		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, bits_ok_focused, MSG_ICON_OK2());
+		Icon * icon_back = new Icon(icon_size, bits_back_normal, MSG_BACK());
+		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, MSG_ICON_OK2());
 
 		ScreenMenu * local_view = new ScreenMenu(MSG_SCREEN_LEVEL_INIT_TITLE(), MSG_SCREEN_LEVEL_INIT_TEXT());
 		local_view->add(screen_main);
@@ -546,8 +546,8 @@ namespace ui
 
 	static ScreenMenu * make_screen_level_confirm()
 	{
-		Icon * icon_retry = new Icon(icon_size, bits_retry_normal, bits_retry_focused, MSG_ICON_RETRY());
-		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, bits_ok_focused, MSG_ICON_OK2());
+		Icon * icon_retry = new Icon(icon_size, bits_retry_normal, MSG_ICON_RETRY());
+		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, MSG_ICON_OK2());
 
 		ScreenMenu * local_view = new ScreenMenu(MSG_SCREEN_LEVEL_CONFIRM_TITLE(), MSG_SCREEN_LEVEL_CONFIRM_TEXT());
 		local_view->add(screen_level_homing);
@@ -559,8 +559,8 @@ namespace ui
 
 	static ScreenMenu * make_screen_autohome_init()
 	{
-		Icon * icon_back = new Icon(icon_size, bits_back_normal, bits_back_focused, MSG_BACK());
-		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, bits_ok_focused, MSG_ICON_OK2());
+		Icon * icon_back = new Icon(icon_size, bits_back_normal, MSG_BACK());
+		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, MSG_ICON_OK2());
 
 		ScreenMenu * local_view = new ScreenMenu(MSG_SCREEN_AUTOHOME_INIT_TITLE(), MSG_SCREEN_AUTOHOME_INIT_TEXT());
 		local_view->add(screen_main);
@@ -677,11 +677,11 @@ namespace ui
 
 	static ScreenMenu * make_screen_move()
 	{
-		Icon * icon_back = new Icon(icon_size, bits_back_normal, bits_back_focused, MSG_BACK());
-		Icon * icon_move_x = new Icon(icon_size, bits_x_axis_normal, bits_x_axis_focused, MSG_ICON_MOVE_X());
-		Icon * icon_move_y = new Icon(icon_size, bits_y_axis_normal, bits_y_axis_focused, MSG_ICON_MOVE_Y());
-		Icon * icon_move_z = new Icon(icon_size, bits_z_axis_normal, bits_z_axis_focused, MSG_ICON_MOVE_Z());
-		Icon * icon_move_e = new Icon(icon_size, bits_e_axis_normal, bits_e_axis_focused, MSG_ICON_MOVE_E());
+		Icon * icon_back = new Icon(icon_size, bits_back_normal, MSG_BACK());
+		Icon * icon_move_x = new Icon(icon_size, bits_x_axis_normal, MSG_ICON_MOVE_X());
+		Icon * icon_move_y = new Icon(icon_size, bits_y_axis_normal, MSG_ICON_MOVE_Y());
+		Icon * icon_move_z = new Icon(icon_size, bits_z_axis_normal, MSG_ICON_MOVE_Z());
+		Icon * icon_move_e = new Icon(icon_size, bits_e_axis_normal, MSG_ICON_MOVE_E());
 
 		ScreenMenu *  local_view = new ScreenMenu(MSG_SCREEN_MOVE_TITLE(), MSG_SCREEN_MOVE_TEXT());
 		local_view->add(screen_main);
@@ -707,8 +707,8 @@ namespace ui
 
 	static ScreenMenu * make_screen_move_heat_confirm()
 	{
-		Icon * icon_back = new Icon(icon_size, bits_back_normal, bits_back_focused, MSG_BACK());
-		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, bits_ok_focused, MSG_ICON_OK2());
+		Icon * icon_back = new Icon(icon_size, bits_back_normal, MSG_BACK());
+		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, MSG_ICON_OK2());
 
 		ScreenMenu * local_view = new ScreenMenu(MSG_SCREEN_MOVE_CONFIRM_TITLE(), MSG_SCREEN_MOVE_CONFIRM_TEXT());
 		local_view->add(screen_move);
@@ -734,10 +734,10 @@ namespace ui
 
 	static ScreenMenu * make_screen_move_x()
 	{
-		Icon * icon_back = new Icon(icon_size, bits_back_normal, bits_back_focused, MSG_BACK());
-		Icon * icon_move_10mm = new Icon(icon_size, bits_10mm_normal, bits_10mm_focused, MSG_ICON_MOVE_10MM());
-		Icon * icon_move_1mm = new Icon(icon_size, bits_1mm_normal, bits_1mm_focused, MSG_ICON_MOVE_1MM());
-		Icon * icon_move_01mm = new Icon(icon_size, bits_01mm_normal, bits_01mm_focused, MSG_ICON_MOVE_01MM());
+		Icon * icon_back = new Icon(icon_size, bits_back_normal, MSG_BACK());
+		Icon * icon_move_10mm = new Icon(icon_size, bits_10mm_normal, MSG_ICON_MOVE_10MM());
+		Icon * icon_move_1mm = new Icon(icon_size, bits_1mm_normal, MSG_ICON_MOVE_1MM());
+		Icon * icon_move_01mm = new Icon(icon_size, bits_01mm_normal, MSG_ICON_MOVE_01MM());
 
 		ScreenMenu * local_view = new ScreenMenu(MSG_SCREEN_MOVE_X_TITLE(), MSG_SCREEN_MOVE_X_TEXT());
 		local_view->add(screen_move);
@@ -753,10 +753,10 @@ namespace ui
 
 	static ScreenMenu * make_screen_move_y()
 	{
-		Icon * icon_back = new Icon(icon_size, bits_back_normal, bits_back_focused, MSG_BACK());
-		Icon * icon_move_10mm = new Icon(icon_size, bits_10mm_normal, bits_10mm_focused, MSG_ICON_MOVE_10MM());
-		Icon * icon_move_1mm = new Icon(icon_size, bits_1mm_normal, bits_1mm_focused, MSG_ICON_MOVE_1MM());
-		Icon * icon_move_01mm = new Icon(icon_size, bits_01mm_normal, bits_01mm_focused, MSG_ICON_MOVE_01MM());
+		Icon * icon_back = new Icon(icon_size, bits_back_normal, MSG_BACK());
+		Icon * icon_move_10mm = new Icon(icon_size, bits_10mm_normal, MSG_ICON_MOVE_10MM());
+		Icon * icon_move_1mm = new Icon(icon_size, bits_1mm_normal, MSG_ICON_MOVE_1MM());
+		Icon * icon_move_01mm = new Icon(icon_size, bits_01mm_normal, MSG_ICON_MOVE_01MM());
 
 		ScreenMenu * local_view = new ScreenMenu(MSG_SCREEN_MOVE_Y_TITLE(), MSG_SCREEN_MOVE_Y_TEXT());
 		local_view->add(screen_move);
@@ -772,10 +772,10 @@ namespace ui
 
 	static ScreenMenu * make_screen_move_z()
 	{
-		Icon * icon_back = new Icon(icon_size, bits_back_normal, bits_back_focused, MSG_BACK());
-		Icon * icon_move_10mm = new Icon(icon_size, bits_10mm_normal, bits_10mm_focused, MSG_ICON_MOVE_10MM());
-		Icon * icon_move_1mm = new Icon(icon_size, bits_1mm_normal, bits_1mm_focused, MSG_ICON_MOVE_1MM());
-		Icon * icon_move_01mm = new Icon(icon_size, bits_01mm_normal, bits_01mm_focused, MSG_ICON_MOVE_01MM());
+		Icon * icon_back = new Icon(icon_size, bits_back_normal, MSG_BACK());
+		Icon * icon_move_10mm = new Icon(icon_size, bits_10mm_normal, MSG_ICON_MOVE_10MM());
+		Icon * icon_move_1mm = new Icon(icon_size, bits_1mm_normal, MSG_ICON_MOVE_1MM());
+		Icon * icon_move_01mm = new Icon(icon_size, bits_01mm_normal, MSG_ICON_MOVE_01MM());
 
 		ScreenMenu * local_view = new ScreenMenu(MSG_SCREEN_MOVE_Z_TITLE(), MSG_SCREEN_MOVE_Z_TEXT());
 		local_view->add(screen_move);
@@ -791,9 +791,9 @@ namespace ui
 
 	static ScreenMenu * make_screen_move_e()
 	{
-		Icon * icon_back = new Icon(icon_size, bits_back_normal, bits_back_focused, MSG_BACK());
-		Icon * icon_move_1mm = new Icon(icon_size, bits_1mm_normal, bits_1mm_focused, MSG_ICON_MOVE_1MM());
-		Icon * icon_move_01mm = new Icon(icon_size, bits_01mm_normal, bits_01mm_focused, MSG_ICON_MOVE_01MM());
+		Icon * icon_back = new Icon(icon_size, bits_back_normal, MSG_BACK());
+		Icon * icon_move_1mm = new Icon(icon_size, bits_1mm_normal, MSG_ICON_MOVE_1MM());
+		Icon * icon_move_01mm = new Icon(icon_size, bits_01mm_normal, MSG_ICON_MOVE_01MM());
 
 		ScreenMenu * local_view = new ScreenMenu(MSG_SCREEN_MOVE_E_TITLE(), MSG_SCREEN_MOVE_E_TEXT());
 		local_view->add(screen_move);
@@ -936,8 +936,8 @@ namespace ui
 
 	static ScreenMenu * make_screen_offset()
 	{
-		Icon * icon_back = new Icon(icon_size, bits_back_normal, bits_back_focused, MSG_BACK());
-		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, bits_ok_focused, MSG_ICON_OK2());
+		Icon * icon_back = new Icon(icon_size, bits_back_normal, MSG_BACK());
+		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, MSG_ICON_OK2());
 
 		ScreenMenu * local_view = new ScreenMenu(MSG_SCREEN_OFFSET_INIT_TITLE(), MSG_SCREEN_OFFSET_INIT_TEXT());
 		local_view->add(screen_settings);
@@ -1006,8 +1006,8 @@ namespace ui
 
 	static ScreenMenu * make_screen_offset_finish()
 	{
-		Icon * icon_retry = new Icon(icon_size, bits_retry_normal, bits_retry_focused, MSG_ICON_RETRY());
-		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, bits_ok_focused, MSG_ICON_OK2());
+		Icon * icon_retry = new Icon(icon_size, bits_retry_normal, MSG_ICON_RETRY());
+		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, MSG_ICON_OK2());
 
 		ScreenMenu * local_view = new ScreenMenu(MSG_SCREEN_OFFSET_FINISH_TITLE(), MSG_SCREEN_OFFSET_FINISH_TEXT());
 		local_view->add(screen_offset_home);
@@ -1055,11 +1055,11 @@ namespace ui
 	
 	static ScreenPrint * make_screen_print()
 	{
-		IconStatus<PrinterState_t> * icon_play_pause = new IconStatus<PrinterState_t>(icon_size, bits_pause_normal, bits_pause_focused, bits_play_normal, bits_play_focused, MSG_ICON_PAUSE(), MSG_ICON_PLAY(), &PrintManager::single::instance());
-		Icon * icon_stop = new Icon(icon_size, bits_stop_normal, bits_stop_focused, MSG_ICON_STOP());
-		Icon * icon_change_filament = new Icon(icon_size, bits_change_filament_normal, bits_change_filament_focused, MSG_ICON_CHANGE_FILAMENT());
-		Icon * icon_change_speed = new Icon(icon_size, bits_change_speed_normal, bits_change_speed_focused, MSG_ICON_CHANGE_SPEED());
-		Icon * icon_temperature = new Icon(icon_size, bits_temperature_normal, bits_temperature_focused, MSG_ICON_TEMPERATURE());
+		IconStatus<PrinterState_t> * icon_play_pause = new IconStatus<PrinterState_t>(icon_size, bits_pause_normal, bits_play_normal, MSG_ICON_PAUSE(), MSG_ICON_PLAY(), &PrintManager::single::instance());
+		Icon * icon_stop = new Icon(icon_size, bits_stop_normal, MSG_ICON_STOP());
+		Icon * icon_change_filament = new Icon(icon_size, bits_change_filament_normal, MSG_ICON_CHANGE_FILAMENT());
+		Icon * icon_change_speed = new Icon(icon_size, bits_change_speed_normal, MSG_ICON_CHANGE_SPEED());
+		Icon * icon_temperature = new Icon(icon_size, bits_temperature_normal, MSG_ICON_TEMPERATURE());
 
 		ScreenPrint * local_view = new ScreenPrint(MSG_SCREEN_PRINT_PRINTING(), &temp::TemperatureManager::single::instance());
 		local_view->add(screen_play_pause);
@@ -1126,8 +1126,8 @@ namespace ui
 
 	static ScreenFile * make_screen_stop_confirm()
 	{
-		Icon * icon_back = new Icon(icon_size, bits_back_normal, bits_back_focused, MSG_BACK());
-		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, bits_ok_focused, MSG_ICON_OK2());
+		Icon * icon_back = new Icon(icon_size, bits_back_normal, MSG_BACK());
+		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, MSG_ICON_OK2());
 
 		ScreenFile * local_view = new ScreenFile(MSG_SCREEN_STOP_CONFIRM_TITLE());
 		local_view->add(screen_print);
@@ -1153,8 +1153,8 @@ namespace ui
 
 	static ScreenMenu * make_screen_change_init()
 	{
-		Icon * icon_back = new Icon(icon_size, bits_back_normal, bits_back_focused, MSG_BACK());
-		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, bits_ok_focused, MSG_ICON_OK2());
+		Icon * icon_back = new Icon(icon_size, bits_back_normal, MSG_BACK());
+		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, MSG_ICON_OK2());
 
 		ScreenMenu * local_view = new ScreenMenu(MSG_SCREEN_CHANGE_INIT_TITLE(), MSG_SCREEN_CHANGE_INIT_TEXT());
 		local_view->add(screen_print);
@@ -1237,8 +1237,8 @@ namespace ui
 
 	static ScreenMenu * make_screen_change_confirm()
 	{
-		Icon * icon_retry = new Icon(icon_size, bits_retry_normal, bits_retry_focused, MSG_ICON_RETRY());
-		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, bits_ok_focused, MSG_ICON_OK2());
+		Icon * icon_retry = new Icon(icon_size, bits_retry_normal, MSG_ICON_RETRY());
+		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, MSG_ICON_OK2());
 
 		ScreenMenu * local_view = new ScreenMenu(MSG_SCREEN_CHANGE_CONFIRM_TITLE(), MSG_SCREEN_CHANGE_CONFIRM_TEXT());
 		local_view->add(screen_change_pullout_info);
@@ -1284,8 +1284,8 @@ namespace ui
 
 	static ScreenMenu * make_screen_reset_init()
 	{
-		Icon * icon_back = new Icon(icon_size, bits_back_normal, bits_back_focused, MSG_BACK());
-		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, bits_ok_focused, MSG_ICON_OK2());
+		Icon * icon_back = new Icon(icon_size, bits_back_normal, MSG_BACK());
+		Icon * icon_ok = new Icon(icon_size, bits_ok_normal, MSG_ICON_OK2());
 
 		ScreenMenu * local_view = new ScreenMenu(MSG_SCREEN_RESET_INIT_TITLE(), MSG_SCREEN_RESET_INIT_TEXT());
 		local_view->add(screen_settings);
diff --git a/Marlin/ui/GuiPainter.cpp b/Marlin/ui/GuiPainter.cpp
index e7a722106d36..336b6052ed73 100644
--- a/Marlin/ui/GuiPainter.cpp
+++ b/Marlin/ui/GuiPainter.cpp
@@ -156,7 +156,7 @@ namespace ui
 		setFont(FontType_t::BODY_FONT);
 
 		// Draw SD small icon
-		drawBitmap(m_working_area.x_init, m_working_area.y_init, little_icon_width, little_icon_height, bits_sd_small);
+		drawBitmap(m_working_area.x_init, m_working_area.y_init, little_icon_width, little_icon_height, bits_sd_small, 0);
 
 		// Draw the percentage done
 		m_working_area.x_init += little_icon_width + 4;
@@ -571,9 +571,9 @@ namespace ui
 		m_impl.drawBox(x, y, w, h);
 	}
 
-	void GuiPainter::drawBitmap(uint8_t x, uint8_t y, uint8_t width, uint8_t height, const unsigned char* bitmap)
+	void GuiPainter::drawBitmap(uint8_t x, uint8_t y, uint8_t width, uint8_t height, const unsigned char* bitmap, uint8_t inverse)
 	{
-		m_impl.drawXBMP(x, y, width, height, bitmap);
+		m_impl.drawXBMP(x, y, width, height, bitmap,inverse);
 	}
 
 	void GuiPainter::coordinateXInit(uint8_t coordinate)
diff --git a/Marlin/ui/GuiPainter.h b/Marlin/ui/GuiPainter.h
index 7b8c05906360..c8dd52b57b8d 100644
--- a/Marlin/ui/GuiPainter.h
+++ b/Marlin/ui/GuiPainter.h
@@ -116,7 +116,7 @@ namespace ui
 
 			void drawLine(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2);
 			void drawBox(uint8_t x, uint8_t y, uint8_t w, uint8_t h);
-			void drawBitmap(uint8_t x, uint8_t y, uint8_t width, uint8_t height, const unsigned char* bitmap);
+			void drawBitmap(uint8_t x, uint8_t y, uint8_t width, uint8_t height, const unsigned char* bitmap, uint8_t inverse);
 
 			char * itostr2(const int &xx);
 
diff --git a/Marlin/ui/Icon.cpp b/Marlin/ui/Icon.cpp
index 3c977f44c341..d4de2a8307cd 100644
--- a/Marlin/ui/Icon.cpp
+++ b/Marlin/ui/Icon.cpp
@@ -30,10 +30,9 @@
 
 namespace ui
 {
-	Icon::Icon (Size const & size, const unsigned char* bitmap, const unsigned char * focused_bitmap, const char * text)
+	Icon::Icon (Size const & size, const unsigned char* bitmap, const char * text)
 		: m_size(size)
 		, m_bitmap(bitmap)
-		, m_focused_bitmap(focused_bitmap)
 		, m_text(text)
 	{ }
 
@@ -58,7 +57,7 @@ namespace ui
 	void Icon::draw(uint8_t x, uint8_t y, bool focused)
 	{
 		painter.setColorIndex(1);
-		painter.drawBitmap(x, y, m_size.width, m_size.height, (focused) ? m_focused_bitmap : m_bitmap);
+		painter.drawBitmap(x, y, m_size.width, m_size.height, m_bitmap, (focused) ? 1 : 0);
 	}
 
 	void Icon::show()
diff --git a/Marlin/ui/Icon.h b/Marlin/ui/Icon.h
index 59eb77618586..b8a4f70ce2c7 100644
--- a/Marlin/ui/Icon.h
+++ b/Marlin/ui/Icon.h
@@ -46,7 +46,7 @@ namespace ui
 	class Icon 
 	{	
 		public:
-			Icon(Size const & size, const unsigned char * bitmap, const unsigned char * focused_bitmap = 0, const char * text = 0);
+			Icon(Size const & size, const unsigned char * bitmap, const char * text = 0);
 			virtual ~Icon();
 
 			uint8_t const & width() const;
@@ -59,7 +59,6 @@ namespace ui
 		protected:
 			Size m_size;
 			const unsigned char * m_bitmap;
-			const unsigned char * m_focused_bitmap;
 			const char * m_text;
 	};
 }
diff --git a/Marlin/ui/IconStatus.h b/Marlin/ui/IconStatus.h
index 71d9dc1d8226..3baaa0c53f0e 100644
--- a/Marlin/ui/IconStatus.h
+++ b/Marlin/ui/IconStatus.h
@@ -39,7 +39,7 @@ namespace ui
 		class IconStatus : public Icon, public Observer<T>
 	{
 		public:
-			IconStatus(Size const & size, const unsigned char * bitmap, const unsigned char * focused_bitmap, const unsigned char * alt_bitmap, const unsigned char * alt_focused_bitmap, const char * text, const char * alt_text, Subject<T> * model);
+			IconStatus(Size const & size, const unsigned char * bitmap, const unsigned char * alt_bitmap, const char * text, const char * alt_text, Subject<T> * model);
 			virtual ~IconStatus();
 
 			void update(T value);
@@ -51,15 +51,13 @@ namespace ui
 		private:
 			T m_value;
 			const unsigned char * m_alt_bitmap;
-			const unsigned char * m_alt_focused_bitmap;
 			const char * m_alt_text;
 	};
 
 	template <typename T>
-	IconStatus<T>::IconStatus(Size const & size, const unsigned char * bitmap, const unsigned char * focused_bitmap, const unsigned char * alt_bitmap, const unsigned char * alt_focused_bitmap, const char * text, const char * alt_text, Subject<T> * model)
-		: Icon(size, bitmap, focused_bitmap, text)
+	IconStatus<T>::IconStatus(Size const & size, const unsigned char * bitmap, const unsigned char * alt_bitmap, const char * text, const char * alt_text, Subject<T> * model)
+		: Icon(size, bitmap, text)
 		, m_alt_bitmap(alt_bitmap)
-		, m_alt_focused_bitmap(alt_focused_bitmap)
 		, m_alt_text(alt_text)
 		, Observer<T>(model)
 	{ }
@@ -94,11 +92,11 @@ namespace ui
 
     	if (m_value)
     	{
-			painter.drawBitmap(x, y, m_size.width, m_size.height, (focused) ? m_alt_focused_bitmap : m_alt_bitmap);
+			painter.drawBitmap(x, y, m_size.width, m_size.height, m_alt_bitmap, (focused) ? 1 : 0);
 		}
 		else
 		{
-			painter.drawBitmap(x, y, m_size.width, m_size.height, (focused) ? m_focused_bitmap : m_bitmap);
+			painter.drawBitmap(x, y, m_size.width, m_size.height, m_bitmap, (focused) ? 1 : 0);
 		}
 	}
 
diff --git a/Marlin/ui/IconWidget.h b/Marlin/ui/IconWidget.h
index 1c296de75b1f..fe3f8c5811bc 100644
--- a/Marlin/ui/IconWidget.h
+++ b/Marlin/ui/IconWidget.h
@@ -38,7 +38,7 @@ namespace ui
 		class IconWidget : public Icon, public Observer<T>
 	{
 		public:
-			IconWidget(Size const & size, const unsigned char* bitmap, const unsigned char * focused_bitmap, const char * text, Subject<T> * model);
+			IconWidget(Size const & size, const unsigned char* bitmap, const char * text, Subject<T> * model);
 			virtual ~IconWidget();
 
 			void update(T value);
@@ -51,8 +51,8 @@ namespace ui
 	};
 
 	template <typename T>
-	IconWidget<T>::IconWidget(Size const & size, const unsigned char* bitmap, const unsigned char * focused_bitmap, const char * text, Subject<T> * model)
-		: Icon(size, bitmap, focused_bitmap, text)
+	IconWidget<T>::IconWidget(Size const & size, const unsigned char* bitmap, const char * text, Subject<T> * model)
+		: Icon(size, bitmap, text)
 		, Observer<T>(model)
 	{ }
 
@@ -70,7 +70,7 @@ namespace ui
 	void IconWidget<T>::draw(uint8_t x, uint8_t y, bool focused)
 	{
 		painter.setColorIndex(1);
-		painter.drawBitmap(x, y, m_size.width, m_size.height, (focused) ? m_focused_bitmap : m_bitmap);
+		painter.drawBitmap(x, y, m_size.width, m_size.height, m_bitmap, (focused) ? 1 : 0);
 
 		if(focused)
 		{
diff --git a/Marlin/ui/IconWidgetBed.h b/Marlin/ui/IconWidgetBed.h
index 8e7fe7da907b..df2fb17ebc9b 100644
--- a/Marlin/ui/IconWidgetBed.h
+++ b/Marlin/ui/IconWidgetBed.h
@@ -40,7 +40,7 @@ namespace ui
 		class IconWidgetBed : public Icon, public Observer<T>
 	{
 		public:
-			IconWidgetBed(Size const & size, const unsigned char* bitmap, const unsigned char * focused_bitmap, const unsigned char* bitmap_2, const unsigned char * focused_bitmap_2, const char * text, Subject<T> * model);
+			IconWidgetBed(Size const & size, const unsigned char* bitmap, const unsigned char* bitmap_2, const char * text, Subject<T> * model);
 			virtual ~IconWidgetBed();
 
 			void update(T value);
@@ -53,16 +53,14 @@ namespace ui
 			bool m_above_switch;
 			
 			const unsigned char * m_bitmap_2;
-			const unsigned char * m_focused_bitmap_2;
 	};
 
 	template <typename T>
-	IconWidgetBed<T>::IconWidgetBed(Size const & size, const unsigned char* bitmap, const unsigned char * focused_bitmap, const unsigned char* bitmap_2, const unsigned char * focused_bitmap_2, const char * text, Subject<T> * model)
-		: Icon(size, bitmap, focused_bitmap, text)
+	IconWidgetBed<T>::IconWidgetBed(Size const & size, const unsigned char* bitmap, const unsigned char* bitmap_2, const char * text, Subject<T> * model)
+		: Icon(size, bitmap, text)
 		, Observer<T>(model)
 		, m_above_switch(false)
 		, m_bitmap_2(bitmap_2)
-		, m_focused_bitmap_2(focused_bitmap_2)
 	{ }
 
 	template <typename T>
@@ -89,16 +87,16 @@ namespace ui
 		
 		if(temp::TemperatureManager::single::instance().getBedCurrentTemperature() < (BED_HOT_TEMP + bed_histeresis))
 		{
-			painter.drawBitmap(x, y, m_size.width, m_size.height, (focused) ? m_focused_bitmap : m_bitmap);
+			painter.drawBitmap(x, y, m_size.width, m_size.height, m_bitmap, (focused) ? 1 : 0);
 			m_above_switch = false;
 		}
 		else
 		{
-			painter.drawBitmap(x, y, m_size.width, m_size.height, (focused) ? m_focused_bitmap_2 : m_bitmap_2);
+			painter.drawBitmap(x, y, m_size.width, m_size.height, m_bitmap_2, (focused) ? 1 : 0);
 			m_above_switch = true;
 		}
 	#else
-		painter.drawBitmap(x, y, m_size.width, m_size.height, (focused) ? m_focused_bitmap : m_bitmap);
+		painter.drawBitmap(x, y, m_size.width, m_size.height, m_bitmap, (focused) ? 1 : 0);
 	#endif
 	
 		if(focused)
diff --git a/Marlin/ui/ScreenAbout.cpp b/Marlin/ui/ScreenAbout.cpp
index 057bf3daa6a2..c52eff5cb0a0 100644
--- a/Marlin/ui/ScreenAbout.cpp
+++ b/Marlin/ui/ScreenAbout.cpp
@@ -58,7 +58,7 @@ namespace ui
 			uint8_t x_offset = 6;
 			uint8_t y_offset = 4;
 			painter.setColorIndex(1);
-			painter.drawBitmap(x_init + x_offset, y_init + y_offset, logo_width, logo_height, bits_logo_about);
+			painter.drawBitmap(x_init + x_offset, y_init + y_offset, logo_width, logo_height, bits_logo_about,0);
 			//Print machine name centered
 			uint8_t h_pad = strlen_P(MACHINE_NAME)*6/2;
 			x_init = x_offset + logo_width + 8;
diff --git a/Marlin/ui/ScreenAnimation.h b/Marlin/ui/ScreenAnimation.h
index b895a8aa6481..04cdde62ea07 100644
--- a/Marlin/ui/ScreenAnimation.h
+++ b/Marlin/ui/ScreenAnimation.h
@@ -155,28 +155,28 @@ namespace ui
 				switch(m_frame)
 				{
 					case 0:
-						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_1);
+						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_1,0);
 						break;
 					case 1:
-						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_2);
+						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_2,0);
 						break;
 					case 2:
-						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_3);
+						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_3,0);
 						break;
 					case 3:
-						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_4);
+						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_4,0);
 						break;
 					case 4:
-						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_5);
+						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_5,0);
 						break;
 					case 5:
-						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_6);
+						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_6,0);
 						break;
 					case 6:
-						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_7);
+						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_7,0);
 						break;
 					case 7:
-						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_8);
+						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_8,0);
 						break;
 				}
 
diff --git a/Marlin/ui/ScreenCooldown.cpp b/Marlin/ui/ScreenCooldown.cpp
index 152edb9581e0..52083ee41676 100644
--- a/Marlin/ui/ScreenCooldown.cpp
+++ b/Marlin/ui/ScreenCooldown.cpp
@@ -96,28 +96,28 @@ namespace ui
 				switch(m_frame)
 				{
 					case 0:
-						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_1);
+						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_1,0);
 						break;
 					case 1:
-						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_2);
+						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_2,0);
 						break;
 					case 2:
-						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_3);
+						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_3,0);
 						break;
 					case 3:
-						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_4);
+						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_4,0);
 						break;
 					case 4:
-						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_5);
+						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_5,0);
 						break;
 					case 5:
-						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_6);
+						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_6,0);
 						break;
 					case 6:
-						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_7);
+						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_7,0);
 						break;
 					case 7:
-						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_8);
+						painter.drawBitmap(10, 40, progress_width, progress_height, bits_progress_8,0);
 						break;
 				}
 
diff --git a/Marlin/ui/ScreenEmergency.cpp b/Marlin/ui/ScreenEmergency.cpp
index 446157aac344..35631f98d1f3 100644
--- a/Marlin/ui/ScreenEmergency.cpp
+++ b/Marlin/ui/ScreenEmergency.cpp
@@ -76,7 +76,7 @@ namespace ui
 			uint8_t y_offset = 9;
 
 			Area temp_area = painter.getWorkingArea();
-			painter.drawBitmap(temp_area.x_init + x_offset, temp_area.y_init + y_offset, emergency_width, emergency_height, bits_emergency);
+			painter.drawBitmap(temp_area.x_init + x_offset, temp_area.y_init + y_offset, emergency_width, emergency_height, bits_emergency,0);
 
 			Area text_area(40, 14, 127, 54);
 			painter.setWorkingArea(text_area);
diff --git a/Marlin/ui/ScreenError.cpp b/Marlin/ui/ScreenError.cpp
index 0d9bc8bc3cad..da09175acb88 100644
--- a/Marlin/ui/ScreenError.cpp
+++ b/Marlin/ui/ScreenError.cpp
@@ -65,7 +65,7 @@ namespace ui
 			uint8_t y_offset = 9;
 
 			Area temp_area = painter.getWorkingArea();
-			painter.drawBitmap(temp_area.x_init + x_offset, temp_area.y_init + y_offset, emergency_width, emergency_height, bits_emergency);
+			painter.drawBitmap(temp_area.x_init + x_offset, temp_area.y_init + y_offset, emergency_width, emergency_height, bits_emergency,0);
 
 			Area text_area(40, 14, 127, 54);
 			painter.setWorkingArea(text_area);
diff --git a/Marlin/ui/ScreenInactivity.cpp b/Marlin/ui/ScreenInactivity.cpp
index 58678330fa71..6bf093ea85a5 100644
--- a/Marlin/ui/ScreenInactivity.cpp
+++ b/Marlin/ui/ScreenInactivity.cpp
@@ -81,7 +81,7 @@ namespace ui
 				uint8_t y_end = painter.coordinateYEnd();
 				uint8_t x_offset = 9;
 				uint8_t y_offset = 9;
-				painter.drawBitmap(x_init + x_offset, y_init + y_offset, logo_width, logo_height, bits_logo_about);
+				painter.drawBitmap(x_init + x_offset, y_init + y_offset, logo_width, logo_height, bits_logo_about,0);
 
 				//Print text
 				x_offset = 8;
@@ -97,7 +97,7 @@ namespace ui
 				//Paint bitmap inactivity on the right
 				x_init = 128 - inactivity_width - x_offset;
 				y_init += 3;
-				painter.drawBitmap(x_init, y_init + y_offset, inactivity_width, inactivity_height, icon_inactivity);
+				painter.drawBitmap(x_init, y_init + y_offset, inactivity_width, inactivity_height, icon_inactivity,0);
 
 				//Print temp
 				char temp[21] = "";
@@ -119,28 +119,28 @@ namespace ui
 				switch(m_frame)
 				{
 					case 0:
-						painter.drawBitmap(x_init + 2, y_init + 2, progress_width, progress_height, bits_progress_1);
+						painter.drawBitmap(x_init + 2, y_init + 2, progress_width, progress_height, bits_progress_1,0);
 						break;
 					case 1:
-						painter.drawBitmap(x_init + 2, y_init + 2, progress_width, progress_height, bits_progress_2);
+						painter.drawBitmap(x_init + 2, y_init + 2, progress_width, progress_height, bits_progress_2,0);
 						break;
 					case 2:
-						painter.drawBitmap(x_init + 2, y_init + 2, progress_width, progress_height, bits_progress_3);
+						painter.drawBitmap(x_init + 2, y_init + 2, progress_width, progress_height, bits_progress_3,0);
 						break;
 					case 3:
-						painter.drawBitmap(x_init + 2, y_init + 2, progress_width, progress_height, bits_progress_4);
+						painter.drawBitmap(x_init + 2, y_init + 2, progress_width, progress_height, bits_progress_4,0);
 						break;
 					case 4:
-						painter.drawBitmap(x_init + 2, y_init + 2, progress_width, progress_height, bits_progress_5);
+						painter.drawBitmap(x_init + 2, y_init + 2, progress_width, progress_height, bits_progress_5,0);
 						break;
 					case 5:
-						painter.drawBitmap(x_init + 2, y_init + 2, progress_width, progress_height, bits_progress_6);
+						painter.drawBitmap(x_init + 2, y_init + 2, progress_width, progress_height, bits_progress_6,0);
 						break;
 					case 6:
-						painter.drawBitmap(x_init + 2, y_init + 2, progress_width, progress_height, bits_progress_7);
+						painter.drawBitmap(x_init + 2, y_init + 2, progress_width, progress_height, bits_progress_7,0);
 						break;
 					case 7:
-						painter.drawBitmap(x_init + 2, y_init + 2, progress_width, progress_height, bits_progress_8);
+						painter.drawBitmap(x_init + 2, y_init + 2, progress_width, progress_height, bits_progress_8,0);
 						break;
 				}
 
diff --git a/Marlin/ui/ScreenLanguage.h b/Marlin/ui/ScreenLanguage.h
index a20565e6dcc1..607574eda4f3 100644
--- a/Marlin/ui/ScreenLanguage.h
+++ b/Marlin/ui/ScreenLanguage.h
@@ -53,7 +53,7 @@ namespace ui
 			const Language m_default;
 			uint8_t m_language;
 			const uint8_t m_min = 0;
-			const uint8_t m_max = 7;
+			const uint8_t m_max = 6;
 	};
 }
 #endif //SCREEN_LANGUAGE_H
diff --git a/Marlin/ui/ScreenList.cpp b/Marlin/ui/ScreenList.cpp
index e9707035c866..fb976cbd3ea5 100644
--- a/Marlin/ui/ScreenList.cpp
+++ b/Marlin/ui/ScreenList.cpp
@@ -113,7 +113,7 @@ namespace ui
 			{
 				painter.setColorIndex(1);
 				painter.setFont(FontType_t::BODY_FONT);
-				painter.drawBitmap(x_init, y_init + 3, little_icon_width, little_icon_height, bits_updir_small);
+				painter.drawBitmap(x_init, y_init + 3, little_icon_width, little_icon_height, bits_updir_small,0);
 				painter.setPrintPos(x_init + 6, y_init + 3);
 				painter.print("/");
 				painter.setPrintPos(x_init + 12, y_init + 3);
@@ -161,13 +161,13 @@ namespace ui
 				{
 					if(entry->type == CacheEntryType_t::BACK_ENTRY)
 					{
-						painter.drawBitmap(painter.coordinateXInit() + 1, painter.coordinateYInit() + i * (max_font_height + 1), little_icon_width, little_icon_height, bits_back_small);
+						painter.drawBitmap(painter.coordinateXInit() + 1, painter.coordinateYInit() + i * (max_font_height + 1), little_icon_width, little_icon_height, bits_back_small,0);
 						painter.setPrintPos(painter.coordinateXInit() + 9, painter.coordinateYInit() + i * (max_font_height + 1));
 						painter.print_P(MSG_SCREEN_SD_LIST_BACK());
 					}
 					else
 					{
-						painter.drawBitmap(painter.coordinateXInit() + 1, painter.coordinateYInit() + i * (max_font_height + 1), little_icon_width, little_icon_height, bits_updir_small);
+						painter.drawBitmap(painter.coordinateXInit() + 1, painter.coordinateYInit() + i * (max_font_height + 1), little_icon_width, little_icon_height, bits_updir_small,0);
 						painter.setPrintPos(painter.coordinateXInit() + 9, painter.coordinateYInit() + i * (max_font_height + 1));
 						painter.print_P(MSG_SCREEN_SD_LIST_PREV());
 					}
@@ -176,7 +176,7 @@ namespace ui
 				{
 					if (entry->type == FOLDER_ENTRY)
 					{
-						painter.drawBitmap(painter.coordinateXInit() + 1, painter.coordinateYInit() + i * (max_font_height + 1), little_icon_width, little_icon_height, bits_folder_small);
+						painter.drawBitmap(painter.coordinateXInit() + 1, painter.coordinateYInit() + i * (max_font_height + 1), little_icon_width, little_icon_height, bits_folder_small,0);
 					}
 					painter.setPrintPos(painter.coordinateXInit() + 9, painter.coordinateYInit() + i * (max_font_height + 1));
 					if (entry == m_browsing_cache->getSelectedEntry())
diff --git a/Marlin/ui/ScreenSerial.cpp b/Marlin/ui/ScreenSerial.cpp
index d6e4881ef307..bd1bd065c7d3 100644
--- a/Marlin/ui/ScreenSerial.cpp
+++ b/Marlin/ui/ScreenSerial.cpp
@@ -83,7 +83,7 @@ namespace ui
 				uint8_t x_offset = 6;
 				uint8_t y_offset = 4;
 				painter.setColorIndex(1);
-				painter.drawBitmap(x_init + x_offset, y_init + y_offset, serial_width, serial_height, bits_serial);
+				painter.drawBitmap(x_init + x_offset, y_init + y_offset, serial_width, serial_height, bits_serial,0);
 
 				//Print state
 				Area text_area(x_init + x_offset + serial_width, y_init, 127, 63);
diff --git a/Marlin/ui/ScreenSplash.cpp b/Marlin/ui/ScreenSplash.cpp
index 49be05cc78c0..655cf21b7a19 100644
--- a/Marlin/ui/ScreenSplash.cpp
+++ b/Marlin/ui/ScreenSplash.cpp
@@ -94,7 +94,7 @@ namespace ui
 		painter.firstPage();
 		do
 		{
-			painter.drawBitmap(34,10,splash_width,splash_height,bits_logo_splash);
+			painter.drawBitmap(splash_x, splash_y, splash_width, splash_height, bits_logo_about,0);
 		} while(painter.nextPage());
 
 	}
diff --git a/Marlin/ui/ScreenStop.cpp b/Marlin/ui/ScreenStop.cpp
index 8b79b50cbb85..08a7b4d8f007 100644
--- a/Marlin/ui/ScreenStop.cpp
+++ b/Marlin/ui/ScreenStop.cpp
@@ -54,7 +54,7 @@ namespace ui
 			painter.setPrintPos(padding, 43);
 			painter.print(height);
 
-			painter.drawBitmap(127 - strlen(total_time) * 6 - padding - icon_clock_width - 2, 43, icon_clock_width, icon_clock_height, icon_clock);
+			painter.drawBitmap(127 - strlen(total_time) * 6 - padding - icon_clock_width - 2, 43, icon_clock_width, icon_clock_height, icon_clock,0);
 			painter.setPrintPos( 127 - strlen(total_time) * 6 - padding, 43);
 			painter.print(total_time);
 
diff --git a/hephestos.sh b/hephestos.sh
new file mode 100755
index 000000000000..58ee9308c53d
--- /dev/null
+++ b/hephestos.sh
@@ -0,0 +1,14 @@
+#!/bin/bash -x
+
+export HARDWARE="hephestos_2"
+export WWW_DIR="/tmp/marlin/build"
+export FW_DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
+export ARDUINO="${FW_DIR}/../arduino-1.6.7"
+export WORKSPACE="${FW_DIR}/Marlin"
+export CONFIG_DIR_DEST="${FW_DIR}/Marlin"
+export CONFIG_DIR="${CONFIG_DIR_DEST}/config"
+export BUILD_NUMBER="jerome"
+
+mkdir -p "${WWW_DIR}"
+
+source "${FW_DIR}/entrypoint.sh"