ENABLE_GCODE_VIEWER set as default in libslic3r

src/libslic3r/AppConfig.cpp

@@ -38,9 +38,7 @@ void AppConfig::reset()
 // Override missing or keys with their defaults.
 void AppConfig::set_defaults()
 {
-#if ENABLE_GCODE_VIEWER
     if (m_mode == EAppMode::Editor) {
-#endif // ENABLE_GCODE_VIEWER
         // Reset the empty fields to defaults.
         if (get("autocenter").empty())
             set("autocenter", "0");
@@ -98,17 +96,6 @@ void AppConfig::set_defaults()
         if (get("auto_toolbar_size").empty())
             set("auto_toolbar_size", "100");
 
-#if !ENABLE_GCODE_VIEWER
-        if (get("use_perspective_camera").empty())
-            set("use_perspective_camera", "1");
-
-        if (get("use_free_camera").empty())
-            set("use_free_camera", "0");
-
-        if (get("reverse_mouse_wheel_zoom").empty())
-            set("reverse_mouse_wheel_zoom", "0");
-#endif // !ENABLE_GCODE_VIEWER
-
 #if ENABLE_ENVIRONMENT_MAP
         if (get("use_environment_map").empty())
             set("use_environment_map", "0");
@@ -116,7 +103,6 @@ void AppConfig::set_defaults()
 
         if (get("use_inches").empty())
             set("use_inches", "0");
-#if ENABLE_GCODE_VIEWER
     }
 
     if (get("seq_top_layer_only").empty())
@@ -130,7 +116,6 @@ void AppConfig::set_defaults()
 
     if (get("reverse_mouse_wheel_zoom").empty())
         set("reverse_mouse_wheel_zoom", "0");
-#endif // ENABLE_GCODE_VIEWER
 
     if (get("show_splash_screen").empty())
         set("show_splash_screen", "1");
@@ -247,14 +232,10 @@ void AppConfig::save()
 
     boost::nowide::ofstream c;
     c.open(path_pid, std::ios::out | std::ios::trunc);
-#if ENABLE_GCODE_VIEWER
     if (m_mode == EAppMode::Editor)
         c << "# " << Slic3r::header_slic3r_generated() << std::endl;
     else
         c << "# " << Slic3r::header_gcodeviewer_generated() << std::endl;
-#else
-    c << "# " << Slic3r::header_slic3r_generated() << std::endl;
-#endif // ENABLE_GCODE_VIEWER
     // Make sure the "no" category is written first.
     for (const std::pair<std::string, std::string> &kvp : m_storage[""])
         c << kvp.first << " = " << kvp.second << std::endl;
@@ -455,15 +436,11 @@ void AppConfig::reset_selections()
 
 std::string AppConfig::config_path()
 {
-#if ENABLE_GCODE_VIEWER
     std::string path = (m_mode == EAppMode::Editor) ?
         (boost::filesystem::path(Slic3r::data_dir()) / (SLIC3R_APP_KEY ".ini")).make_preferred().string() :
         (boost::filesystem::path(Slic3r::data_dir()) / (GCODEVIEWER_APP_KEY ".ini")).make_preferred().string();
 
     return path;
-#else
-    return (boost::filesystem::path(Slic3r::data_dir()) / (SLIC3R_APP_KEY ".ini")).make_preferred().string();
-#endif // ENABLE_GCODE_VIEWER
 }
 
 std::string AppConfig::version_check_url() const
@@ -474,11 +451,7 @@ std::string AppConfig::version_check_url() const
 
 bool AppConfig::exists()
 {
-#if ENABLE_GCODE_VIEWER
     return boost::filesystem::exists(config_path());
-#else
-    return boost::filesystem::exists(AppConfig::config_path());
-#endif // ENABLE_GCODE_VIEWER
 }
 
 }; // namespace Slic3r

src/libslic3r/AppConfig.hpp

