PrusaSlicer-NonPlainar/xs/xsp/GCode.xsp

%module{Slic3r::XS};

%{
#include <myinit.h>
#include "libslic3r/GCode.hpp"
%}

%name{Slic3r::GCode::AvoidCrossingPerimeters} class AvoidCrossingPerimeters {
    AvoidCrossingPerimeters();
    ~AvoidCrossingPerimeters();
    
    void init_external_mp(ExPolygons islands);
    void init_layer_mp(ExPolygons islands);
    Clone<Polyline> travel_to(GCode* gcode, Point* point)
        %code{% RETVAL = THIS->travel_to(*gcode, *point); %};
    
    bool use_external_mp()
        %code{% RETVAL = THIS->use_external_mp; %};
    void set_use_external_mp(bool value)
        %code{% THIS->use_external_mp = value; %};
    
    bool use_external_mp_once()
        %code{% RETVAL = THIS->use_external_mp_once; %};
    void set_use_external_mp_once(bool value)
        %code{% THIS->use_external_mp_once = value; %};
    
    bool disable_once()
        %code{% RETVAL = THIS->disable_once; %};
    void set_disable_once(bool value)
        %code{% THIS->disable_once = value; %};
};

%name{Slic3r::GCode::OozePrevention} class OozePrevention {
    OozePrevention();
    ~OozePrevention();
    
    bool enable()
        %code{% RETVAL = THIS->enable; %};
    void set_enable(bool value)
        %code{% THIS->enable = value; %};
    
    Points standby_points()
        %code{% RETVAL = THIS->standby_points; %};
    void set_standby_points(Points points)
        %code{% THIS->standby_points = points; %};
};

%name{Slic3r::GCode::Wipe} class Wipe {
    Wipe();
    ~Wipe();
    
    bool has_path();
    void reset_path();
    std::string wipe(GCode* gcodegen, bool toolchange = false)
        %code{% RETVAL = THIS->wipe(*gcodegen, toolchange); %};
    
    bool enable()
        %code{% RETVAL = THIS->enable; %};
    void set_enable(bool value)
        %code{% THIS->enable = value; %};
    
    Ref<Polyline> path()
        %code{% RETVAL = &(THIS->path); %};
    void set_path(Polyline* value)
        %code{% THIS->path = *value; %};
};

%name{Slic3r::GCode} class GCode {
    GCode();
    ~GCode();
    
    Ref<Pointf> origin()
        %code{% RETVAL = &(THIS->origin); %};
    
    Ref<FullPrintConfig> config()
        %code{% RETVAL = &(THIS->config); %};
    
    Ref<GCodeWriter> writer()
        %code{% RETVAL = &(THIS->writer); %};
    
    Ref<PlaceholderParser> placeholder_parser()
        %code{% RETVAL = THIS->placeholder_parser; %};
    void set_placeholder_parser(PlaceholderParser* ptr)
        %code{% THIS->placeholder_parser = ptr; %};
    
    Ref<OozePrevention> ooze_prevention()
        %code{% RETVAL = &(THIS->ooze_prevention); %};
    
    Ref<Wipe> wipe()
        %code{% RETVAL = &(THIS->wipe); %};
    
    Ref<AvoidCrossingPerimeters> avoid_crossing_perimeters()
        %code{% RETVAL = &(THIS->avoid_crossing_perimeters); %};
    
    bool enable_loop_clipping()
        %code{% RETVAL = THIS->enable_loop_clipping; %};
    void set_enable_loop_clipping(bool value)
        %code{% THIS->enable_loop_clipping = value; %};
    
    bool enable_cooling_markers()
        %code{% RETVAL = THIS->enable_cooling_markers; %};
    void set_enable_cooling_markers(bool value)
        %code{% THIS->enable_cooling_markers = value; %};
    
    int layer_count()
        %code{% RETVAL = THIS->layer_count; %};
    void set_layer_count(int value)
        %code{% THIS->layer_count = value; %};
    
    int layer_index()
        %code{% RETVAL = THIS->layer_index; %};
    void set_layer_index(int value)
        %code{% THIS->layer_index = value; %};
    
    bool has_layer()
        %code{% RETVAL = THIS->layer != NULL; %};
    Ref<Layer> layer()
        %code{% RETVAL = THIS->layer; %};
    void set_layer(Layer* ptr)
        %code{% THIS->layer = ptr; %};
    
    bool _has_seam_position(PrintObject* ptr)
        %code{% RETVAL = THIS->_seam_position.count(ptr) > 0; %};
    Clone<Point> _seam_position(PrintObject* ptr)
        %code{% RETVAL = THIS->_seam_position[ptr]; %};
    void _set_seam_position(PrintObject* ptr, Point* pos)
        %code{% THIS->_seam_position[ptr] = *pos; %};
    
    bool first_layer()
        %code{% RETVAL = THIS->first_layer; %};
    void set_first_layer(bool value)
        %code{% THIS->first_layer = value; %};
    
    unsigned int elapsed_time()
        %code{% RETVAL = THIS->elapsed_time; %};
    void set_elapsed_time(unsigned int value)
        %code{% THIS->elapsed_time = value; %};
    
    bool last_pos_defined();
    Ref<Point> last_pos()
        %code{% RETVAL = &(THIS->last_pos()); %};
    void set_last_pos(Point* pos)
        %code{% THIS->set_last_pos(*pos); %};
    
    double volumetric_speed()
        %code{% RETVAL = THIS->volumetric_speed; %};
    void set_volumetric_speed(double value)
        %code{% THIS->volumetric_speed = value; %};
    
    void apply_print_config(PrintConfig* print_config)
        %code{% THIS->apply_print_config(*print_config); %};
    void set_origin(Pointf* pointf)
        %code{% THIS->set_origin(*pointf); %};
    std::string preamble();
    bool needs_retraction(Polyline* travel, ExtrusionRole role)
        %code{% RETVAL = THIS->needs_retraction(*travel, role); %};
    std::string retract(bool toolchange = false);
    std::string unretract();
    Clone<Pointf> point_to_gcode(Point* point)
        %code{% RETVAL = THIS->point_to_gcode(*point); %};
};