Add HAS_FILAMENT_RUNOUT_DISTANCE

Marlin/src/feature/runout.cpp

   runout.filament_present(extruder); // calls response.filament_present(extruder)
 }
 
-#if ENABLED(FILAMENT_MOTION_SENSOR)
-  uint8_t FilamentSensorEncoder::motion_detected;
-#endif
-
-#ifdef FILAMENT_RUNOUT_DISTANCE_MM
+#if HAS_FILAMENT_RUNOUT_DISTANCE
   float RunoutResponseDelayed::runout_distance_mm = FILAMENT_RUNOUT_DISTANCE_MM;
   volatile float RunoutResponseDelayed::runout_mm_countdown[EXTRUDERS];
+  #if ENABLED(FILAMENT_MOTION_SENSOR)
+    uint8_t FilamentSensorEncoder::motion_detected;
+  #endif
 #else
   int8_t RunoutResponseDebounced::runout_count; // = 0
 #endif

Marlin/src/feature/runout.h

       response.filament_present(extruder);
     }
 
-    #ifdef FILAMENT_RUNOUT_DISTANCE_MM
+    #if HAS_FILAMENT_RUNOUT_DISTANCE
       static inline float& runout_distance() { return response.runout_distance_mm; }
       static inline void set_runout_distance(const float &mm) { response.runout_distance_mm = mm; }
     #endif
       if ( enabled && !filament_ran_out
         && (printingIsActive() || TERN0(ADVANCED_PAUSE_FEATURE, did_pause_print))
       ) {
-        #ifdef FILAMENT_RUNOUT_DISTANCE_MM
-          cli(); // Prevent RunoutResponseDelayed::block_completed from accumulating here
-        #endif
+        TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, cli()); // Prevent RunoutResponseDelayed::block_completed from accumulating here
         response.run();
         sensor.run();
         const bool ran_out = response.has_run_out();
-        #ifdef FILAMENT_RUNOUT_DISTANCE_MM
-          sei();
-        #endif
+        TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, sei());
         if (ran_out) {
           filament_ran_out = true;
           event_filament_runout();
 
 /********************************* RESPONSE TYPE *********************************/
 
-#ifdef FILAMENT_RUNOUT_DISTANCE_MM
+#if HAS_FILAMENT_RUNOUT_DISTANCE
 
   // RunoutResponseDelayed triggers a runout event only if the length
   // of filament specified by FILAMENT_RUNOUT_DISTANCE_MM has been fed
       }
   };
 
-#else // !FILAMENT_RUNOUT_DISTANCE_MM
+#else // !HAS_FILAMENT_RUNOUT_DISTANCE
 
   // RunoutResponseDebounced triggers a runout event after a runout
   // condition has been detected runout_threshold times in a row.
       static inline void filament_present(const uint8_t)          { runout_count = runout_threshold; }
   };
 
-#endif // !FILAMENT_RUNOUT_DISTANCE_MM
+#endif // !HAS_FILAMENT_RUNOUT_DISTANCE
 
 /********************************* TEMPLATE SPECIALIZATION *********************************/
 
 typedef TFilamentMonitor<
-  #ifdef FILAMENT_RUNOUT_DISTANCE_MM
-    RunoutResponseDelayed,
-    TERN(FILAMENT_MOTION_SENSOR, FilamentSensorEncoder, FilamentSensorSwitch)
-  #else
-    RunoutResponseDebounced, FilamentSensorSwitch
-  #endif
-> FilamentMonitor;
+          TERN(HAS_FILAMENT_RUNOUT_DISTANCE, RunoutResponseDelayed, RunoutResponseDebounced),
+          TERN(FILAMENT_MOTION_SENSOR, FilamentSensorEncoder, FilamentSensorSwitch)
+        > FilamentMonitor;
 
 extern FilamentMonitor runout;

Marlin/src/gcode/feature/runout/M412.cpp

  */
 void GcodeSuite::M412() {
   if (parser.seen("RS"
-    #ifdef FILAMENT_RUNOUT_DISTANCE_MM
-      "D"
-    #endif
-    #if ENABLED(HOST_ACTION_COMMANDS)
-      "H"
-    #endif
+    TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, "D")
+    TERN_(HOST_ACTION_COMMANDS, "H")
   )) {
     #if ENABLED(HOST_ACTION_COMMANDS)
       if (parser.seen('H')) runout.host_handling = parser.value_bool();
     const bool seenR = parser.seen('R'), seenS = parser.seen('S');
     if (seenR || seenS) runout.reset();
     if (seenS) runout.enabled = parser.value_bool();
-    #ifdef FILAMENT_RUNOUT_DISTANCE_MM
+    #if HAS_FILAMENT_RUNOUT_DISTANCE
       if (parser.seen('D')) runout.set_runout_distance(parser.value_linear_units());
     #endif
   }
     SERIAL_ECHO_START();
     SERIAL_ECHOPGM("Filament runout ");
     serialprintln_onoff(runout.enabled);
-    #ifdef FILAMENT_RUNOUT_DISTANCE_MM
+    #if HAS_FILAMENT_RUNOUT_DISTANCE
       SERIAL_ECHOLNPAIR("Filament runout distance (mm): ", runout.runout_distance());
     #endif
   }

Marlin/src/inc/Conditionals_adv.h

 
 #if ENABLED(FILAMENT_RUNOUT_SENSOR)
   #define HAS_FILAMENT_SENSOR 1
