Merge branch 'master' into wipe_tower_improvements

lib/Slic3r/GUI.pm

@@ -9,7 +9,6 @@ use List::Util qw(first);
 use Slic3r::GUI::2DBed;
 use Slic3r::GUI::AboutDialog;
 use Slic3r::GUI::BedShapeDialog;
-use Slic3r::GUI::BonjourBrowser;
 use Slic3r::GUI::ConfigWizard;
 use Slic3r::GUI::Controller;
 use Slic3r::GUI::Controller::ManualControlDialog;

lib/Slic3r/GUI/BonjourBrowser.pm

@@ -1,53 +0,0 @@
-# A tiny dialog to select an OctoPrint device to print to.
-
-package Slic3r::GUI::BonjourBrowser;
-use strict;
-use warnings;
-use utf8;
-
-use Wx qw(:dialog :id :misc :sizer :choicebook wxTAB_TRAVERSAL);
-use Wx::Event qw(EVT_CLOSE);
-use base 'Wx::Dialog';
-
-sub new {
-    my $class = shift;
-    my ($parent, $devices) = @_;
-    my $self = $class->SUPER::new($parent, -1, "Device Browser", wxDefaultPosition, [350,700], wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER);
-    
-    $self->{devices} = $devices;
-    
-    # label
-    my $text = Wx::StaticText->new($self, -1, "Choose an OctoPrint device in your network:", wxDefaultPosition, wxDefaultSize);
-    
-    # selector
-    $self->{choice} = my $choice = Wx::Choice->new($self, -1, wxDefaultPosition, wxDefaultSize,
-        [ map $_->name, @{$self->{devices}} ]);
-    
-    my $main_sizer = Wx::BoxSizer->new(wxVERTICAL);
-    $main_sizer->Add($text, 1, wxEXPAND | wxALL, 10);
-    $main_sizer->Add($choice, 1, wxEXPAND | wxALL, 10);
-    $main_sizer->Add($self->CreateButtonSizer(wxOK | wxCANCEL), 0, wxEXPAND);
-    
-    $self->SetSizer($main_sizer);
-    $self->SetMinSize($self->GetSize);
-    $main_sizer->SetSizeHints($self);
-    
-    # needed to actually free memory
-    EVT_CLOSE($self, sub {
-        $self->EndModal(wxID_OK);
-        $self->Destroy;
-    });
-    
-    return $self;
-}
-
-sub GetValue {
-    my ($self) = @_;
-    return $self->{devices}[ $self->{choice}->GetSelection ]->address;
-}
-sub GetPort {
-    my ($self) = @_;
-    return $self->{devices}[ $self->{choice}->GetSelection ]->port;
-}
-
-1;

lib/Slic3r/GUI/Plater.pm