@@ -15,7 +15,6 @@ namespace Slic3r {
 class AppConfig
 {
 public:
-#if ENABLE_GCODE_VIEWER
 	enum class EAppMode : unsigned char
 	{
 		Editor,
@@ -23,14 +22,9 @@ public:
 	};
 
 	explicit AppConfig(EAppMode mode) :
-#else
-	AppConfig() :
-#endif // ENABLE_GCODE_VIEWER
 		m_dirty(false),
 		m_orig_version(Semver::invalid()),
-#if ENABLE_GCODE_VIEWER
 		m_mode(mode),
-#endif // ENABLE_GCODE_VIEWER
 		m_legacy_datadir(false)
 	{
 		this->reset();
@@ -135,11 +129,7 @@ public:
     void                reset_selections();
 
 	// Get the default config path from Slic3r::data_dir().
-#if ENABLE_GCODE_VIEWER
 	std::string			config_path();
-#else
-	static std::string  config_path();
-#endif // ENABLE_GCODE_VIEWER
 
 	// Returns true if the user's data directory comes from before Slic3r 1.40.0 (no updating)
 	bool 				legacy_datadir() const { return m_legacy_datadir; }
@@ -154,11 +144,7 @@ public:
 	Semver 				orig_version() const { return m_orig_version; }
 
 	// Does the config file exist?
-#if ENABLE_GCODE_VIEWER
 	bool 				exists();
-#else
-	static bool 		exists();
-#endif // ENABLE_GCODE_VIEWER
 
     std::vector<std::string> get_recent_projects() const;
     void set_recent_projects(const std::vector<std::string>& recent_projects);
@@ -196,10 +182,8 @@ private:
 	    return true;
 	}
 
-#if ENABLE_GCODE_VIEWER
+	// Type of application: Editor or GCodeViewer
 	EAppMode													m_mode { EAppMode::Editor };
-#endif // ENABLE_GCODE_VIEWER
-
 	// Map of section, name -> value
 	std::map<std::string, std::map<std::string, std::string>> 	m_storage;
 	// Map of enabled vendors / models / variants

src/libslic3r/CustomGCode.cpp

@@ -1,8 +1,6 @@
 #include "CustomGCode.hpp"
 #include "Config.hpp"
-#if ENABLE_GCODE_VIEWER
 #include "GCode.hpp"
-#endif // ENABLE_GCODE_VIEWER
 #include "GCodeWriter.hpp"
 
 namespace Slic3r {
@@ -19,11 +17,7 @@ extern void update_custom_gcode_per_print_z_from_config(Info& info, DynamicPrint
         return;
     if (info.gcodes.empty() && ! colorprint_heights->values.empty()) {
 		// Convert the old colorprint_heighs only if there is no equivalent data in a new format.
-#if ENABLE_GCODE_VIEWER
         const std::vector<std::string>& colors = ColorPrintColors::get();
-#else
-        const std::vector<std::string>& colors = GCodePreviewData::ColorPrintColors();
-#endif // ENABLE_GCODE_VIEWER
         const auto& colorprint_values = colorprint_heights->values;
         info.gcodes.clear();
         info.gcodes.reserve(colorprint_values.size());

src/libslic3r/ExtrusionEntity.cpp

@@ -306,11 +306,7 @@ double ExtrusionLoop::min_mm3_per_mm() const
 std::string ExtrusionEntity::role_to_string(ExtrusionRole role)
 {
     switch (role) {
-#if ENABLE_GCODE_VIEWER
         case erNone                         : return L("Unknown");
-#else
-        case erNone                         : return L("None");
-#endif // ENABLE_GCODE_VIEWER
         case erPerimeter                    : return L("Perimeter");
         case erExternalPerimeter            : return L("External perimeter");
         case erOverhangPerimeter            : return L("Overhang perimeter");

src/libslic3r/GCode.cpp

@@ -546,9 +546,7 @@ namespace Slic3r {
         return gcode;
     }
 
-#if ENABLE_GCODE_VIEWER
     const std::vector<std::string> ColorPrintColors::Colors = { "#C0392B", "#E67E22", "#F1C40F", "#27AE60", "#1ABC9C", "#2980B9", "#9B59B6" };
-#endif // ENABLE_GCODE_VIEWER
 
 #define EXTRUDER_CONFIG(OPT) m_config.OPT.get_at(m_writer.extruder()->id())
 
@@ -687,7 +685,6 @@ std::vector<std::pair<coordf_t, std::vector<GCode::LayerToPrint>>> GCode::collec
     return layers_to_print;
 }
 
-#if ENABLE_GCODE_VIEWER
 // free functions called by GCode::do_export()
 namespace DoExport {
     static void update_print_estimated_times_stats(const GCodeProcessor& processor, PrintStatistics& print_statistics)
@@ -700,9 +697,6 @@ namespace DoExport {
 } // namespace DoExport
 
 void GCode::do_export(Print* print, const char* path, GCodeProcessor::Result* result, ThumbnailsGeneratorCallback thumbnail_cb)
-#else
-void GCode::do_export(Print* print, const char* path, GCodePreviewData* preview_data, ThumbnailsGeneratorCallback thumbnail_cb)
-#endif // ENABLE_GCODE_VIEWER
 {
     PROFILE_CLEAR();
 
@@ -724,10 +718,6 @@ void GCode::do_export(Print* print, const char* path, GCodePreviewData* preview_
     if (file == nullptr)
         throw Slic3r::RuntimeError(std::string("G-code export to ") + path + " failed.\nCannot open the file for writing.\n");
 
-#if !ENABLE_GCODE_VIEWER
-    m_enable_analyzer = preview_data != nullptr;
-#endif // !ENABLE_GCODE_VIEWER
-
     try {
         m_placeholder_parser_failed_templates.clear();
         this->_do_export(*print, file, thumbnail_cb);
@@ -759,35 +749,12 @@ void GCode::do_export(Print* print, const char* path, GCodePreviewData* preview_
         throw Slic3r::RuntimeError(msg);
     }
 
-#if ENABLE_GCODE_VIEWER
     BOOST_LOG_TRIVIAL(debug) << "Start processing gcode, " << log_memory_info();
     m_processor.process_file(path_tmp, true, [print]() { print->throw_if_canceled(); });
     DoExport::update_print_estimated_times_stats(m_processor, print->m_print_statistics);
     if (result != nullptr)
         *result = std::move(m_processor.extract_result());
     BOOST_LOG_TRIVIAL(debug) << "Finished processing gcode, " << log_memory_info();
-#else
-    GCodeTimeEstimator::PostProcessData normal_data = m_normal_time_estimator.get_post_process_data();
-    GCodeTimeEstimator::PostProcessData silent_data = m_silent_time_estimator.get_post_process_data();
-
-    bool remaining_times_enabled = print->config().remaining_times.value;
-
-    BOOST_LOG_TRIVIAL(debug) << "Time estimator post processing" << log_memory_info();
-    GCodeTimeEstimator::post_process(path_tmp, 60.0f, remaining_times_enabled ? &normal_data : nullptr, (remaining_times_enabled && m_silent_time_estimator_enabled) ? &silent_data : nullptr);
-
-    if (remaining_times_enabled) {
-        m_normal_time_estimator.reset();
-        if (m_silent_time_estimator_enabled)
-            m_silent_time_estimator.reset();
-    }
-
-    // starts analyzer calculations
-    if (m_enable_analyzer) {
-        BOOST_LOG_TRIVIAL(debug) << "Preparing G-code preview data" << log_memory_info();
-        m_analyzer.calc_gcode_preview_data(*preview_data, [print]() { print->throw_if_canceled(); });
-        m_analyzer.reset();
-    }
-#endif // ENABLE_GCODE_VIEWER
 
     if (rename_file(path_tmp, path))
         throw Slic3r::RuntimeError(
@@ -804,88 +771,6 @@ void GCode::do_export(Print* print, const char* path, GCodePreviewData* preview_
 
 // free functions called by GCode::_do_export()
 namespace DoExport {
-#if !ENABLE_GCODE_VIEWER
-    static void init_time_estimators(const PrintConfig &config, GCodeTimeEstimator &normal_time_estimator, GCodeTimeEstimator &silent_time_estimator, bool &silent_time_estimator_enabled)
-	{
-	    // resets time estimators
-	    normal_time_estimator.reset();
-	    normal_time_estimator.set_dialect(config.gcode_flavor);
-	    normal_time_estimator.set_extrusion_axis(config.get_extrusion_axis()[0]);
-	    silent_time_estimator_enabled = (config.gcode_flavor == gcfMarlin) && config.silent_mode;
-
-	    // Until we have a UI support for the other firmwares than the Marlin, use the hardcoded default values
-	    // and let the user to enter the G-code limits into the start G-code.
-	    // If the following block is enabled for other firmwares than the Marlin, then the function
-	    // this->print_machine_envelope(file, print);
-	    // shall be adjusted as well to produce a G-code block compatible with the particular firmware flavor.
-	    if (config.gcode_flavor.value == gcfMarlin) {
-            if (config.machine_limits_usage.value != MachineLimitsUsage::Ignore) {
-		        normal_time_estimator.set_max_acceleration((float)config.machine_max_acceleration_extruding.values[0]);
-		        normal_time_estimator.set_retract_acceleration((float)config.machine_max_acceleration_retracting.values[0]);
-		        normal_time_estimator.set_minimum_feedrate((float)config.machine_min_extruding_rate.values[0]);
-		        normal_time_estimator.set_minimum_travel_feedrate((float)config.machine_min_travel_rate.values[0]);
-		        normal_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::X, (float)config.machine_max_acceleration_x.values[0]);
-		        normal_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::Y, (float)config.machine_max_acceleration_y.values[0]);
-		        normal_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::Z, (float)config.machine_max_acceleration_z.values[0]);
-		        normal_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::E, (float)config.machine_max_acceleration_e.values[0]);
-		        normal_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::X, (float)config.machine_max_feedrate_x.values[0]);
-		        normal_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::Y, (float)config.machine_max_feedrate_y.values[0]);
-		        normal_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::Z, (float)config.machine_max_feedrate_z.values[0]);
-		        normal_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::E, (float)config.machine_max_feedrate_e.values[0]);
-		        normal_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::X, (float)config.machine_max_jerk_x.values[0]);
-		        normal_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::Y, (float)config.machine_max_jerk_y.values[0]);
-		        normal_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::Z, (float)config.machine_max_jerk_z.values[0]);
-		        normal_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::E, (float)config.machine_max_jerk_e.values[0]);
-		    }
- 
-	        if (silent_time_estimator_enabled)
-	        {
-	            silent_time_estimator.reset();
-	            silent_time_estimator.set_dialect(config.gcode_flavor);
-	            silent_time_estimator.set_extrusion_axis(config.get_extrusion_axis()[0]);
-
-                if (config.machine_limits_usage.value != MachineLimitsUsage::Ignore) {
-		            /* "Stealth mode" values can be just a copy of "normal mode" values
-		            * (when they aren't input for a printer preset).
-		            * Thus, use back value from values, instead of second one, which could be absent
-		            */
-		            silent_time_estimator.set_max_acceleration((float)config.machine_max_acceleration_extruding.values.back());
-		            silent_time_estimator.set_retract_acceleration((float)config.machine_max_acceleration_retracting.values.back());
-		            silent_time_estimator.set_minimum_feedrate((float)config.machine_min_extruding_rate.values.back());
-		            silent_time_estimator.set_minimum_travel_feedrate((float)config.machine_min_travel_rate.values.back());
-		            silent_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::X, (float)config.machine_max_acceleration_x.values.back());
-		            silent_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::Y, (float)config.machine_max_acceleration_y.values.back());
-		            silent_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::Z, (float)config.machine_max_acceleration_z.values.back());
-		            silent_time_estimator.set_axis_max_acceleration(GCodeTimeEstimator::E, (float)config.machine_max_acceleration_e.values.back());
-		            silent_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::X, (float)config.machine_max_feedrate_x.values.back());
-		            silent_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::Y, (float)config.machine_max_feedrate_y.values.back());
-		            silent_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::Z, (float)config.machine_max_feedrate_z.values.back());
-		            silent_time_estimator.set_axis_max_feedrate(GCodeTimeEstimator::E, (float)config.machine_max_feedrate_e.values.back());
-		            silent_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::X, (float)config.machine_max_jerk_x.values.back());
-		            silent_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::Y, (float)config.machine_max_jerk_y.values.back());
-		            silent_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::Z, (float)config.machine_max_jerk_z.values.back());
-		            silent_time_estimator.set_axis_max_jerk(GCodeTimeEstimator::E, (float)config.machine_max_jerk_e.values.back());
-		        }
-
-	            if (config.single_extruder_multi_material) {
-	                // As of now the fields are shown at the UI dialog in the same combo box as the ramming values, so they
-	                // are considered to be active for the single extruder multi-material printers only.
-	                silent_time_estimator.set_filament_load_times(config.filament_load_time.values);
-	                silent_time_estimator.set_filament_unload_times(config.filament_unload_time.values);
-	            }
-	        }
-	    }
-	    // Filament load / unload times are not specific to a firmware flavor. Let anybody use it if they find it useful.
-	    if (config.single_extruder_multi_material) {
-	        // As of now the fields are shown at the UI dialog in the same combo box as the ramming values, so they
-	        // are considered to be active for the single extruder multi-material printers only.
-	        normal_time_estimator.set_filament_load_times(config.filament_load_time.values);
-	        normal_time_estimator.set_filament_unload_times(config.filament_unload_time.values);
-	    }
-	}
-#endif // !ENABLE_GCODE_VIEWER
-
-#if ENABLE_GCODE_VIEWER
     static void init_gcode_processor(const PrintConfig& config, GCodeProcessor& processor, bool& silent_time_estimator_enabled)
     {
         silent_time_estimator_enabled = (config.gcode_flavor == gcfMarlin) && config.silent_mode;
@@ -893,33 +778,6 @@ namespace DoExport {
         processor.apply_config(config);
         processor.enable_stealth_time_estimator(silent_time_estimator_enabled);
     }
-#else
-    static void init_gcode_analyzer(const PrintConfig &config, GCodeAnalyzer &analyzer)
-	{
-	    // resets analyzer
-	    analyzer.reset();
-
-	    // send extruder offset data to analyzer
-	    GCodeAnalyzer::ExtruderOffsetsMap extruder_offsets;
-	    unsigned int num_extruders = static_cast<unsigned int>(config.nozzle_diameter.values.size());
-	    for (unsigned int extruder_id = 0; extruder_id < num_extruders; ++ extruder_id)
-	    {
-	        Vec2d offset = config.extruder_offset.get_at(extruder_id);
-	        if (!offset.isApprox(Vec2d::Zero()))
-	            extruder_offsets[extruder_id] = offset;
-	    }
-	    analyzer.set_extruder_offsets(extruder_offsets);
-
-	    // tell analyzer about the extrusion axis
-	    analyzer.set_extrusion_axis(config.get_extrusion_axis()[0]);
-
-	    // send extruders count to analyzer to allow it to detect invalid extruder idxs
-	    analyzer.set_extruders_count(num_extruders);
-
-	    // tell analyzer about the gcode flavor
-	    analyzer.set_gcode_flavor(config.gcode_flavor);
-    }
-#endif // ENABLE_GCODE_VIEWER
 
 	static double autospeed_volumetric_limit(const Print &print)
 	{
@@ -1043,11 +901,6 @@ namespace DoExport {
 
 	// Fill in print_statistics and return formatted string containing filament statistics to be inserted into G-code comment section.
     static std::string update_print_stats_and_format_filament_stats(
-#if !ENABLE_GCODE_VIEWER
-        const GCodeTimeEstimator    &normal_time_estimator,
-	    const GCodeTimeEstimator    &silent_time_estimator,
-	    const bool                   silent_time_estimator_enabled,
-#endif // !ENABLE_GCODE_VIEWER
         const bool                   has_wipe_tower,
 	    const WipeTowerData         &wipe_tower_data,
 	    const std::vector<Extruder> &extruders,
@@ -1056,13 +909,6 @@ namespace DoExport {
 		std::string filament_stats_string_out;
 
 	    print_statistics.clear();
-#if !ENABLE_GCODE_VIEWER
-        print_statistics.estimated_normal_print_time = normal_time_estimator.get_time_dhm/*s*/();
-        print_statistics.estimated_silent_print_time = silent_time_estimator_enabled ? silent_time_estimator.get_time_dhm/*s*/() : "N/A";
-        print_statistics.estimated_normal_custom_gcode_print_times = normal_time_estimator.get_custom_gcode_times_dhm(true);
-        if (silent_time_estimator_enabled)
-            print_statistics.estimated_silent_custom_gcode_print_times = silent_time_estimator.get_custom_gcode_times_dhm(true);
-#endif // !ENABLE_GCODE_VIEWER
         print_statistics.total_toolchanges = std::max(0, wipe_tower_data.number_of_toolchanges);
 	    if (! extruders.empty()) {
 	        std::pair<std::string, unsigned int> out_filament_used_mm ("; filament used [mm] = ", 0);
@@ -1153,29 +999,16 @@ void GCode::_do_export(Print& print, FILE* file, ThumbnailsGeneratorCallback thu
 {
     PROFILE_FUNC();
 
-#if ENABLE_GCODE_VIEWER
     // modifies m_silent_time_estimator_enabled
     DoExport::init_gcode_processor(print.config(), m_processor, m_silent_time_estimator_enabled);
-#else
-    DoExport::init_time_estimators(print.config(),
-        // modifies the following:
-        m_normal_time_estimator, m_silent_time_estimator, m_silent_time_estimator_enabled);
-    DoExport::init_gcode_analyzer(print.config(), m_analyzer);
-#endif // ENABLE_GCODE_VIEWER
 
     // resets analyzer's tracking data
-#if ENABLE_GCODE_VIEWER
     m_last_height = 0.0f;
     m_last_layer_z = 0.0f;
 #if ENABLE_GCODE_VIEWER_DATA_CHECKING
     m_last_mm3_per_mm = 0.0;
     m_last_width = 0.0f;
 #endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
-#else
-    m_last_mm3_per_mm = GCodeAnalyzer::Default_mm3_per_mm;
-    m_last_width = GCodeAnalyzer::Default_Width;
-    m_last_height = GCodeAnalyzer::Default_Height;
-#endif // ENABLE_GCODE_VIEWER
 
     // How many times will be change_layer() called?
     // change_layer() in turn increments the progress bar status.
@@ -1266,16 +1099,8 @@ void GCode::_do_export(Print& print, FILE* file, ThumbnailsGeneratorCallback thu
     print.throw_if_canceled();
 
     // adds tags for time estimators
-#if ENABLE_GCODE_VIEWER
     if (print.config().remaining_times.value)
         _writeln(file, GCodeProcessor::First_Line_M73_Placeholder_Tag);
-#else
-    if (print.config().remaining_times.value) {
-        _writeln(file, GCodeTimeEstimator::Normal_First_M73_Output_Placeholder_Tag);
-        if (m_silent_time_estimator_enabled)
-            _writeln(file, GCodeTimeEstimator::Silent_First_M73_Output_Placeholder_Tag);
-    }
-#endif // ENABLE_GCODE_VIEWER
 
     // Prepare the helper object for replacing placeholders in custom G-code and output filename.
     m_placeholder_parser = print.placeholder_parser();
@@ -1380,14 +1205,8 @@ void GCode::_do_export(Print& print, FILE* file, ThumbnailsGeneratorCallback thu
     // Set extruder(s) temperature before and after start G-code.
     this->_print_first_layer_extruder_temperatures(file, print, start_gcode, initial_extruder_id, false);
 
-#if ENABLE_GCODE_VIEWER
     // adds tag for processor
     _write_format(file, ";%s%s\n", GCodeProcessor::Extrusion_Role_Tag.c_str(), ExtrusionEntity::role_to_string(erCustom).c_str());
-#else
-    if (m_enable_analyzer)
-        // adds tag for analyzer
-        _write_format(file, ";%s%d\n", GCodeAnalyzer::Extrusion_Role_Tag.c_str(), erCustom);
-#endif // ENABLE_GCODE_VIEWER
 
     // Write the custom start G-code
     _writeln(file, start_gcode);
@@ -1541,14 +1360,8 @@ void GCode::_do_export(Print& print, FILE* file, ThumbnailsGeneratorCallback thu
     _write(file, this->retract());
     _write(file, m_writer.set_fan(false));
 
-#if ENABLE_GCODE_VIEWER
     // adds tag for processor
     _write_format(file, ";%s%s\n", GCodeProcessor::Extrusion_Role_Tag.c_str(), ExtrusionEntity::role_to_string(erCustom).c_str());
-#else
-    if (m_enable_analyzer)
-        // adds tag for analyzer
-        _write_format(file, ";%s%d\n", GCodeAnalyzer::Extrusion_Role_Tag.c_str(), erCustom);
-#endif // ENABLE_GCODE_VIEWER
 
     // Process filament-specific gcode in extruder order.
     {
@@ -1573,32 +1386,14 @@ void GCode::_do_export(Print& print, FILE* file, ThumbnailsGeneratorCallback thu
     _write(file, m_writer.postamble());
 
     // adds tags for time estimators
-#if ENABLE_GCODE_VIEWER
     if (print.config().remaining_times.value)
         _writeln(file, GCodeProcessor::Last_Line_M73_Placeholder_Tag);
-#else
-    if (print.config().remaining_times.value) {
-        _writeln(file, GCodeTimeEstimator::Normal_Last_M73_Output_Placeholder_Tag);
-        if (m_silent_time_estimator_enabled)
-            _writeln(file, GCodeTimeEstimator::Silent_Last_M73_Output_Placeholder_Tag);
-    }
-#endif // ENABLE_GCODE_VIEWER
 
     print.throw_if_canceled();
 
-    // calculates estimated printing time
-#if !ENABLE_GCODE_VIEWER
-    m_normal_time_estimator.calculate_time(false);
-    if (m_silent_time_estimator_enabled)
-        m_silent_time_estimator.calculate_time(false);
-#endif // !ENABLE_GCODE_VIEWER
-
     // Get filament stats.
     _write(file, DoExport::update_print_stats_and_format_filament_stats(
     	// Const inputs
-#if !ENABLE_GCODE_VIEWER
-        m_normal_time_estimator, m_silent_time_estimator, m_silent_time_estimator_enabled,
-#endif // !ENABLE_GCODE_VIEWER
         has_wipe_tower, print.wipe_tower_data(),
         m_writer.extruders(),
         // Modifies
@@ -1608,13 +1403,7 @@ void GCode::_do_export(Print& print, FILE* file, ThumbnailsGeneratorCallback thu
     _write_format(file, "; total filament cost = %.2lf\n", print.m_print_statistics.total_cost);
     if (print.m_print_statistics.total_toolchanges > 0)
     	_write_format(file, "; total toolchanges = %i\n", print.m_print_statistics.total_toolchanges);
-#if ENABLE_GCODE_VIEWER
     _writeln(file, GCodeProcessor::Estimated_Printing_Time_Placeholder_Tag);
-#else
-    _write_format(file, "; estimated printing time (normal mode) = %s\n", m_normal_time_estimator.get_time_dhms().c_str());
-    if (m_silent_time_estimator_enabled)
-        _write_format(file, "; estimated printing time (silent mode) = %s\n", m_silent_time_estimator.get_time_dhms().c_str());
-#endif // ENABLE_GCODE_VIEWER
 
     // Append full config.
     _write(file, "\n");
@@ -1896,15 +1685,8 @@ namespace ProcessLayer
             {
                 assert(m600_extruder_before_layer >= 0);
 		        // Color Change or Tool Change as Color Change.
-#if ENABLE_GCODE_VIEWER
                 // add tag for processor
                 gcode += ";" + GCodeProcessor::Color_Change_Tag + ",T" + std::to_string(m600_extruder_before_layer) + "\n";
-#else
-                // add tag for analyzer
-                gcode += "; " + GCodeAnalyzer::Color_Change_Tag + ",T" + std::to_string(m600_extruder_before_layer) + "\n";
-                // add tag for time estimator
-                gcode += "; " + GCodeTimeEstimator::Color_Change_Tag + "\n";
-#endif // ENABLE_GCODE_VIEWER
 
                 if (!single_extruder_printer && m600_extruder_before_layer >= 0 && first_extruder_id != (unsigned)m600_extruder_before_layer
                     // && !MMU1
@@ -1923,33 +1705,17 @@ namespace ProcessLayer
 	        {
 	            if (gcode_type == CustomGCode::PausePrint) // Pause print
 	            {
-#if ENABLE_GCODE_VIEWER
                     // add tag for processor
                     gcode += ";" + GCodeProcessor::Pause_Print_Tag + "\n";
-#else
-                    // add tag for analyzer
-                    gcode += "; " + GCodeAnalyzer::Pause_Print_Tag + "\n";
-#endif // ENABLE_GCODE_VIEWER
                     //! FIXME_in_fw show message during print pause
 	                if (!pause_print_msg.empty())
 	                    gcode += "M117 " + pause_print_msg + "\n";
-#if !ENABLE_GCODE_VIEWER
-                    // add tag for time estimator
-	                gcode += "; " + GCodeTimeEstimator::Pause_Print_Tag + "\n";
-#endif // !ENABLE_GCODE_VIEWER
                     gcode += config.pause_print_gcode;
                 }
 	            else
 	            {
-#if ENABLE_GCODE_VIEWER
                     // add tag for processor
                     gcode += ";" + GCodeProcessor::Custom_Code_Tag + "\n";
-#else
-                    // add tag for analyzer
-                    gcode += "; " + GCodeAnalyzer::Custom_Code_Tag + "\n";
-                    // add tag for time estimator
-                    //gcode += "; " + GCodeTimeEstimator::Custom_Code_Tag + "\n";
-#endif // ENABLE_GCODE_VIEWER
                     if (gcode_type == CustomGCode::Template)    // Template Cistom Gcode
                         gcode += config.template_custom_gcode;
                     else                                        // custom Gcode
@@ -2091,7 +1857,6 @@ void GCode::process_layer(
 
     std::string gcode;
 
-#if ENABLE_GCODE_VIEWER
     // add tag for processor
     gcode += "; " + GCodeProcessor::Layer_Change_Tag + "\n";
     // export layer z
@@ -2105,7 +1870,6 @@ void GCode::process_layer(
     // update caches
     m_last_layer_z = static_cast<float>(print_z);
     m_last_height = height;
-#endif // ENABLE_GCODE_VIEWER
 
     // Set new layer - this will change Z and force a retraction if retract_layer_change is enabled.
     if (! print.config().before_layer_gcode.value.empty()) {
@@ -2320,15 +2084,9 @@ void GCode::process_layer(
             m_wipe_tower->tool_change(*this, extruder_id, extruder_id == layer_tools.extruders.back()) :
             this->set_extruder(extruder_id, print_z);
 
-#if ENABLE_GCODE_VIEWER
         // let analyzer tag generator aware of a role type change
         if (layer_tools.has_wipe_tower && m_wipe_tower)
             m_last_processor_extrusion_role = erWipeTower;
-#else
-        // let analyzer tag generator aware of a role type change
-        if (m_enable_analyzer && layer_tools.has_wipe_tower && m_wipe_tower)
-            m_last_analyzer_extrusion_role = erWipeTower;
-#endif // ENABLE_GCODE_VIEWER
 
         if (auto loops_it = skirt_loops_per_extruder.find(extruder_id); loops_it != skirt_loops_per_extruder.end()) {
             const std::pair<size_t, size_t> loops = loops_it->second;
@@ -2432,14 +2190,6 @@ void GCode::process_layer(
     if (m_cooling_buffer)
         gcode = m_cooling_buffer->process_layer(gcode, layer.id());
 
-#if !ENABLE_GCODE_VIEWER
-    // add tag for analyzer
-    if (gcode.find(GCodeAnalyzer::Pause_Print_Tag) != gcode.npos)
-        gcode += "\n; " + GCodeAnalyzer::End_Pause_Print_Or_Custom_Code_Tag + "\n";
-    else if (gcode.find(GCodeAnalyzer::Custom_Code_Tag) != gcode.npos)
-        gcode += "\n; " + GCodeAnalyzer::End_Pause_Print_Or_Custom_Code_Tag + "\n";
-#endif // !ENABLE_GCODE_VIEWER
-
 #ifdef HAS_PRESSURE_EQUALIZER
     // Apply pressure equalization if enabled;
     // printf("G-code before filter:\n%s\n", gcode.c_str());
@@ -2449,17 +2199,8 @@ void GCode::process_layer(
 #endif /* HAS_PRESSURE_EQUALIZER */
 
     _write(file, gcode);
-#if ENABLE_GCODE_VIEWER
     BOOST_LOG_TRIVIAL(trace) << "Exported layer " << layer.id() << " print_z " << print_z <<
         log_memory_info();
-#else
-    BOOST_LOG_TRIVIAL(trace) << "Exported layer " << layer.id() << " print_z " << print_z <<
-        ", time estimator memory: " <<
-        format_memsize_MB(m_normal_time_estimator.memory_used() + (m_silent_time_estimator_enabled ? m_silent_time_estimator.memory_used() : 0)) <<
-        ", analyzer memory: " <<
-        format_memsize_MB(m_analyzer.memory_used()) <<
-        log_memory_info();
-#endif // ENABLE_GCODE_VIEWER
 }
 
 void GCode::apply_print_config(const PrintConfig &print_config)
@@ -2790,21 +2531,9 @@ std::string GCode::extrude_support(const ExtrusionEntityCollection &support_fill
 void GCode::_write(FILE* file, const char *what)
 {
     if (what != nullptr) {
-#if ENABLE_GCODE_VIEWER
         const char* gcode = what;
-#else
-        // apply analyzer, if enabled
-        const char* gcode = m_enable_analyzer ? m_analyzer.process_gcode(what).c_str() : what;
-#endif // !ENABLE_GCODE_VIEWER
-
         // writes string to file
         fwrite(gcode, 1, ::strlen(gcode), file);
-#if !ENABLE_GCODE_VIEWER
-        // updates time estimator and gcode lines vector
-        m_normal_time_estimator.add_gcode_block(gcode);
-        if (m_silent_time_estimator_enabled)
-            m_silent_time_estimator.add_gcode_block(gcode);
-#endif // !ENABLE_GCODE_VIEWER
     }
 }
 
@@ -2944,70 +2673,36 @@ std::string GCode::_extrude(const ExtrusionPath &path, std::string description,
     }
 
     // adds processor tags and updates processor tracking data
-#if ENABLE_GCODE_VIEWER
     // PrusaMultiMaterial::Writer may generate GCodeProcessor::Height_Tag lines without updating m_last_height
     // so, if the last role was erWipeTower we force export of GCodeProcessor::Height_Tag lines
     bool last_was_wipe_tower = (m_last_processor_extrusion_role == erWipeTower);
-#else
+    char buf[64];
-    if (m_enable_analyzer) {
-        // PrusaMultiMaterial::Writer may generate GCodeAnalyzer::Height_Tag and GCodeAnalyzer::Width_Tag lines without updating m_last_height and m_last_width
-        // so, if the last role was erWipeTower we force export of GCodeAnalyzer::Height_Tag and GCodeAnalyzer::Width_Tag lines
-        bool last_was_wipe_tower = (m_last_analyzer_extrusion_role == erWipeTower);
-#endif // ENABLE_GCODE_VIEWER
-        char buf[64];
 
-#if ENABLE_GCODE_VIEWER
+    if (path.role() != m_last_processor_extrusion_role) {
-        if (path.role() != m_last_processor_extrusion_role) {
+        m_last_processor_extrusion_role = path.role();
-            m_last_processor_extrusion_role = path.role();
+        sprintf(buf, ";%s%s\n", GCodeProcessor::Extrusion_Role_Tag.c_str(), ExtrusionEntity::role_to_string(m_last_processor_extrusion_role).c_str());
-            sprintf(buf, ";%s%s\n", GCodeProcessor::Extrusion_Role_Tag.c_str(), ExtrusionEntity::role_to_string(m_last_processor_extrusion_role).c_str());
+        gcode += buf;
-            gcode += buf;
+    }
-        }
 
 #if ENABLE_GCODE_VIEWER_DATA_CHECKING
-        if (last_was_wipe_tower || (m_last_mm3_per_mm != path.mm3_per_mm)) {
+    if (last_was_wipe_tower || (m_last_mm3_per_mm != path.mm3_per_mm)) {
-            m_last_mm3_per_mm = path.mm3_per_mm;
+        m_last_mm3_per_mm = path.mm3_per_mm;
-            sprintf(buf, ";%s%f\n", GCodeProcessor::Mm3_Per_Mm_Tag.c_str(), m_last_mm3_per_mm);
+        sprintf(buf, ";%s%f\n", GCodeProcessor::Mm3_Per_Mm_Tag.c_str(), m_last_mm3_per_mm);
-            gcode += buf;
+        gcode += buf;
-        }
+    }
 
-        if (last_was_wipe_tower || m_last_width != path.width) {
+    if (last_was_wipe_tower || m_last_width != path.width) {
-            m_last_width = path.width;
+        m_last_width = path.width;
-            sprintf(buf, ";%s%g\n", GCodeProcessor::Width_Tag.c_str(), m_last_width);
+        sprintf(buf, ";%s%g\n", GCodeProcessor::Width_Tag.c_str(), m_last_width);
-            gcode += buf;
+        gcode += buf;
-        }
+    }
 #endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
 
-        if (last_was_wipe_tower || std::abs(m_last_height - path.height) > EPSILON) {
+    if (last_was_wipe_tower || std::abs(m_last_height - path.height) > EPSILON) {
-            m_last_height = path.height;
+        m_last_height = path.height;
-            sprintf(buf, ";%s%g\n", GCodeProcessor::Height_Tag.c_str(), m_last_height);
+        sprintf(buf, ";%s%g\n", GCodeProcessor::Height_Tag.c_str(), m_last_height);
-            gcode += buf;
+        gcode += buf;
-        }
-#else
-        if (path.role() != m_last_analyzer_extrusion_role) {
-            m_last_analyzer_extrusion_role = path.role();
-            sprintf(buf, ";%s%d\n", GCodeAnalyzer::Extrusion_Role_Tag.c_str(), int(m_last_analyzer_extrusion_role));
-            gcode += buf;
-        }
-
-        if (last_was_wipe_tower || (m_last_mm3_per_mm != path.mm3_per_mm)) {
-            m_last_mm3_per_mm = path.mm3_per_mm;
-            sprintf(buf, ";%s%f\n", GCodeAnalyzer::Mm3_Per_Mm_Tag.c_str(), m_last_mm3_per_mm);
-            gcode += buf;
-        }
-
-        if (last_was_wipe_tower || m_last_width != path.width) {
-            m_last_width = path.width;
-            sprintf(buf, ";%s%f\n", GCodeAnalyzer::Width_Tag.c_str(), m_last_width);
-            gcode += buf;
-        }
-
-        if (last_was_wipe_tower || m_last_height != path.height) {
-            m_last_height = path.height;
-            sprintf(buf, ";%s%f\n", GCodeAnalyzer::Height_Tag.c_str(), m_last_height);
-            gcode += buf;
-        }
     }
-#endif // ENABLE_GCODE_VIEWER
 
     std::string comment;
     if (m_enable_cooling_markers) {

src/libslic3r/GCode.hpp

@@ -14,9 +14,7 @@
 #include "GCode/ToolOrdering.hpp"
 #include "GCode/WipeTower.hpp"
 #include "GCode/SeamPlacer.hpp"
-#if ENABLE_GCODE_VIEWER
 #include "GCode/GCodeProcessor.hpp"
-#endif // ENABLE_GCODE_VIEWER
 #include "EdgeGrid.hpp"
 #include "GCode/ThumbnailData.hpp"
 
@@ -31,9 +29,6 @@ namespace Slic3r {
 
 // Forward declarations.
 class GCode;
-#if !ENABLE_GCODE_VIEWER
-class GCodePreviewData;
-#endif // !ENABLE_GCODE_VIEWER
 
 namespace { struct Item; }
 struct PrintInstance;
@@ -143,14 +138,12 @@ private:
     double                                                       m_last_wipe_tower_print_z = 0.f;
 };
 
-#if ENABLE_GCODE_VIEWER
 class ColorPrintColors
 {
     static const std::vector<std::string> Colors;
 public:
     static const std::vector<std::string>& get() { return Colors; }
 };
-#endif // ENABLE_GCODE_VIEWER
 
 class GCode {
 public:        
@@ -158,13 +151,8 @@ public:
     	m_origin(Vec2d::Zero()),
         m_enable_loop_clipping(true), 
         m_enable_cooling_markers(false), 
-        m_enable_extrusion_role_markers(false), 
+        m_enable_extrusion_role_markers(false),
-#if ENABLE_GCODE_VIEWER
         m_last_processor_extrusion_role(erNone),
-#else
-        m_enable_analyzer(false),
-        m_last_analyzer_extrusion_role(erNone),
-#endif // ENABLE_GCODE_VIEWER
         m_layer_count(0),
         m_layer_index(-1), 
         m_layer(nullptr), 
@@ -175,17 +163,8 @@ public:
         m_last_mm3_per_mm(0.0),
         m_last_width(0.0f),
 #endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
-#if !ENABLE_GCODE_VIEWER
-        m_last_mm3_per_mm(GCodeAnalyzer::Default_mm3_per_mm),
-        m_last_width(GCodeAnalyzer::Default_Width),
-        m_last_height(GCodeAnalyzer::Default_Height),
-#endif // !ENABLE_GCODE_VIEWER
         m_brim_done(false),
         m_second_layer_things_done(false),
-#if !ENABLE_GCODE_VIEWER
-        m_normal_time_estimator(GCodeTimeEstimator::Normal),
-        m_silent_time_estimator(GCodeTimeEstimator::Silent),
-#endif // !ENABLE_GCODE_VIEWER
         m_silent_time_estimator_enabled(false),
         m_last_obj_copy(nullptr, Point(std::numeric_limits<coord_t>::max(), std::numeric_limits<coord_t>::max()))
         {}
@@ -193,11 +172,7 @@ public:
 
     // throws std::runtime_exception on error,
     // throws CanceledException through print->throw_if_canceled().
-#if ENABLE_GCODE_VIEWER
     void            do_export(Print* print, const char* path, GCodeProcessor::Result* result = nullptr, ThumbnailsGeneratorCallback thumbnail_cb = nullptr);
-#else
-    void            do_export(Print* print, const char* path, GCodePreviewData* preview_data = nullptr, ThumbnailsGeneratorCallback thumbnail_cb = nullptr);
-#endif // ENABLE_GCODE_VIEWER
 
     // Exported for the helper classes (OozePrevention, Wipe) and for the Perl binding for unit tests.
     const Vec2d&    origin() const { return m_origin; }
@@ -360,16 +335,8 @@ private:
     // Markers for the Pressure Equalizer to recognize the extrusion type.
     // The Pressure Equalizer removes the markers from the final G-code.
     bool                                m_enable_extrusion_role_markers;
-#if ENABLE_GCODE_VIEWER
     // Keeps track of the last extrusion role passed to the processor
     ExtrusionRole                       m_last_processor_extrusion_role;
-#else
-    // Enableds the G-code Analyzer.
-    // Extended markers will be added during G-code generation.
-    // The G-code Analyzer will remove these comments from the final G-code.
-    bool                                m_enable_analyzer;
-    ExtrusionRole                       m_last_analyzer_extrusion_role;
-#endif // ENABLE_GCODE_VIEWER
     // How many times will change_layer() be called?
     // change_layer() will update the progress bar.
     unsigned int                        m_layer_count;
@@ -381,7 +348,6 @@ private:
     double                              m_volumetric_speed;
     // Support for the extrusion role markers. Which marker is active?
     ExtrusionRole                       m_last_extrusion_role;
-#if ENABLE_GCODE_VIEWER
     // Support for G-Code Processor
     float                               m_last_height{ 0.0f };
     float                               m_last_layer_z{ 0.0f };
@@ -389,12 +355,6 @@ private:
     double                              m_last_mm3_per_mm;
     float                               m_last_width{ 0.0f };
 #endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
-#else
-    // Support for G-Code Analyzer
-    double                              m_last_mm3_per_mm;
-    float                               m_last_width;
-    float                               m_last_height;
-#endif // ENABLE_GCODE_VIEWER
 
     Point                               m_last_pos;
     bool                                m_last_pos_defined;
@@ -415,20 +375,10 @@ private:
     // Index of a last object copy extruded.
     std::pair<const PrintObject*, Point> m_last_obj_copy;
 
-#if !ENABLE_GCODE_VIEWER
-    // Time estimators
-    GCodeTimeEstimator m_normal_time_estimator;
-    GCodeTimeEstimator m_silent_time_estimator;
-#endif // !ENABLE_GCODE_VIEWER
     bool m_silent_time_estimator_enabled;
 
-#if ENABLE_GCODE_VIEWER
     // Processor
     GCodeProcessor m_processor;
-#else
-    // Analyzer
-    GCodeAnalyzer m_analyzer;
-#endif // ENABLE_GCODE_VIEWER
 
     // Write a string into a file.
     void _write(FILE* file, const std::string& what) { this->_write(file, what.c_str()); }

src/libslic3r/GCode/GCodeProcessor.cpp

@@ -15,7 +15,6 @@
     #include <utility>
 #endif
 
-#if ENABLE_GCODE_VIEWER
 #include <chrono>
 
 static const float INCHES_TO_MM = 25.4f;
@@ -2228,4 +2227,3 @@ void GCodeProcessor::update_estimated_times_stats()
 
 } /* namespace Slic3r */
 
-#endif // ENABLE_GCODE_VIEWER

src/libslic3r/GCode/GCodeProcessor.hpp

@@ -1,7 +1,6 @@
 #ifndef slic3r_GCodeProcessor_hpp_
 #define slic3r_GCodeProcessor_hpp_
 
-#if ENABLE_GCODE_VIEWER
 #include "libslic3r/GCodeReader.hpp"
 #include "libslic3r/Point.hpp"
 #include "libslic3r/ExtrusionEntity.hpp"
@@ -584,8 +583,6 @@ namespace Slic3r {
 
 } /* namespace Slic3r */
 
-#endif // ENABLE_GCODE_VIEWER
-
 #endif /* slic3r_GCodeProcessor_hpp_ */
 
 

src/libslic3r/GCode/WipeTower.cpp

@@ -5,9 +5,7 @@
 #include <vector>
 #include <numeric>
 
-#if ENABLE_GCODE_VIEWER
 #include "GCodeProcessor.hpp"
-#endif // ENABLE_GCODE_VIEWER
 #include "BoundingBox.hpp"
 
 
@@ -36,25 +34,18 @@ public:
 		m_extrusion_flow(0.f),
 		m_preview_suppressed(false),
 		m_elapsed_time(0.f),
-#if !ENABLE_GCODE_VIEWER || ENABLE_GCODE_VIEWER_DATA_CHECKING
+#if ENABLE_GCODE_VIEWER_DATA_CHECKING
         m_default_analyzer_line_width(line_width),
-#endif // !ENABLE_GCODE_VIEWER || ENABLE_GCODE_VIEWER_DATA_CHECKING
+#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
         m_gcode_flavor(flavor),
         m_filpar(filament_parameters)
         {
             // adds tag for analyzer:
             char buf[64];
-#if ENABLE_GCODE_VIEWER
             sprintf(buf, ";%s%f\n", GCodeProcessor::Height_Tag.c_str(), m_layer_height); // don't rely on GCodeAnalyzer knowing the layer height - it knows nothing at priming
             m_gcode += buf;
             sprintf(buf, ";%s%s\n", GCodeProcessor::Extrusion_Role_Tag.c_str(), ExtrusionEntity::role_to_string(erWipeTower).c_str());
             m_gcode += buf;
-#else
-            sprintf(buf, ";%s%f\n", GCodeAnalyzer::Height_Tag.c_str(), m_layer_height); // don't rely on GCodeAnalyzer knowing the layer height - it knows nothing at priming
-            m_gcode += buf;
-            sprintf(buf, ";%s%d\n", GCodeAnalyzer::Extrusion_Role_Tag.c_str(), erWipeTower);
-            m_gcode += buf;
-#endif // ENABLE_GCODE_VIEWER
 #if ENABLE_GCODE_VIEWER_DATA_CHECKING
             change_analyzer_line_width(line_width);
 #endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
@@ -78,26 +69,6 @@ public:
         m_gcode += buf;
         return *this;
     }
-#else
-#if !ENABLE_GCODE_VIEWER
-    WipeTowerWriter& change_analyzer_line_width(float line_width) {
-        // adds tag for analyzer:
-        char buf[64];
-        sprintf(buf, ";%s%f\n", GCodeAnalyzer::Width_Tag.c_str(), line_width);
-        m_gcode += buf;
-        return *this;
-    }
-
-    WipeTowerWriter& change_analyzer_mm3_per_mm(float len, float e) {
-        static const float area = float(M_PI) * 1.75f * 1.75f / 4.f;
-        float mm3_per_mm = (len == 0.f ? 0.f : area * e / len);
-        // adds tag for analyzer:
-        char buf[64];
-        sprintf(buf, ";%s%f\n", GCodeAnalyzer::Mm3_Per_Mm_Tag.c_str(), mm3_per_mm);
-        m_gcode += buf;
-        return *this;
-    }
-#endif // !ENABLE_GCODE_VIEWER
 #endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
 
 	WipeTowerWriter& 			 set_initial_position(const Vec2f &pos, float width = 0.f, float depth = 0.f, float internal_angle = 0.f) {
@@ -133,13 +104,13 @@ public:
 	// Suppress / resume G-code preview in Slic3r. Slic3r will have difficulty to differentiate the various
 	// filament loading and cooling moves from normal extrusion moves. Therefore the writer
 	// is asked to suppres output of some lines, which look like extrusions.
-#if !ENABLE_GCODE_VIEWER || ENABLE_GCODE_VIEWER_DATA_CHECKING
+#if ENABLE_GCODE_VIEWER_DATA_CHECKING
     WipeTowerWriter& suppress_preview() { change_analyzer_line_width(0.f); m_preview_suppressed = true; return *this; }
     WipeTowerWriter& resume_preview() { change_analyzer_line_width(m_default_analyzer_line_width); m_preview_suppressed = false; return *this; }
 #else
     WipeTowerWriter& 			 suppress_preview() { m_preview_suppressed = true; return *this; }
 	WipeTowerWriter& 			 resume_preview()   { m_preview_suppressed = false; return *this; }
-#endif // !ENABLE_GCODE_VIEWER || ENABLE_GCODE_VIEWER_DATA_CHECKING
+#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
 
 	WipeTowerWriter& 			 feedrate(float f)
 	{
@@ -178,10 +149,6 @@ public:
         if (! m_preview_suppressed && e > 0.f && len > 0.f) {
 #if ENABLE_GCODE_VIEWER_DATA_CHECKING
             change_analyzer_mm3_per_mm(len, e);
-#else
-#if !ENABLE_GCODE_VIEWER
-            change_analyzer_mm3_per_mm(len, e);
-#endif // !ENABLE_GCODE_VIEWER
 #endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
             // Width of a squished extrusion, corrected for the roundings of the squished extrusions.
 			// This is left zero if it is a travel move.
@@ -461,9 +428,9 @@ private:
 	float		  m_wipe_tower_depth = 0.f;
     unsigned      m_last_fan_speed = 0;
     int           current_temp = -1;
-#if !ENABLE_GCODE_VIEWER || ENABLE_GCODE_VIEWER_DATA_CHECKING
+#if ENABLE_GCODE_VIEWER_DATA_CHECKING
     const float   m_default_analyzer_line_width;
-#endif // !ENABLE_GCODE_VIEWER || ENABLE_GCODE_VIEWER_DATA_CHECKING
+#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
     float         m_used_filament_length = 0.f;
     GCodeFlavor   m_gcode_flavor;
     const std::vector<WipeTower::FilamentParameters>& m_filpar;

src/libslic3r/GCodeReader.cpp

@@ -1,9 +1,7 @@
 #include "GCodeReader.hpp"
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/split.hpp>
-#if ENABLE_GCODE_VIEWER
 #include <boost/nowide/fstream.hpp>
-#endif // ENABLE_GCODE_VIEWER
 #include <fstream>
 #include <iostream>
 #include <iomanip>
@@ -116,18 +114,10 @@ void GCodeReader::update_coordinates(GCodeLine &gline, std::pair<const char*, co
 
 void GCodeReader::parse_file(const std::string &file, callback_t callback)
 {
-#if ENABLE_GCODE_VIEWER
     boost::nowide::ifstream f(file);
-#else
-    std::ifstream f(file);
-#endif // ENABLE_GCODE_VIEWER
     std::string line;
-#if ENABLE_GCODE_VIEWER
     m_parsing_file = true;
     while (m_parsing_file && std::getline(f, line))
-#else
-    while (std::getline(f, line))
-#endif // ENABLE_GCODE_VIEWER
         this->parse_line(line, callback);
 }
 

src/libslic3r/GCodeReader.hpp

@@ -108,9 +108,7 @@ public:
         { GCodeLine gline; this->parse_line(line.c_str(), gline, callback); }
 
     void parse_file(const std::string &file, callback_t callback);
-#if ENABLE_GCODE_VIEWER
     void quit_parsing_file() { m_parsing_file = false; }
-#endif // ENABLE_GCODE_VIEWER
 
     float& x()       { return m_position[X]; }
     float  x() const { return m_position[X]; }
@@ -149,9 +147,7 @@ private:
     char        m_extrusion_axis;
     float       m_position[NUM_AXES];
     bool        m_verbose;
-#if ENABLE_GCODE_VIEWER
     bool        m_parsing_file{ false };
-#endif // ENABLE_GCODE_VIEWER
 };
 
 } /* namespace Slic3r */

src/libslic3r/Preset.cpp

@@ -1836,7 +1836,6 @@ namespace PresetUtils {
 		return out;
 	}
 
-#if ENABLE_GCODE_VIEWER
     std::string system_printer_bed_model(const Preset& preset)
     {
         std::string out;
@@ -1854,7 +1853,6 @@ namespace PresetUtils {
             out = Slic3r::resources_dir() + "/profiles/" + preset.vendor->id + "/" + pm->bed_texture;
         return out;
     }
-#endif // ENABLE_GCODE_VIEWER
 } // namespace PresetUtils
 
 } // namespace Slic3r

src/libslic3r/Preset.hpp

@@ -537,10 +537,8 @@ public:
 namespace PresetUtils {
 	// PrinterModel of a system profile, from which this preset is derived, or null if it is not derived from a system profile.
 	const VendorProfile::PrinterModel* system_printer_model(const Preset &preset);
-#if ENABLE_GCODE_VIEWER
     std::string system_printer_bed_model(const Preset& preset);
     std::string system_printer_bed_texture(const Preset& preset);
-#endif // ENABLE_GCODE_VIEWER
 } // namespace PresetUtils
 
 

src/libslic3r/Print.cpp

@@ -1661,21 +1661,13 @@ void Print::process()
 // The export_gcode may die for various reasons (fails to process output_filename_format,
 // write error into the G-code, cannot execute post-processing scripts).
 // It is up to the caller to show an error message.
-#if ENABLE_GCODE_VIEWER
 std::string Print::export_gcode(const std::string& path_template, GCodeProcessor::Result* result, ThumbnailsGeneratorCallback thumbnail_cb)
-#else
-std::string Print::export_gcode(const std::string& path_template, GCodePreviewData* preview_data, ThumbnailsGeneratorCallback thumbnail_cb)
-#endif // ENABLE_GCODE_VIEWER
 {
     // output everything to a G-code file
     // The following call may die if the output_filename_format template substitution fails.
     std::string path = this->output_filepath(path_template);
     std::string message;
-#if ENABLE_GCODE_VIEWER
     if (!path.empty() && result == nullptr) {
-#else
-    if (! path.empty() && preview_data == nullptr) {
-#endif // ENABLE_GCODE_VIEWER
         // Only show the path if preview_data is not set -> running from command line.
         message = L("Exporting G-code");
         message += " to ";
@@ -1686,11 +1678,7 @@ std::string Print::export_gcode(const std::string& path_template, GCodePreviewDa
 
     // The following line may die for multiple reasons.
     GCode gcode;
-#if ENABLE_GCODE_VIEWER
     gcode.do_export(this, path.c_str(), result, thumbnail_cb);
-#else
-    gcode.do_export(this, path.c_str(), preview_data, thumbnail_cb);
-#endif // ENABLE_GCODE_VIEWER
     return path.c_str();
 }
 

src/libslic3r/Print.hpp

@@ -11,9 +11,7 @@
 #include "GCode/ToolOrdering.hpp"
 #include "GCode/WipeTower.hpp"
 #include "GCode/ThumbnailData.hpp"
-#if ENABLE_GCODE_VIEWER
 #include "GCode/GCodeProcessor.hpp"
-#endif // ENABLE_GCODE_VIEWER
 
 #include "libslic3r.h"
 
@@ -23,9 +21,6 @@ class Print;
 class PrintObject;
 class ModelObject;
 class GCode;
-#if !ENABLE_GCODE_VIEWER
-class GCodePreviewData;
-#endif // !ENABLE_GCODE_VIEWER
 enum class SlicingMode : uint32_t;
 class Layer;
 class SupportLayer;
@@ -312,10 +307,6 @@ struct PrintStatistics
     PrintStatistics() { clear(); }
     std::string                     estimated_normal_print_time;
     std::string                     estimated_silent_print_time;
-#if !ENABLE_GCODE_VIEWER
-    std::vector<std::pair<CustomGCode::Type, std::string>>    estimated_normal_custom_gcode_print_times;
-    std::vector<std::pair<CustomGCode::Type, std::string>>    estimated_silent_custom_gcode_print_times;
-#endif // !ENABLE_GCODE_VIEWER
     double                          total_used_filament;
     double                          total_extruded_volume;
     double                          total_cost;
@@ -333,12 +324,6 @@ struct PrintStatistics
     std::string             finalize_output_path(const std::string &path_in) const;
 
     void clear() {
-#if !ENABLE_GCODE_VIEWER
-        estimated_normal_print_time.clear();
-        estimated_silent_print_time.clear();
-        estimated_normal_custom_gcode_print_times.clear();
-        estimated_silent_custom_gcode_print_times.clear();
-#endif // !ENABLE_GCODE_VIEWER
         total_used_filament    = 0.;
         total_extruded_volume  = 0.;
         total_cost             = 0.;
@@ -380,11 +365,7 @@ public:
     void                process() override;
     // Exports G-code into a file name based on the path_template, returns the file path of the generated G-code file.
     // If preview_data is not null, the preview_data is filled in for the G-code visualization (not used by the command line Slic3r).
-#if ENABLE_GCODE_VIEWER
     std::string         export_gcode(const std::string& path_template, GCodeProcessor::Result* result, ThumbnailsGeneratorCallback thumbnail_cb = nullptr);
-#else
-    std::string         export_gcode(const std::string& path_template, GCodePreviewData* preview_data, ThumbnailsGeneratorCallback thumbnail_cb = nullptr);
-#endif // ENABLE_GCODE_VIEWER
 
     // methods for handling state
     bool                is_step_done(PrintStep step) const { return Inherited::is_step_done(step); }

src/libslic3r/Utils.hpp

@@ -110,30 +110,13 @@ std::string string_printf(const char *format, ...);
 // to be placed at the top of Slic3r generated files.
 std::string header_slic3r_generated();
 
-#if ENABLE_GCODE_VIEWER
 // Standard "generated by PrusaGCodeViewer version xxx timestamp xxx" header string, 
 // to be placed at the top of Slic3r generated files.
 std::string header_gcodeviewer_generated();
-#endif // ENABLE_GCODE_VIEWER
 
 // getpid platform wrapper
 extern unsigned get_current_pid();
 
-#if !ENABLE_GCODE_VIEWER
-template <typename Real>
-Real round_nearest(Real value, unsigned int decimals)
-{
-    Real res = (Real)0;
-    if (decimals == 0)
-        res = ::round(value);
-    else {
-        Real power = ::pow((Real)10, (int)decimals);
-        res = ::round(value * power + (Real)0.5) / power;
-    }
-    return res;
-}
-#endif // !ENABLE_GCODE_VIEWER
-
 // Compute the next highest power of 2 of 32-bit v
 // http://graphics.stanford.edu/~seander/bithacks.html
 inline uint16_t next_highest_power_of_2(uint16_t v)

src/libslic3r/utils.cpp

@@ -614,12 +614,10 @@ std::string header_slic3r_generated()
 	return std::string("generated by " SLIC3R_APP_NAME " " SLIC3R_VERSION " on " ) + Utils::utc_timestamp();
 }
 
-#if ENABLE_GCODE_VIEWER
 std::string header_gcodeviewer_generated()
 {
 	return std::string("generated by " GCODEVIEWER_APP_NAME " " SLIC3R_VERSION " on ") + Utils::utc_timestamp();
 }
-#endif // ENABLE_GCODE_VIEWER
 
 unsigned get_current_pid()
 {