+  #ifdef FILAMENT_RUNOUT_DISTANCE_MM
+    #define HAS_FILAMENT_RUNOUT_DISTANCE 1
+  #endif
 #endif
 
 // Let SD_FINISHED_RELEASECOMMAND stand in for SD_FINISHED_STEPPERRELEASE

Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/screens/filament_runout_screen.cpp

   w.heading(   GET_TEXT_F(MSG_FILAMENT));
   w.toggle( 2, GET_TEXT_F(MSG_RUNOUT_SENSOR), getFilamentRunoutEnabled());
 
-  #ifdef FILAMENT_RUNOUT_DISTANCE_MM
+  #if HAS_FILAMENT_RUNOUT_DISTANCE
     extern const char NUL_STR[];
     w.heading(GET_TEXT_F(MSG_RUNOUT_DISTANCE_MM));
     w.units(GET_TEXT_F(MSG_UNITS_MM));
   const float increment = getIncrement();
   switch (tag) {
     case 2: setFilamentRunoutEnabled(!getFilamentRunoutEnabled()); break;
-    #ifdef FILAMENT_RUNOUT_DISTANCE_MM
+    #if HAS_FILAMENT_RUNOUT_DISTANCE
       case  10: UI_DECREMENT(FilamentRunoutDistance_mm); break;
       case  11: UI_INCREMENT(FilamentRunoutDistance_mm); break;
     #endif

Marlin/src/lcd/extui/ui_api.cpp

     bool getFilamentRunoutEnabled()                 { return runout.enabled; }
     void setFilamentRunoutEnabled(const bool value) { runout.enabled = value; }
 
-    #ifdef FILAMENT_RUNOUT_DISTANCE_MM
+    #if HAS_FILAMENT_RUNOUT_DISTANCE
       float getFilamentRunoutDistance_mm()                 { return runout.runout_distance(); }
       void setFilamentRunoutDistance_mm(const float value) { runout.set_runout_distance(constrain(value, 0, 999)); }
     #endif

Marlin/src/lcd/extui/ui_api.h

     bool getFilamentRunoutEnabled();
     void setFilamentRunoutEnabled(const bool);
 
-    #ifdef FILAMENT_RUNOUT_DISTANCE_MM
+    #if HAS_FILAMENT_RUNOUT_DISTANCE
       float getFilamentRunoutDistance_mm();
       void setFilamentRunoutDistance_mm(const float);
     #endif

Marlin/src/lcd/menu/menu_advanced.cpp

   #include "../../module/temperature.h"
 #endif
 
-#if ENABLED(FILAMENT_RUNOUT_SENSOR) && FILAMENT_RUNOUT_DISTANCE_MM
+#if HAS_FILAMENT_RUNOUT_DISTANCE
   #include "../../feature/runout.h"
 #endif
 
       #endif
     #endif
 
-    #if ENABLED(FILAMENT_RUNOUT_SENSOR) && FILAMENT_RUNOUT_DISTANCE_MM
+    #if HAS_FILAMENT_RUNOUT_DISTANCE
       editable.decimal = runout.runout_distance();
       EDIT_ITEM(float3, MSG_RUNOUT_DISTANCE_MM, &editable.decimal, 1, 30,
         []{ runout.set_runout_distance(editable.decimal); }, true

Marlin/src/module/configuration_store.cpp

       #else
         constexpr bool runout_sensor_enabled = true;
       #endif
-      #if HAS_FILAMENT_SENSOR && defined(FILAMENT_RUNOUT_DISTANCE_MM)
+      #if HAS_FILAMENT_RUNOUT_DISTANCE
         const float &runout_distance_mm = runout.runout_distance();
       #else
         constexpr float runout_distance_mm = 0;
 
         float runout_distance_mm;
         EEPROM_READ(runout_distance_mm);
-        #if HAS_FILAMENT_SENSOR && defined(FILAMENT_RUNOUT_DISTANCE_MM)
+        #if HAS_FILAMENT_RUNOUT_DISTANCE
           if (!validating) runout.set_runout_distance(runout_distance_mm);
         #endif
       }
   #if HAS_FILAMENT_SENSOR
     runout.enabled = true;
     runout.reset();
-    #ifdef FILAMENT_RUNOUT_DISTANCE_MM
-      runout.set_runout_distance(FILAMENT_RUNOUT_DISTANCE_MM);
-    #endif
+    TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, runout.set_runout_distance(FILAMENT_RUNOUT_DISTANCE_MM));
   #endif
 
   //
       CONFIG_ECHO_START();
       SERIAL_ECHOLNPAIR(
         "  M412 S", int(runout.enabled)
-        #ifdef FILAMENT_RUNOUT_DISTANCE_MM
+        #if HAS_FILAMENT_RUNOUT_DISTANCE
           , " D", LINEAR_UNIT(runout.runout_distance())
         #endif
       );

Marlin/src/module/stepper.cpp

   #include "../feature/mixing.h"
 #endif
 
-#ifdef FILAMENT_RUNOUT_DISTANCE_MM
+#if HAS_FILAMENT_RUNOUT_DISTANCE
   #include "../feature/runout.h"
 #endif
 
           PAGE_SEGMENT_UPDATE_POS(E);
         }
       #endif
-      #ifdef FILAMENT_RUNOUT_DISTANCE_MM
-        runout.block_completed(current_block);
-      #endif
+      TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, runout.block_completed(current_block));
       discard_current_block();
     }
     else {