@@ -1333,6 +1333,9 @@ sub export_gcode {
     } else {
         my $default_output_file = eval { $self->{print}->output_filepath($main::opt{output} // '') };
         Slic3r::GUI::catch_error($self) and return;
+        # If possible, remove accents from accented latin characters.
+        # This function is useful for generating file names to be processed by legacy firmwares.
+        $default_output_file = Slic3r::GUI::fold_utf8_to_ascii($default_output_file);
         my $dlg = Wx::FileDialog->new($self, L('Save G-code file as:'), 
             wxTheApp->{app_config}->get_last_output_dir(dirname($default_output_file)),
             basename($default_output_file), &Slic3r::GUI::FILE_WILDCARDS->{gcode}, wxFD_SAVE | wxFD_OVERWRITE_PROMPT);

lib/Slic3r/Test/SectionCut.pm

@@ -1,177 +0,0 @@
-# 2D cut in the XZ plane through the toolpaths.
-# For debugging purposes.
-
-package Slic3r::Test::SectionCut;
-use Moo;
-
-use List::Util qw(first min max);
-use Slic3r::Geometry qw(unscale);
-use Slic3r::Geometry::Clipper qw(intersection_pl);
-use SVG;
-use Slic3r::SVG;
-
-has 'print'         => (is => 'ro', required => 1);
-has 'scale'         => (is => 'ro', default => sub { 30 });
-has 'y_percent'     => (is => 'ro', default => sub { 0.5 });  # Y coord of section line expressed as factor
-has 'line'          => (is => 'rw');
-has '_height'       => (is => 'rw');
-has '_svg'          => (is => 'rw');
-has '_svg_style'    => (is => 'rw', default => sub { {} });
-
-sub BUILD {
-    my $self = shift;
-    
-    # calculate the Y coordinate of the section line
-    my $bb = $self->print->bounding_box;
-    my $y = ($bb->y_min + $bb->y_max) * $self->y_percent;
-    
-    # store our section line
-    $self->line(Slic3r::Line->new([ $bb->x_min, $y ], [ $bb->x_max, $y ]));
-}
-
-sub export_svg {
-    my $self = shift;
-    my ($filename) = @_;
-    
-    # get bounding box of print and its height
-    # (Print should return a BoundingBox3 object instead)
-    my $bb = $self->print->bounding_box;
-    my $print_size = $bb->size;
-    $self->_height(max(map $_->print_z, map @{$_->layers}, @{$self->print->objects}));
-    
-    # initialize the SVG canvas
-    $self->_svg(my $svg = SVG->new(
-        width  => $self->scale * unscale($print_size->x),
-        height => $self->scale * $self->_height,
-    ));
-    
-    # set default styles
-    $self->_svg_style->{'stroke-width'}   = 1;
-    $self->_svg_style->{'fill-opacity'}   = 0.5;
-    $self->_svg_style->{'stroke-opacity'} = 0.2;
-    
-    # plot perimeters
-    $self->_svg_style->{'stroke'}   = '#EE0000';
-    $self->_svg_style->{'fill'}     = '#FF0000';
-    $self->_plot_group(sub { map @{$_->perimeters}, @{$_[0]->regions} });
-    
-    # plot infill
-    $self->_svg_style->{'stroke'}   = '#444444';
-    $self->_svg_style->{'fill'}     = '#454545';
-    $self->_plot_group(sub { map @{$_->fills}, @{$_[0]->regions} });
-    
-    # plot support material
-    $self->_svg_style->{'stroke'}   = '#12EF00';
-    $self->_svg_style->{'fill'}     = '#22FF00';
-    $self->_plot_group(sub { $_[0]->isa('Slic3r::Layer::Support') ? ($_[0]->support_fills) : () });
-    
-    Slic3r::open(\my $fh, '>', $filename);
-    print $fh $svg->xmlify;
-    close $fh;
-    printf "Section cut SVG written to %s\n", $filename;
-}
-
-sub _plot_group {
-    my $self = shift;
-    my ($filter) = @_;
-    
-    my $bb = $self->print->bounding_box;
-    my $g = $self->_svg->group(style => { %{$self->_svg_style} });
-    
-    foreach my $object (@{$self->print->objects}) {
-        foreach my $copy (@{$object->_shifted_copies}) {
-            foreach my $layer (@{$object->layers}, @{$object->support_layers}) {
-                # get all ExtrusionPath objects
-                my @paths = map $_->clone,
-                    map { ($_->isa('Slic3r::ExtrusionLoop') || $_->isa('Slic3r::ExtrusionPath::Collection')) ? @$_ : $_ }
-                    grep defined $_,
-                    $filter->($layer);
-                
-                # move paths to location of copy
-                $_->polyline->translate(@$copy) for @paths;
-                
-                if (0) {
-                    # export plan with section line and exit
-                    require "Slic3r/SVG.pm";
-                    Slic3r::SVG::output(
-                        "line.svg",
-                        no_arrows       => 1,
-                        lines           => [ $self->line ],
-                        red_polylines   => [ map $_->polyline, @paths ],
-                    );
-                    exit;
-                }
-                
-                foreach my $path (@paths) {
-                    foreach my $line (@{$path->lines}) {
-                        my @intersections = @{intersection_pl(
-                            [ $self->line->as_polyline ],
-                            $line->grow(Slic3r::Geometry::scale $path->width/2),
-                        )};
-                        
-                        die "Intersection has more than two points!\n"
-                            if defined first { @$_ > 2 } @intersections;
-                        
-                        # turn intersections to lines
-                        my @lines = map Slic3r::Line->new(@$_), @intersections;
-                        
-                        # align intersections to canvas
-                        $_->translate(-$bb->x_min, 0) for @lines;
-                        
-                        # we want lines oriented from left to right in order to draw
-                        # rectangles correctly
-                        foreach my $line (@lines) {
-                            $line->reverse if $line->a->x > $line->b->x;
-                        }
-                        
-                        if ($path->is_bridge) {
-                            foreach my $line (@lines) {
-                                my $radius = $path->width / 2;
-                                my $width = unscale abs($line->b->x - $line->a->x);
-                                if ((10 * $radius) < $width) {
-                                    # we're cutting the path in the longitudinal direction, so we've got a rectangle
-                                    $g->rectangle(
-                                        'x'         => $self->scale * unscale($line->a->x),
-                                        'y'         => $self->scale * $self->_y($layer->print_z),
-                                        'width'     => $self->scale * $width,
-                                        'height'    => $self->scale * $radius * 2,
-                                        'rx'        => $self->scale * $radius * 0.35,
-                                        'ry'        => $self->scale * $radius * 0.35,
-                                    );
-                                } else {
-                                    $g->circle(
-                                        'cx'        => $self->scale * (unscale($line->a->x) + $radius),
-                                        'cy'        => $self->scale * $self->_y($layer->print_z - $radius),
-                                        'r'         => $self->scale * $radius,
-                                    );
-                                }
-                            }
-                        } else {
-                            foreach my $line (@lines) {
-                                my $height = $path->height;
-                                $height = $layer->height if $height == -1;
-                                $g->rectangle(
-                                    'x'         => $self->scale * unscale($line->a->x),
-                                    'y'         => $self->scale * $self->_y($layer->print_z),
-                                    'width'     => $self->scale * unscale($line->b->x - $line->a->x),
-                                    'height'    => $self->scale * $height,
-                                    'rx'        => $self->scale * $height * 0.5,
-                                    'ry'        => $self->scale * $height * 0.5,
-                                );
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-sub _y {
-    my $self = shift;
-    my ($y) = @_;
-    
-    return $self->_height - $y;
-}
-
-1;

utils/gcode_sectioncut.pl

@@ -1,129 +0,0 @@
-#!/usr/bin/perl
-# This script generates section cuts from a given G-Code file
-
-use strict;
-use warnings;
-
-BEGIN {
-    use FindBin;
-    use lib "$FindBin::Bin/../lib";
-    use local::lib "$FindBin::Bin/../local-lib";
-}
-
-use Getopt::Long qw(:config no_auto_abbrev);
-use List::Util qw(max);
-use Slic3r;
-use Slic3r::Geometry qw(X Y);
-use Slic3r::Geometry::Clipper qw(JT_SQUARE);
-use Slic3r::Test;
-use SVG;
-
-my %opt = (
-    layer_height    => 0.2,
-    extrusion_width => 0.5,
-    scale           => 30,
-);
-{
-    my %options = (
-        'help'                  => sub { usage() },
-        'layer-height|h=f'      => \$opt{layer_height},
-        'extrusion-width|w=f'   => \$opt{extrusion_width},
-        'scale|s=i'             => \$opt{scale},
-    );
-    GetOptions(%options) or usage(1);
-    $ARGV[0] or usage(1);
-}
-
-{
-    my $input_file = $ARGV[0];
-    my $output_file = $input_file;
-    $output_file =~ s/\.(?:gcode|gco|ngc|g)$/.svg/;
-    
-    # read paths
-    my %paths = ();    # z => [ path, path ... ]
-    Slic3r::GCode::Reader->new->parse(io($input_file)->all, sub {
-        my ($self, $cmd, $args, $info) = @_;
-        
-        if ($cmd eq 'G1' && $info->{extruding}) {
-            $paths{ $self->Z } ||= [];
-            push @{ $paths{ $self->Z } }, Slic3r::Line->new(
-                [ $self->X, $self->Y ],
-                [ $info->{new_X}, $info->{new_Y} ],
-            );
-        }
-    });
-    
-    # calculate print extents
-    my $bounding_box = Slic3r::Geometry::BoundingBox->new_from_points([ map @$_, map @$_, values %paths ]);
-    
-    # calculate section line
-    my $section_y = $bounding_box->center->[Y];
-    my $section_line = [
-        [ $bounding_box->x_min, $section_y ],
-        [ $bounding_box->x_max, $section_y ],
-    ];
-    
-    # initialize output
-    my $max_z = max(keys %paths);
-    my $svg = SVG->new(
-        width  => $opt{scale} * $bounding_box->size->[X],
-        height => $opt{scale} * $max_z,
-    );
-    
-    # put everything into a group
-    my $g = $svg->group(style => {
-        'stroke-width'  => 1,
-        'stroke'        => '#444444',
-        'fill'          => 'grey',
-    });
-    
-    # draw paths
-    foreach my $z (sort keys %paths) {
-        foreach my $line (@{ $paths{$z} }) {
-            my @intersections = @{intersection_pl(
-                [ $section_line ],
-                [ _grow($line, $opt{extrusion_width}/2) ],
-            )};
-            
-            $g->rectangle(
-                'x'         => $opt{scale} * ($_->[0][X] - $bounding_box->x_min),
-                'y'         => $opt{scale} * ($max_z - $z),
-                'width'     => $opt{scale} * abs($_->[1][X] - $_->[0][X]),
-                'height'    => $opt{scale} * $opt{layer_height},
-                'rx'        => $opt{scale} * $opt{layer_height} * 0.35,
-                'ry'        => $opt{scale} * $opt{layer_height} * 0.35,
-            ) for @intersections;
-        }
-    }
-    
-    # write output
-    Slic3r::open(\my $fh, '>', $output_file);
-    print $fh $svg->xmlify;
-    close $fh;
-    printf "Section cut SVG written to %s\n", $output_file;
-}
-
-# replace built-in Line->grow method which relies on int_offset()
-sub _grow {
-    my ($line, $distance) = @_;
-    
-    my $polygon = [ @$line, CORE::reverse @$line[1..($#$line-1)] ];
-    return @{Math::Clipper::offset([$polygon], $distance, 100000, JT_SQUARE, 2)};
-}
-
-sub usage {
-    my ($exit_code) = @_;
-    
-    print <<"EOF";
-Usage: gcode_sectioncut.pl [ OPTIONS ] file.gcode
-
-    --help              Output this usage screen and exit
-    --layer-height, -h  Use the specified layer height
-    --extrusion-width, -w  Use the specified extrusion width
-    --scale             Factor for converting G-code units to SVG units
-    
-EOF
-    exit ($exit_code || 0);
-}
-
-__END__

xs/CMakeLists.txt

@@ -205,6 +205,8 @@ add_library(libslic3r_gui STATIC
     ${LIBDIR}/slic3r/GUI/RammingChart.hpp
     ${LIBDIR}/slic3r/GUI/BonjourDialog.cpp
     ${LIBDIR}/slic3r/GUI/BonjourDialog.hpp
+    ${LIBDIR}/slic3r/Utils/ASCIIFolding.cpp
+    ${LIBDIR}/slic3r/Utils/ASCIIFolding.hpp
     ${LIBDIR}/slic3r/Utils/Http.cpp
     ${LIBDIR}/slic3r/Utils/Http.hpp
     ${LIBDIR}/slic3r/Utils/OctoPrint.cpp

xs/src/libslic3r/Fill/FillRectilinear2.cpp

@@ -1427,10 +1427,12 @@ Polylines FillTriangles::fill_surface(const Surface *surface, const FillParams &
     // Each linear fill covers 1/3 of the target coverage.
     FillParams params2 = params;
     params2.density *= 0.333333333f;
+    FillParams params3 = params2;
+    params3.dont_connect = true;
     Polylines polylines_out;
     if (! fill_surface_by_lines(surface, params2, 0.f, 0., polylines_out) ||
         ! fill_surface_by_lines(surface, params2, float(M_PI / 3.), 0., polylines_out) ||
-        ! fill_surface_by_lines(surface, params2, float(2. * M_PI / 3.), 0., polylines_out)) {
+        ! fill_surface_by_lines(surface, params3, float(2. * M_PI / 3.), 0., polylines_out)) {
         printf("FillTriangles::fill_surface() failed to fill a region.\n");
     }
     return polylines_out;
@@ -1441,10 +1443,12 @@ Polylines FillStars::fill_surface(const Surface *surface, const FillParams &para
     // Each linear fill covers 1/3 of the target coverage.
     FillParams params2 = params;
     params2.density *= 0.333333333f;
+    FillParams params3 = params2;
+    params3.dont_connect = true;
     Polylines polylines_out;
     if (! fill_surface_by_lines(surface, params2, 0.f, 0., polylines_out) ||
         ! fill_surface_by_lines(surface, params2, float(M_PI / 3.), 0., polylines_out) ||
-        ! fill_surface_by_lines(surface, params2, float(2. * M_PI / 3.), 0.5 * this->spacing / params2.density, polylines_out)) {
+        ! fill_surface_by_lines(surface, params3, float(2. * M_PI / 3.), 0.5 * this->spacing / params2.density, polylines_out)) {
         printf("FillStars::fill_surface() failed to fill a region.\n");
     }
     return polylines_out;
@@ -1455,12 +1459,14 @@ Polylines FillCubic::fill_surface(const Surface *surface, const FillParams &para
     // Each linear fill covers 1/3 of the target coverage.
     FillParams params2 = params;
     params2.density *= 0.333333333f;
+    FillParams params3 = params2;
+    params3.dont_connect = true;
     Polylines polylines_out;
     coordf_t dx = sqrt(0.5) * z;
     if (! fill_surface_by_lines(surface, params2, 0.f, dx, polylines_out) ||
         ! fill_surface_by_lines(surface, params2, float(M_PI / 3.), - dx, polylines_out) ||
         // Rotated by PI*2/3 + PI to achieve reverse sloping wall.
-        ! fill_surface_by_lines(surface, params2, float(M_PI * 2. / 3.), dx, polylines_out)) {
+        ! fill_surface_by_lines(surface, params3, float(M_PI * 2. / 3.), dx, polylines_out)) {
         printf("FillCubic::fill_surface() failed to fill a region.\n");
     } 
     return polylines_out; 

xs/src/libslic3r/GCode/CoolingBuffer.cpp

@@ -107,9 +107,11 @@ std::string CoolingBuffer::process_layer(const std::string &gcode, size_t layer_
                 TYPE_G1                 = 1 << 5,
                 TYPE_ADJUSTABLE         = 1 << 6,
                 TYPE_EXTERNAL_PERIMETER = 1 << 7,
-                TYPE_WIPE               = 1 << 8,
+                // The line sets a feedrate.
-                TYPE_G4                 = 1 << 9,
+                TYPE_HAS_F              = 1 << 8,
-                TYPE_G92                = 1 << 10,
+                TYPE_WIPE               = 1 << 9,
+                TYPE_G4                 = 1 << 10,
+                TYPE_G92                = 1 << 11,
             };
 
             Line(unsigned int type, size_t  line_start, size_t  line_end) :
@@ -187,9 +189,13 @@ std::string CoolingBuffer::process_layer(const std::string &gcode, size_t layer_
                                   (*c == extrusion_axis) ? 3 : (*c == 'F') ? 4 : size_t(-1);
 					if (axis != size_t(-1)) {
 						new_pos[axis] = float(atof(++c));
-						if (axis == 4)
+						if (axis == 4) {
 							// Convert mm/min to mm/sec.
 							new_pos[4] /= 60.f;
+                            if ((line.type & Adjustment::Line::TYPE_G92) == 0)
+                                // This is G0 or G1 line and it sets the feedrate. This mark is used for reducing the duplicate F calls.
+                                line.type |= Adjustment::Line::TYPE_HAS_F;
+                        }
 					}
                     // Skip this word.
                     for (; *c != ' ' && *c != '\t' && *c != 0; ++ c);
@@ -227,6 +233,8 @@ std::string CoolingBuffer::process_layer(const std::string &gcode, size_t layer_
 					if ((line.type & Adjustment::Line::TYPE_ADJUSTABLE) || active_speed_modifier != size_t(-1))
                         line.time_max = (min_print_speed == 0.f) ? FLT_MAX : std::max(line.time, line.length / min_print_speed);
 					if (active_speed_modifier < adjustment->lines.size() && (line.type & Adjustment::Line::TYPE_G1)) {
+                        // Inside the ";_EXTRUDE_SET_SPEED" blocks, there must not be a G1 Fxx entry.
+                        assert((line.type & Adjustment::Line::TYPE_HAS_F) == 0);
 						Adjustment::Line &sm = adjustment->lines[active_speed_modifier];
 						sm.length   += line.length;
 						sm.time     += line.time;
@@ -415,17 +423,20 @@ std::string CoolingBuffer::process_layer(const std::string &gcode, size_t layer_
     };
 	change_extruder_set_fan();
 
-    size_t pos = 0;
+    const char *pos              = gcode.c_str();
+    int         current_feedrate = 0;
     for (const Adjustment::Line *line : lines) {
-        if (line->line_start > pos)
+        const char *line_start  = gcode.c_str() + line->line_start;
-            new_gcode.append(gcode.c_str() + pos, line->line_start - pos);
+        const char *line_end    = gcode.c_str() + line->line_end;
+        if (line_start > pos)
+            new_gcode.append(pos, line_start - pos);
         if (line->type & Adjustment::Line::TYPE_SET_TOOL) {
-            unsigned int new_extruder = (unsigned int)atoi(gcode.c_str() + line->line_start + toolchange_prefix.size());
+            unsigned int new_extruder = (unsigned int)atoi(line_start + toolchange_prefix.size());
             if (new_extruder != m_current_extruder) {
                 m_current_extruder = new_extruder;
                 change_extruder_set_fan();
             }
-            new_gcode.append(gcode.c_str() + line->line_start, line->line_end - line->line_start);
+            new_gcode.append(line_start, line_end - line_start);
         } else if (line->type & Adjustment::Line::TYPE_BRIDGE_FAN_START) {
             if (bridge_fan_control)
                 new_gcode += m_gcodegen.writer().set_fan(bridge_fan_speed, true);
@@ -434,27 +445,61 @@ std::string CoolingBuffer::process_layer(const std::string &gcode, size_t layer_
                 new_gcode += m_gcodegen.writer().set_fan(fan_speed, true);
         } else if (line->type & Adjustment::Line::TYPE_EXTRUDE_END) {
             // Just remove this comment.
-        } else if (line->type & (Adjustment::Line::TYPE_ADJUSTABLE | Adjustment::Line::TYPE_EXTERNAL_PERIMETER | Adjustment::Line::TYPE_WIPE)) {
+        } else if (line->type & (Adjustment::Line::TYPE_ADJUSTABLE | Adjustment::Line::TYPE_EXTERNAL_PERIMETER | Adjustment::Line::TYPE_WIPE | Adjustment::Line::TYPE_HAS_F)) {
-            // Start of the comment. The line type indicates there must be some comment present.
+            // Find the start of a comment, or roll to the end of line.
-            const char *end = strchr(gcode.c_str() + line->line_start, ';');
+			const char *end = line_start;
+			for (; end < line_end && *end != ';'; ++ end);
+			// Find the 'F' word.
+            const char *fpos            = strstr(line_start + 2, " F") + 2;
+            int         new_feedrate    = current_feedrate;
+            bool        modify          = false;
+            assert(fpos != nullptr);
             if (line->slowdown) {
-                // Replace the feedrate.
+                modify       = true;
-                const char *pos = strstr(gcode.c_str() + line->line_start + 2, " F") + 2;
+                new_feedrate = int(floor(60. * (line->length / line->time) + 0.5));
-                new_gcode.append(gcode.c_str() + line->line_start, pos - gcode.c_str() - line->line_start);
-                char buf[64];
-                sprintf(buf, "%d", int(floor(60. * (line->length / line->time) + 0.5)));
-                new_gcode += buf;
-                // Skip the non-whitespaces up to the comment.
-                for (; *pos != ' ' && *pos != ';'; ++ pos);
-                // Append the rest of the line without the comment.
-                if (pos < end)
-                    new_gcode.append(pos, end - pos);
             } else {
+                new_feedrate = atoi(fpos);
+                if (new_feedrate != current_feedrate) {
                     // Append the line without the comment.
-                new_gcode.append(gcode.c_str() + line->line_start, end - gcode.c_str() - line->line_start);
+                    new_gcode.append(line_start, end - line_start);
+                    current_feedrate = new_feedrate;
+                } else if ((line->type & (Adjustment::Line::TYPE_ADJUSTABLE | Adjustment::Line::TYPE_EXTERNAL_PERIMETER | Adjustment::Line::TYPE_WIPE)) || line->length == 0.) {
+                    // Feedrate does not change and this line does not move the print head. Skip the complete G-code line including the G-code comment.
+                    end = line_end;
+                } else {
+                    // Remove the feedrate from the G0/G1 line.
+                    modify = true;
                 }
-            // Process the comments, remove ";_EXTRUDE_SET_SPEED", ";_EXTERNAL_PERIMETER", ";_WIPE"
+            }
-            std::string comment(end, gcode.c_str() + line->line_end);
+            if (modify) {
+                if (new_feedrate != current_feedrate) {
+                    // Replace the feedrate.
+                    new_gcode.append(line_start, fpos - line_start);
+                    current_feedrate = new_feedrate;
+                    char buf[64];
+                    sprintf(buf, "%d", int(current_feedrate));
+                    new_gcode += buf;
+                } else {
+                    // Remove the feedrate word.
+                    const char *f = fpos;
+                    // Roll the pointer before the 'F' word.
+                    for (f -= 2; f > line_start && (*f == ' ' || *f == '\t'); -- f);
+                    // Append up to the F word, without the trailing whitespace.
+                    new_gcode.append(line_start, f - line_start + 1);
+                }
+                // Skip the non-whitespaces of the F parameter up the comment or end of line.
+				for (; fpos != end && *fpos != ' ' && *fpos != ';' && *fpos != '\n'; ++fpos);
+                // Append the rest of the line without the comment.
+                if (fpos < end)
+                    new_gcode.append(fpos, end - fpos);
+                // There should never be an empty G1 statement emited by the filter. Such lines should be removed completely.
+                assert(new_gcode.size() < 4 || new_gcode.substr(new_gcode.size() - 4) != "G1 \n");
+            }
+            // Process the rest of the line.
+            if (end < line_end) {
+                if (line->type & (Adjustment::Line::TYPE_ADJUSTABLE | Adjustment::Line::TYPE_EXTERNAL_PERIMETER | Adjustment::Line::TYPE_WIPE)) {
+					// Process comments, remove ";_EXTRUDE_SET_SPEED", ";_EXTERNAL_PERIMETER", ";_WIPE"
+					std::string comment(end, line_end);
 					boost::replace_all(comment, ";_EXTRUDE_SET_SPEED", "");
                     if (line->type & Adjustment::Line::TYPE_EXTERNAL_PERIMETER)
                         boost::replace_all(comment, ";_EXTERNAL_PERIMETER", "");
@@ -462,12 +507,18 @@ std::string CoolingBuffer::process_layer(const std::string &gcode, size_t layer_
                         boost::replace_all(comment, ";_WIPE", "");
 					new_gcode += comment;
 				} else {
-			new_gcode.append(gcode.c_str() + line->line_start, line->line_end - line->line_start);
+					// Just attach the rest of the source line.
+					new_gcode.append(end, line_end - end);
 				}
-        pos = line->line_end;
             }
-    if (pos < gcode.size())
+        } else {
-        new_gcode.append(gcode.c_str() + pos, gcode.size() - pos);
+			new_gcode.append(line_start, line_end - line_start);
+        }
+        pos = line_end;
+    }
+    const char *gcode_end = gcode.c_str() + gcode.size();
+    if (pos < gcode_end)
+        new_gcode.append(pos, gcode_end - pos);
 
     return new_gcode;
 }

xs/src/slic3r/Utils/ASCIIFolding.hpp

@@ -0,0 +1,15 @@
+#ifndef slic3r_ASCIIFolding_hpp_
+#define slic3r_ASCIIFolding_hpp_
+
+#include <string>
+
+namespace Slic3r {
+
+// If possible, remove accents from accented latin characters.
+// This function is useful for generating file names to be processed by legacy firmwares.
+extern std::string fold_utf8_to_ascii(const char *src);
+extern std::string fold_utf8_to_ascii(const std::string &src);
+
+}; // namespace Slic3r
+
+#endif /* slic3r_ASCIIFolding_hpp_ */

xs/xsp/GCode.xsp

@@ -23,7 +23,7 @@
             try {
                 THIS->do_export(print, path);
             } catch (std::exception& e) {
-                croak(e.what());
+                croak("%s\n", e.what());
             }
         %};
     void do_export_w_preview(Print *print, const char *path, GCodePreviewData *preview_data)

xs/xsp/GUI.xsp

@@ -3,6 +3,7 @@
 %{
 #include <xsinit.h>
 #include "slic3r/GUI/GUI.hpp"
+#include "slic3r/Utils/ASCIIFolding.hpp"
 %}
 
 
@@ -63,3 +64,6 @@ void add_frequently_changed_parameters(SV *ui_parent, SV *ui_sizer, SV *ui_p_siz
     %code%{ Slic3r::GUI::add_frequently_changed_parameters((wxWindow*)wxPli_sv_2_object(aTHX_ ui_parent, "Wx::Window"),
                                                            (wxBoxSizer*)wxPli_sv_2_object(aTHX_ ui_sizer, "Wx::BoxSizer"),
                                                            (wxFlexGridSizer*)wxPli_sv_2_object(aTHX_ ui_p_sizer, "Wx::FlexGridSizer")); %};
+
+std::string fold_utf8_to_ascii(const char *src)
+    %code%{ RETVAL = Slic3r::fold_utf8_to_ascii(src); %};

xs/xsp/PlaceholderParser.xsp

@@ -18,7 +18,7 @@
             try {
                 RETVAL = THIS->process(str, 0);
             } catch (std::exception& e) {
-                croak(e.what());
+                croak("%s\n", e.what());
             }
         %};
 
@@ -27,7 +27,7 @@
             try {
                 RETVAL = THIS->evaluate_boolean_expression(str, THIS->config());
             } catch (std::exception& e) {
-                croak(e.what());
+                croak("%s\n", e.what());
             }
         %};        
 };

xs/xsp/Print.xsp

@@ -212,7 +212,7 @@ _constant()
             try {
                 RETVAL = THIS->output_filepath(path);
             } catch (std::exception& e) {
-                croak(e.what());
+                croak("%s\n", e.what());
             }
         %};