Namespaces
namespace	anonymous_namespace{Downloader.cpp}

namespace	anonymous_namespace{DownloaderFileGet.cpp}

namespace	anonymous_namespace{HintNotification.cpp}

namespace	anonymous_namespace{NotificationManager.cpp}

namespace	CommonGizmosDataObjects

namespace	Config

namespace	DownloaderUtils

namespace	Emboss

namespace	GUI_Descriptions

namespace	I18N

namespace	MessageHandlerInternal

namespace	search_for_drives_internal

Classes
class	AboutDialog

class	AboutDialogLogo

class	AppUpdateAvailableDialog

class	AppUpdateDownloadDialog

class	ArchiveViewCtrl

class	ArchiveViewModel

class	ArchiveViewNode

class	ArrangeJob

struct	ArrayEvent

struct	BackgroundTexture

class	Bed3D

class	Bed_2D

struct	BedShape

class	BedShapeDialog

class	BedShapePanel

class	BitmapCache

class	BitmapComboBox

struct	BlockingWait

class	BoostThreadWorker

struct	Bundle

struct	BundleMap

class	Busy

class	BusyCursored

struct	Camera

class	CameraUtils
	Help divide camera data and camera functions This utility work with camera data by static funtions. More...

class	CancellableJob

class	CheckBox

class	CheckboxFileDialog

class	Choice

class	ClippingPlane

class	ColourPicker

class	CommonGizmosDataBase

class	CommonGizmosDataPool

class	ConfigGUITypeError

class	ConfigManipulation

class	ConfigOptionsGroup

class	ConfigSnapshotDialog

class	ConfigWizard

class	ConfigWizardIndex

struct	ConfigWizardPage

class	CoordAxes

class	CopyrightsDialog

class	CreateFontImageJob
	Create image for face name. More...

struct	CursorSetterRAII

struct	DataList

class	DiamTextCtrl

class	DiffModel

class	DiffPresetDialog

class	DiffViewCtrl

class	Download

class	Downloader

class	DPIAware

struct	DpiChangedEvent

struct	DriveData

class	EmbossStylesSerializable
	For store/load font list to/from AppConfig. More...

class	ErrorDialog

struct	Event

class	EventGuard

class	ExtruderSequenceDialog

class	Field

class	FileArchiveDialog

class	FileGet

struct	FileWildcards

class	FillBedJob

struct	FontImageData
	Keep data for rasterization of text by font face. More...

class	FreqChangedParams

class	FullCompareDialog

class	GalleryDialog

class	GalleryDropTarget

class	GCodeViewer

class	GizmoHighlighterTimerEvent

class	GLCanvas3D

class	GLGizmoBase

class	GLGizmoCut3D

class	GLGizmoEmboss

class	GLGizmoFdmSupports

class	GLGizmoFlatten

class	GLGizmoHollow

class	GLGizmoMeasure

class	GLGizmoMmuSegmentation

class	GLGizmoMove3D

class	GLGizmoPainterBase

class	GLGizmoRotate

class	GLGizmoRotate3D

class	GLGizmoScale3D

class	GLGizmoSeam

class	GLGizmoSimplify

class	GLGizmoSlaBase

class	GLGizmoSlaSupports

class	GLGizmosManager

class	GLMmSegmentationGizmo3DScene

class	GLModel

class	GLSelectionRectangle

class	GLTexture

class	GLToolbar

class	GLToolbarItem

class	GUI_App

struct	GUI_InitParams

class	Highlighter

class	HighlighterForWx

struct	HintData

class	HintDatabase

class	IconManager
	Keep texture with icons for UI Manage texture live -> create and destruct texture by live of icon shared pointers. More...

class	ImGuiWrapper

class	InfoDialog

struct	InfoItemAtributes

struct	ItemForDelete

class	Job

class	KBShortcutsDialog

class	KeyAutoRepeatFilter

class	LayerRangeEditor

class	Line
	Represents option lines. More...

class	LoadProjectsDialog

class	MainFrame

class	ManipulationEditor

struct	Materials

class	MenuFactory

class	MeshClipper

struct	MeshErrorsInfo

class	MeshRaycaster

class	MessageDialog

class	ModelNode

class	ModePaletteComboBox

class	Mouse3DController

class	MsgDataIncompatible

class	MsgDataLegacy

struct	MsgDialog

class	MsgNoAppUpdates

class	MsgNoUpdates

class	MsgUpdateConfig

class	MsgUpdateForced

class	MsgUpdateSlic3r

class	NotificationManager

class	NotificationProgressIndicator

class	ObjectDataViewModel

class	ObjectDataViewModelNode

class	ObjectInfo

class	ObjectLayers

class	ObjectList

class	ObjectManipulation

class	ObjectSettings

class	OG_CustomCtrl

class	OG_Settings

class	ogStaticText

class	OpenGLManager

struct	OpenGLVersions

struct	Option
	std::function<wxWindow(wxWindow)>; More...

class	OptionsGroup

class	OtherInstanceMessageHandler

class	Page

struct	PageBedShape

struct	PageBuildVolume

struct	PageCustom

struct	PageDiameters

struct	PageDownloader

struct	PageFirmware

struct	PageMaterials

struct	PageMode

struct	PagePrinters

struct	PageReloadFromDisk

struct	PageTemperatures

struct	PageUpdate

struct	PageVendors

struct	PageWelcome

class	PhysicalPrinterDialog

struct	PickingModel

class	Plater

class	PlaterAfterLoadAutoArrange

class	PlaterDropTarget

class	PlaterPresetComboBox

class	PlaterWorker

class	PointCtrl

class	PreferencesDialog

class	PresetComboBox

class	PresetForPrinter

struct	PresetTab

class	Preview

struct	PrinterPicker

struct	PrinterPickerEvent

class	PrintHostQueueDialog

class	PrintHostSendDialog

struct	ProfilePrintData

class	ProjectDirtyStateManager

class	ProjectDropDialog

struct	PtrWrapper

class	RaycastManager
	Cast rays from camera to scene Used for find hit point on model volume under mouse cursor. More...

class	Rect

class	RemovableDriveManager

class	RenderTimerEvent

class	RetinaHelper

class	RichMessageDialog

class	RotoptimizeJob

class	SavePresetDialog

class	SceneRaycaster

class	SceneRaycasterItem

class	Selection

class	SendSystemInfoDialog

class	SendSystemInfoProgressDialog

class	SettingsDialog

struct	SettingsFactory

class	ShowJsonDialog

class	Sidebar

struct	SimpleEvent

class	Size

class	SlaGizmoHelpDialog

class	SLAImportDialog

class	SLAImportJob

class	SLAImportJobView

class	SlicedInfo

class	SliderCtrl

class	SpinCtrl

class	SpinCtrlDouble

class	SplashScreen

class	StaticLine

class	StaticText

class	SubstitutionManager

class	SuppressBackgroundProcessingUpdate

struct	SurfaceDrag

class	SysInfoDialog

class	Tab

class	TabFilament

class	TabPresetComboBox

class	TabPrint

class	TabPrinter

class	TabSLAMaterial

class	TabSLAPrint

class	TaskTimer

class	TextCtrl

class	ThreadSafeQueueSPSC

class	ToolbarHighlighterTimerEvent

class	TransformationType

class	TransformHelper

class	TranslationProcessor

class	TriangleSelectorGUI

class	TriangleSelectorMmGui

class	UIBuildCanceled

class	UIThreadWorker

class	UndoValueUIManager

class	UnsavedChangesDialog

class	View3D

class	WarningDialog

class	WindowMetrics

class	WipeTower

class	Worker

class	WxFontUtils

Typedefs
using	ConfigOptionsGroupShp = std::shared_ptr< ConfigOptionsGroup >

using	ConfigOptionsGroupWkp = std::weak_ptr< ConfigOptionsGroup >

typedef std::function< bool(const VendorProfile::PrinterModel &)>	ModelFilter

typedef DataList< wxListBox, std::string >	StringList

typedef DataList< wxCheckListBox, std::string >	PresetList

typedef std::map< std::string, std::pair< PagePrinters , PagePrinters > >	Pages3rdparty

typedef std::map< std::string, std::set< std::string > >	PresetAliases

using	choice_ctrl = wxComboBox

using	t_field = std::unique_ptr< Field >

using	t_kill_focus = std::function< void(const std::string &)>

using	t_change = std::function< void(const t_config_option_key &, const boost::any &)>

using	t_back_to_init = std::function< void(const std::string &)>

using	Vec2dEvent = Event< Vec2d >

using	RBtnEvent = Event< std::pair< Vec2d, bool > >

template<size_t N>
using	Vec2dsEvent = ArrayEvent< Vec2d, N >

using	Vec3dEvent = Event< Vec3d >

template<size_t N>
using	Vec3dsEvent = ArrayEvent< Vec3d, N >

using	HeightProfileSmoothEvent = Event< HeightProfileSmoothingParams >

typedef std::map< std::string, std::vector< std::pair< std::string, std::string > > >	FullSettingsHierarchy

typedef double	coordf_t

typedef std::pair< coordf_t, coordf_t >	t_layer_height_range

typedef DPIAware< wxFrame >	DPIFrame

typedef DPIAware< wxDialog >	DPIDialog

using	LoadFromOtherInstanceEvent = Event< std::vector< boost::filesystem::path > >

using	StartDownloadOtherInstanceEvent = Event< std::vector< std::string > >

using	InstanceGoToFrontEvent = SimpleEvent

using	EjectDriveNotificationClickedEvent = SimpleEvent

using	ExportGcodeNotificationClickedEvent = SimpleEvent

using	PresetUpdateAvailableClickedEvent = SimpleEvent

using	CancelFn = std::function< void()>

using	widget_t = std::function< wxSizer (wxWindow )>
	Widget type describes a function object that returns a wxWindow (our widget) and accepts a wxWidget (parent window).

using	t_option = std::unique_ptr< Option >

using	column_t = std::function< wxWindow (wxWindow parent, const Line &)>

using	t_optionfield_map = std::map< t_config_option_key, t_field >

using	t_opt_map = std::map< std::string, std::pair< std::string, int > >

using	t_optgroups = std::vector< std::shared_ptr< ConfigOptionsGroup > >

using	RemovableDriveEjectEvent = Event< std::pair< DriveData, bool > >

using	RemovableDrivesChangedEvent = SimpleEvent

using	PageShp = std::shared_ptr< Page >

using	ModelNodePtrArray = std::vector< std::unique_ptr< ModelNode > >

Enumerations
enum	{ WRAP_WIDTH = 500 , MODEL_MIN_WRAP = 150 , DIALOG_MARGIN = 15 , INDEX_MARGIN = 40 , BTN_SPACING = 10 , INDENT_SPACING = 30 , VERTICAL_SPACING = 10 , MAX_COLS = 4 , ROW_SPACING = 75 }

enum	Technology { T_FFF = 0x1 , T_SLA = 0x2 , T_ANY = ~0 }

enum	BundleLocation { IN_VENDOR , IN_ARCHIVE , IN_RESOURCES }

enum	DownloadState { DownloadPending = 0 , DownloadOngoing , DownloadStopped , DownloadDone , DownloadError , DownloadPaused , DownloadStateUnknown }

enum	DownloaderUserAction { DownloadUserCanceled , DownloadUserPaused , DownloadUserContinued , DownloadUserOpenedFolder }

enum class	PainterGizmoType { FDM_SUPPORTS , SEAM , MMU_SEGMENTATION }

enum class	SLAGizmoEventType : unsigned char { LeftDown = 1 , LeftUp , RightDown , Dragging , Delete , SelectAll , ShiftUp , AltUp , ApplyChanges , DiscardChanges , AutomaticGeneration , ManualEditing , MouseWheelUp , MouseWheelDown , ResetClippingPlane , LeftDown = 1 , LeftUp , RightDown , RightUp , Dragging , Delete , SelectAll , CtrlDown , CtrlUp , ShiftDown , ShiftUp , AltUp , Escape , ApplyChanges , DiscardChanges , AutomaticGeneration , ManualEditing , MouseWheelUp , MouseWheelDown , ResetClippingPlane , Moving }

enum class	SLAGizmoEventType : unsigned char { LeftDown = 1 , LeftUp , RightDown , Dragging , Delete , SelectAll , ShiftUp , AltUp , ApplyChanges , DiscardChanges , AutomaticGeneration , ManualEditing , MouseWheelUp , MouseWheelDown , ResetClippingPlane , LeftDown = 1 , LeftUp , RightDown , RightUp , Dragging , Delete , SelectAll , CtrlDown , CtrlUp , ShiftDown , ShiftUp , AltUp , Escape , ApplyChanges , DiscardChanges , AutomaticGeneration , ManualEditing , MouseWheelUp , MouseWheelDown , ResetClippingPlane , Moving }

enum class	CommonGizmosDataID { None = 0 , SelectionInfo = 1 << 0 , InstancesHider = 1 << 1 , Raycaster = 1 << 3 , ObjectClipper = 1 << 4 , SupportsClipper = 1 << 5 }

enum	FileType { FT_STL , FT_OBJ , FT_OBJECT , FT_STEP , FT_AMF , FT_3MF , FT_GCODE , FT_MODEL , FT_PROJECT , FT_FONTS , FT_GALLERY , FT_INI , FT_SVG , FT_TEX , FT_SL1 , FT_ZIP , FT_SIZE }

enum	ConfigMenuIDs { ConfigMenuWizard , ConfigMenuSnapshots , ConfigMenuTakeSnapshot , ConfigMenuUpdateConf , ConfigMenuUpdateApp , ConfigMenuDesktopIntegration , ConfigMenuPreferences , ConfigMenuModeSimple , ConfigMenuModeAdvanced , ConfigMenuModeExpert , ConfigMenuLanguage , ConfigMenuFlashFirmware , ConfigMenuCnt }

enum class	ECoordinatesType : unsigned char { World , Instance , Local }

enum	EditorType { etUndef = 0 , etMinZ = 1 , etMaxZ = 2 , etLayerHeight = 4 }

enum	{ DPI_DEFAULT = 96 }

enum class	ERescaleTarget { Mainframe , SettingsDialog }

enum	QuickSlice { qsUndef = 0 , qsReslice = 1 , qsSaveAs = 2 , qsExportSVG = 4 , qsExportPNG = 8 }

enum class	NotificationType { CustomNotification , ExportFinished , Mouse3dDisconnected , NewAppAvailable , NewAlphaAvailable , NewBetaAvailable , NoNewReleaseAvailable , PresetUpdateAvailable , ValidateError , ValidateWarning , SlicingError , SlicingWarning , PlaterError , PlaterWarning , ProgressBar , PrintHostUpload , AppDownload , SlicingProgress , EmptyColorChangeCode , CustomSupportsAndSeamRemovedAfterRepair , EmptyAutoColorChange , SignDetected , QuitSLAManualMode , DesktopIntegrationSuccess , DesktopIntegrationFail , UndoDesktopIntegrationSuccess , UndoDesktopIntegrationFail , MmSegmentationExceededExtrudersLimit , DidYouKnowHint , UpdatedItemsInfo , ProgressIndicator , SimplifySuggestion , UnknownFont , NetfabbFinished , ExportOngoing , URLDownload , URLNotRegistered }

enum	ItemType { itUndef = 0 , itObject = 1 , itVolume = 2 , itInstanceRoot = 4 , itInstance = 8 , itSettings = 16 , itLayerRoot = 32 , itLayer = 64 , itInfo = 128 }

enum	ColumnNumber { colName = 0 , colPrint , colExtruder , colEditing }

enum	PrintIndicator { piUndef = 0 , piPrintable , piUnprintable }

enum class	InfoItemType { Undef , CustomSupports , CustomSeam , CutConnectors , MmuSegmentation , Sinking , VariableLayerHeight }

enum	SlicedInfoIdx { siFilament_g , siFilament_m , siFilament_mm3 , siMateril_unit , siCost , siEstimatedTime , siWTNumbetOfToolchanges , siCount }

enum class	ActionButtonType : int { abReslice , abExport , abSendGCode }

enum	ExportingStatus { NOT_EXPORTING , EXPORTING_TO_REMOVABLE , EXPORTING_TO_LOCAL }

enum	ActionButtons { TRANSFER = 1 , KEEP = 2 , SAVE = 4 , DONT_SAVE = 8 }

enum class	Action { Undef , Transfer , Discard , Save }

enum class	NewSlicerInstanceType { Slicer , GCodeViewer }

Functions
static std::string	get_option_label (BedShape::Parameter param)

static wxBitmap	wxImage_to_wxBitmap_with_alpha (wxImage &&image, float scale=1.0f)

static wxString	format_reason (const Config::Snapshot::Reason reason)

static std::string	get_color (wxColour colour)

static wxString	generate_html_row (const Config::Snapshot &snapshot, bool row_even, bool snapshot_active, bool dark_mode)

static wxString	generate_html_page (const Config::SnapshotDB &snapshot_db, const wxString &on_snapshot)

	wxDEFINE_EVENT (EVT_PRINTER_PICK, PrinterPickerEvent)

static void	focus_event (wxFocusEvent &e, wxTextCtrl *ctrl, double def_value)

	wxDECLARE_EVENT (EVT_INDEX_PAGE, wxCommandEvent)

static std::set< std::string >	get_new_added_presets (const std::map< std::string, std::string > &old_data, const std::map< std::string, std::string > &new_data)

static std::string	get_first_added_preset (const std::map< std::string, std::string > &old_data, const std::map< std::string, std::string > &new_data)

	wxDEFINE_EVENT (EVT_INDEX_PAGE, wxCommandEvent)

	wxDEFINE_EVENT (EVT_DWNLDR_FILE_COMPLETE, wxCommandEvent)

	wxDEFINE_EVENT (EVT_DWNLDR_FILE_ERROR, wxCommandEvent)

	wxDEFINE_EVENT (EVT_DWNLDR_FILE_PROGRESS, wxCommandEvent)

	wxDEFINE_EVENT (EVT_DWNLDR_FILE_NAME_CHANGE, wxCommandEvent)

	wxDEFINE_EVENT (EVT_DWNLDR_FILE_PAUSED, wxCommandEvent)

	wxDEFINE_EVENT (EVT_DWNLDR_FILE_CANCELED, wxCommandEvent)

	wxDECLARE_EVENT (EVT_DWNLDR_FILE_COMPLETE, wxCommandEvent)

	wxDECLARE_EVENT (EVT_DWNLDR_FILE_PROGRESS, wxCommandEvent)

	wxDECLARE_EVENT (EVT_DWNLDR_FILE_ERROR, wxCommandEvent)

	wxDECLARE_EVENT (EVT_DWNLDR_FILE_NAME_CHANGE, wxCommandEvent)

	wxDECLARE_EVENT (EVT_DWNLDR_FILE_PAUSED, wxCommandEvent)

	wxDECLARE_EVENT (EVT_DWNLDR_FILE_CANCELED, wxCommandEvent)

wxString	double_to_string (double const value, const int max_precision)

wxString	get_thumbnails_string (const std::vector< Vec2d > &values)

static wxString	na_value (bool for_spin_ctrl=false)

template<class T >
bool	is_defined_input_value (wxWindow *win, const ConfigOptionType &type)

bool	is_bad_field (const t_field &obj)
	Convenience function, accepts a const reference to t_field and checks to see whether or not both wx pointers are null.

bool	is_window_field (const t_field &obj)
	Covenience function to determine whether this field is a valid window field.

bool	is_sizer_field (const t_field &obj)
	Covenience function to determine whether this field is a valid sizer field.

template<typename... TArgs>
wxString	format_wxstr (const char *fmt, TArgs &&... args)

template<typename... TArgs>
wxString	format_wxstr (const std::string &fmt, TArgs &&... args)

template<typename... TArgs>
wxString	format_wxstr (const wxString &fmt, TArgs &&... args)

template<typename... TArgs>
std::string	format (const char *fmt, TArgs &&... args)

template<typename... TArgs>
std::string	format (const std::string &fmt, TArgs &&... args)

template<typename... TArgs>
std::string	format (const wxString &fmt, TArgs &&... args)

static void	add_lock (wxImage &image, wxWindow *parent_win)

static void	add_default_image (wxImageList img_list, bool is_system, wxWindow parent_win)

static fs::path	get_dir (bool sys_dir)

static std::string	get_dir_path (bool sys_dir)

static void	generate_thumbnail_from_model (const std::string &filename)

static void	show_warning (const wxString &title, const std::string &error_file_type)

static unsigned char	buffer_id (EMoveType type)

static EMoveType	buffer_type (unsigned char id)

static float	round_to_bin (const float value)

static GLModel::Geometry	its_make_line (Vec3f beg_pos, Vec3f end_pos)

static void	init_from_circle (GLModel &model, double radius)
	– #ysFIXME those functions bodies are ported from GizmoRotation

static void	init_from_scale (GLModel &model, double radius)

static void	init_from_snap_radii (GLModel &model, double radius)

static void	init_from_angle_arc (GLModel &model, double angle, double radius)

static double	get_grabber_mean_size (const BoundingBoxf3 &bb)

static double	get_half_size (double size)

static double	get_dragging_half_size (double size)

void	update_object_cut_id (CutObjectBase &cut_id, ModelObjectCutAttributes attributes, const int dowels_count)

void	synchronize_model_after_cut (Model &model, const CutObjectBase &cut_id)

static std::string	format_double (double value)

static std::string	format_vec3 (const Vec3d &v)

static std::string	surface_feature_type_as_string (Measure::SurfaceFeatureType type)

static std::string	point_on_feature_type_as_string (Measure::SurfaceFeatureType type, int hover_id)

static std::string	center_on_feature_type_as_string (Measure::SurfaceFeatureType type)

static GLModel::Geometry	init_plane_data (const indexed_triangle_set &its, const std::vector< int > &triangle_indices)

static GLModel::Geometry	init_torus_data (unsigned int primary_resolution, unsigned int secondary_resolution, const Vec3f &center, float radius, float thickness, const Vec3f &model_axis, const Transform3f &world_trafo)

static bool	is_feature_with_center (const Measure::SurfaceFeature &feature)

static Vec3d	get_feature_offset (const Measure::SurfaceFeature &feature)

static void	add_row_to_table (std::function< void(void)> col_1=nullptr, std::function< void(void)> col_2=nullptr)

static void	add_strings_row_to_table (ImGuiWrapper &imgui, const std::string &col_1, const ImVec4 &col_1_color, const std::string &col_2, const ImVec4 &col_2_color)

static void	show_notification_extruders_limit_exceeded ()

static std::vector< ColorRGBA >	get_extruders_colors ()

static std::vector< std::string >	get_extruders_names ()

static std::vector< int >	get_extruder_id_for_volumes (const ModelObject &model_object)

static void	render_extruders_combo (const std::string &label, const std::vector< std::string > &extruders, const std::vector< ColorRGBA > &extruders_colors, size_t &selection_idx)

static int	constraint_id (int grabber_id)

static void	call_after_if_active (std::function< void()> fn, GUI_App *app=&wxGetApp())

static std::set< ObjectID >	get_volume_ids (const Selection &selection)

static ModelVolume *	get_volume (const ObjectID &id, const Selection &selection)

static std::string	create_volumes_name (const std::set< ObjectID > &ids, const Selection &selection)

static float	get_cursor_height ()

	wxDEFINE_EVENT (EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_OBJECT_SELECT, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_RIGHT_CLICK, RBtnEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_REMOVE_OBJECT, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_ARRANGE, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_SELECT_ALL, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_QUESTION_MARK, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_INCREASE_INSTANCES, Event< int >)

	wxDEFINE_EVENT (EVT_GLCANVAS_INSTANCE_MOVED, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_INSTANCE_ROTATED, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_RESET_SKEW, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_INSTANCE_SCALED, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_FORCE_UPDATE, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_WIPETOWER_MOVED, Vec3dEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_WIPETOWER_ROTATED, Vec3dEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_ENABLE_ACTION_BUTTONS, Event< bool >)

	wxDEFINE_EVENT (EVT_GLCANVAS_UPDATE_GEOMETRY, Vec3dsEvent< 2 >)

	wxDEFINE_EVENT (EVT_GLCANVAS_MOUSE_DRAGGING_STARTED, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_UPDATE_BED_SHAPE, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_TAB, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_RESETGIZMOS, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_MOVE_SLIDERS, wxKeyEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_EDIT_COLOR_CHANGE, wxKeyEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_JUMP_TO, wxKeyEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_UNDO, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_REDO, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_COLLAPSE_SIDEBAR, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_RESET_LAYER_HEIGHT_PROFILE, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_ADAPTIVE_LAYER_HEIGHT_PROFILE, Event< float >)

	wxDEFINE_EVENT (EVT_GLCANVAS_SMOOTH_LAYER_HEIGHT_PROFILE, HeightProfileSmoothEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_RELOAD_FROM_DISK, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_RENDER_TIMER, wxTimerEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_TOOLBAR_HIGHLIGHTER_TIMER, wxTimerEvent)

	wxDEFINE_EVENT (EVT_GLCANVAS_GIZMO_HIGHLIGHTER_TIMER, wxTimerEvent)

static std::vector< int >	processed_objects_idxs (const Model &model, const SLAPrint &sla_print, const GLVolumePtrs &volumes)

static bool	composite_id_match (const GLVolume::CompositeID &id1, const GLVolume::CompositeID &id2)

static bool	object_contains_negative_volumes (const Model &model, int obj_id)

static bool	object_has_sla_drain_holes (const Model &model, int obj_id)

static bool	string_getter (const bool is_undo, int idx, const char **out_text)

static bool	search_string_getter (int idx, const char label, const char tooltip)

const ModelVolume *	get_model_volume (const GLVolume &v, const Model &model)

const ModelVolume *	get_model_volume (const ObjectID &volume_id, const ModelObjectPtrs &objects)

ModelVolume *	get_model_volume (const GLVolume &v, const ModelObject &object)

ModelVolume *	get_model_volume (const GLVolume &v, const ModelObjectPtrs &objects)

GLVolume *	get_first_hovered_gl_volume (const GLCanvas3D &canvas)

GLVolume *	get_selected_gl_volume (const GLCanvas3D &canvas)

ModelObject *	get_model_object (const GLVolume &gl_volume, const Model &model)

ModelObject *	get_model_object (const GLVolume &gl_volume, const ModelObjectPtrs &objects)

ModelInstance *	get_model_instance (const GLVolume &gl_volume, const Model &model)

ModelInstance *	get_model_instance (const GLVolume &gl_volume, const ModelObjectPtrs &objects)

ModelInstance *	get_model_instance (const GLVolume &gl_volume, const ModelObject &object)

	wxDECLARE_EVENT (EVT_GLCANVAS_OBJECT_SELECT, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_RIGHT_CLICK, RBtnEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_REMOVE_OBJECT, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_ARRANGE, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_SELECT_ALL, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_QUESTION_MARK, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_INCREASE_INSTANCES, Event< int >)

	wxDECLARE_EVENT (EVT_GLCANVAS_INSTANCE_MOVED, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_FORCE_UPDATE, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_WIPETOWER_MOVED, Vec3dEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_INSTANCE_ROTATED, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_RESET_SKEW, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_INSTANCE_SCALED, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_WIPETOWER_ROTATED, Vec3dEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_ENABLE_ACTION_BUTTONS, Event< bool >)

	wxDECLARE_EVENT (EVT_GLCANVAS_UPDATE_GEOMETRY, Vec3dsEvent< 2 >)

	wxDECLARE_EVENT (EVT_GLCANVAS_MOUSE_DRAGGING_STARTED, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_UPDATE_BED_SHAPE, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_TAB, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_RESETGIZMOS, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_MOVE_SLIDERS, wxKeyEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_EDIT_COLOR_CHANGE, wxKeyEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_JUMP_TO, wxKeyEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_UNDO, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_REDO, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_COLLAPSE_SIDEBAR, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_RESET_LAYER_HEIGHT_PROFILE, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_ADAPTIVE_LAYER_HEIGHT_PROFILE, Event< float >)

	wxDECLARE_EVENT (EVT_GLCANVAS_SMOOTH_LAYER_HEIGHT_PROFILE, HeightProfileSmoothEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_RELOAD_FROM_DISK, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_RENDER_TIMER, wxTimerEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_TOOLBAR_HIGHLIGHTER_TIMER, wxTimerEvent)

	wxDECLARE_EVENT (EVT_GLCANVAS_GIZMO_HIGHLIGHTER_TIMER, wxTimerEvent)

static GLenum	get_primitive_mode (const GLModel::Geometry::Format &format)

static GLenum	get_index_type (const GLModel::Geometry &data)

template<typename Fn >
bool	all_vertices_inside (const GLModel::Geometry &geometry, Fn fn)

bool	contains (const BuildVolume &volume, const GLModel &model, bool ignore_bottom)

GLModel::Geometry	stilized_arrow (unsigned int resolution, float tip_radius, float tip_height, float stem_radius, float stem_height)

GLModel::Geometry	circular_arrow (unsigned int resolution, float radius, float tip_height, float tip_width, float stem_width, float thickness)

GLModel::Geometry	straight_arrow (float tip_width, float tip_height, float stem_width, float stem_height, float thickness)

GLModel::Geometry	diamond (unsigned int resolution)

GLModel::Geometry	smooth_sphere (unsigned int resolution, float radius)

GLModel::Geometry	smooth_cylinder (unsigned int resolution, float radius, float height)

GLModel::Geometry	smooth_torus (unsigned int primary_resolution, unsigned int secondary_resolution, float radius, float thickness)

static bool	to_squared_power_of_two (const std::string &filename, int max_size_px, int &w, int &h)

	wxDEFINE_EVENT (EVT_GLTOOLBAR_ADD, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLTOOLBAR_DELETE, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLTOOLBAR_DELETE_ALL, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLTOOLBAR_ARRANGE, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLTOOLBAR_COPY, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLTOOLBAR_PASTE, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLTOOLBAR_MORE, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLTOOLBAR_FEWER, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLTOOLBAR_SPLIT_OBJECTS, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLTOOLBAR_SPLIT_VOLUMES, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLTOOLBAR_LAYERSEDITING, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLVIEWTOOLBAR_3D, SimpleEvent)

	wxDEFINE_EVENT (EVT_GLVIEWTOOLBAR_PREVIEW, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLTOOLBAR_ADD, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLTOOLBAR_DELETE, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLTOOLBAR_DELETE_ALL, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLTOOLBAR_ARRANGE, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLTOOLBAR_COPY, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLTOOLBAR_PASTE, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLTOOLBAR_MORE, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLTOOLBAR_FEWER, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLTOOLBAR_SPLIT_OBJECTS, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLTOOLBAR_SPLIT_VOLUMES, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLTOOLBAR_LAYERSEDITING, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLVIEWTOOLBAR_3D, SimpleEvent)

	wxDECLARE_EVENT (EVT_GLVIEWTOOLBAR_PREVIEW, SimpleEvent)

void	disable_screensaver ()

void	enable_screensaver ()

bool	debugged ()

void	break_to_debugger ()

const std::string &	shortkey_ctrl_prefix ()

const std::string &	shortkey_alt_prefix ()

void	change_opt_value (DynamicPrintConfig &config, const t_config_option_key &opt_key, const boost::any &value, int opt_index)

void	show_error (wxWindow *parent, const wxString &message, bool monospaced_font)

void	show_error (wxWindow parent, const char message, bool monospaced_font)

void	show_error_id (int id, const std::string &message)

void	show_info (wxWindow *parent, const wxString &message, const wxString &title)

void	show_info (wxWindow parent, const char message, const char *title)

void	warning_catcher (wxWindow *parent, const wxString &message)

static wxString	bold (const wxString &str)

static wxString	bold_string (const wxString &str)

static void	add_config_substitutions (const ConfigSubstitutions &conf_substitutions, wxString &changes)

static wxString	substitution_message (const wxString &changes)

void	show_substitutions_info (const PresetsConfigSubstitutions &presets_config_substitutions)

void	show_substitutions_info (const ConfigSubstitutions &config_substitutions, const std::string &filename)

void	create_combochecklist (wxComboCtrl *comboCtrl, const std::string &text, const std::string &items)

unsigned int	combochecklist_get_flags (wxComboCtrl *comboCtrl)

void	combochecklist_set_flags (wxComboCtrl *comboCtrl, unsigned int flags)

AppConfig *	get_app_config ()

wxString	from_u8 (const std::string &str)

std::string	into_u8 (const wxString &str)

wxString	from_path (const boost::filesystem::path &path)

boost::filesystem::path	into_path (const wxString &str)

void	about ()

void	desktop_open_datadir_folder ()

void	desktop_open_folder (const boost::filesystem::path &path)

void	add_menus (wxMenuBar *menu, int event_preferences_changed, int event_language_change)

void	show_error (wxWindow *parent, const std::string &message, bool monospaced_font=false)

void	show_info (wxWindow *parent, const std::string &message, const std::string &title=std::string())

static wxString	file_wildcards (const FileWildcards &data)

wxString	file_wildcards (FileType file_type, const std::string &custom_extension)

wxString	sla_wildcards (const char *formatid)

static std::string	libslic3r_translate_callback (const char *s)

static void	generic_exception_handle ()

static boost::optional< Semver >	parse_semver_from_ini (std::string path)

void	fatal_error (wxWindow *parent)

static wxString	dots ("…", wxConvUTF8)

static PrinterTechnology	printer_technology ()

static int	extruders_count ()

static bool	is_improper_category (const std::string &category, const int extruders_cnt, const bool is_object_settings=true)

static Plater *	plater ()

static ObjectList *	obj_list ()

static ObjectDataViewModel *	list_model ()

static const Selection &	get_selection ()

static void	get_full_settings_hierarchy (FullSettingsHierarchy &settings_menu, const bool is_part)

static int	GetSelectedChoices (wxArrayInt &selections, const wxString &message, const wxString &caption, const wxArrayString &choices)

static wxMenu *	create_settings_popupmenu (wxMenu *parent_menu, const bool is_object_settings, wxDataViewItem item)

static void	create_freq_settings_popupmenu (wxMenu *menu, const bool is_object_settings, wxDataViewItem item)

int	GUI_Run (GUI_InitParams &params)

	wxDEFINE_EVENT (EVT_OBJ_LIST_OBJECT_SELECT, SimpleEvent)

static PrinterTechnology	printer_technology ()

static const Selection &	scene_selection ()

static DynamicPrintConfig &	printer_config ()

static int	extruders_count ()

static void	take_snapshot (const wxString &snapshot_name)

static std::string	get_warning_icon_name (const TriangleMeshStats &stats)

static wxString	get_item_name (const std::string &name, const bool is_text_volume)

static TriangleMesh	create_mesh (const std::string &type_name, const BoundingBoxf3 &bb)

static wxString	extruder2str (int extruder)

static bool	can_add_volumes_to_object (const ModelObject *object)

static void	update_selection (wxDataViewItemArray &sels, ObjectList::SELECTION_MODE mode, ObjectDataViewModel *model)

static double	get_min_layer_height (const int extruder_idx)

static double	get_max_layer_height (const int extruder_idx)

	wxDECLARE_EVENT (EVT_OBJ_LIST_OBJECT_SELECT, SimpleEvent)

static double	get_volume_min_z (const GLVolume &volume)

static choice_ctrl *	create_word_local_combo (wxWindow *parent)

void	msw_rescale_word_local_combo (choice_ctrl *combo)

static void	set_font_and_background_style (wxWindow *win, const wxFont &font)

static int	find_close_layer_idx (const std::vector< double > &zs, double &z, double eps)

wxTopLevelWindow *	find_toplevel_parent (wxWindow *window)

void	on_window_geometry (wxTopLevelWindow *tlw, std::function< void()> callback)

	wxDEFINE_EVENT (EVT_DPI_CHANGED_SLICER, DpiChangedEvent)

int	get_dpi_for_window (const wxWindow *window)

wxFont	get_default_font_for_dpi (const wxWindow *window, int dpi)

bool	check_dark_mode ()

std::ostream &	operator<< (std::ostream &os, const WindowMetrics &metrics)

wxFont	get_default_font (const wxWindow *window)

	wxDECLARE_EVENT (EVT_DPI_CHANGED_SLICER, DpiChangedEvent)

wxString	L_str (const std::string &str)

void	draw (const IconManager::Icon &icon, const ImVec2 &size=ImVec2(0, 0), const ImVec4 &tint_col=ImVec4(1, 1, 1, 1), const ImVec4 &border_col=ImVec4(0, 0, 0, 0))
	Draw imgui image with icon.

bool	clickable (const IconManager::Icon &icon, const IconManager::Icon &icon_hover)
	Draw icon which change on hover.

bool	button (const IconManager::Icon &activ, const IconManager::Icon &hover, const IconManager::Icon &disable, bool disabled=false)
	Use icon as button with 3 states activ hover and disabled.

static bool	image_button_ex (ImGuiID id, ImTextureID texture_id, const ImVec2 &size, const ImVec2 &uv0, const ImVec2 &uv1, const ImVec2 &padding, const ImVec4 &bg_col, const ImVec4 &tint_col, ImGuiButtonFlags flags)

static void	scroll_up ()

static void	scroll_down ()

static void	process_mouse_wheel (int &mouse_wheel)

static bool	selectable (const char *label, bool selected, ImGuiSelectableFlags flags=0, const ImVec2 &size_arg=ImVec2(0, 0))

static void	scroll_y (int hover_id)

static void	process_key_down (ImGuiKey imgui_key, std::function< void()> f)

template<typename T , typename Func >
static bool	input_optional (std::optional< T > &v, Func &f, std::function< bool(const T &)> is_default, const T &def_val)

	wxDEFINE_EVENT (EVT_LOAD_MODEL_OTHER_INSTANCE, LoadFromOtherInstanceEvent)

	wxDEFINE_EVENT (EVT_START_DOWNLOAD_OTHER_INSTANCE, StartDownloadOtherInstanceEvent)

	wxDEFINE_EVENT (EVT_INSTANCE_GO_TO_FRONT, InstanceGoToFrontEvent)

	wxDECLARE_EVENT (EVT_LOAD_MODEL_OTHER_INSTANCE, LoadFromOtherInstanceEvent)

	wxDECLARE_EVENT (EVT_START_DOWNLOAD_OTHER_INSTANCE, StartDownloadOtherInstanceEvent)

	wxDECLARE_EVENT (EVT_INSTANCE_GO_TO_FRONT, InstanceGoToFrontEvent)

static WipeTower	get_wipe_tower (const Plater &plater)

static void	update_arrangepoly_slaprint (arrangement::ArrangePolygon &ret, const SLAPrintObject &po, const ModelInstance &inst)

static coord_t	brim_offset (const PrintObject &po, const ModelInstance &inst)

coord_t	get_skirt_offset (const Plater *plater)

static std::string	concat_strings (const std::set< std::string > &strings, const std::string &delim="\n")

std::optional< arrangement::ArrangePolygon >	get_wipe_tower_arrangepoly (const Plater &plater)

double	bed_stride (const Plater *plater)

template<>
arrangement::ArrangePolygon	get_arrange_poly (ModelInstance inst, const Plater plater)

arrangement::ArrangeParams	get_arrange_params (Plater *p)

void	assign_logical_beds (std::vector< arrangement::ArrangePolygon > &items, const arrangement::ArrangeBed &bed, double stride)

template<class T >
arrangement::ArrangePolygon	get_arrange_poly (T obj, const Plater *plater)

template<>
arrangement::ArrangePolygon	get_arrange_poly (ModelInstance inst, const Plater plater)

std::string	get_readers_wildcard ()

template<class ProcessFn , class FinishFn , class = std::enable_if_t<IsProcessFn<ProcessFn>>, class = std::enable_if_t<IsFinishFn<FinishFn>>>
bool	queue_job (Worker &w, ProcessFn fn, FinishFn finishfn)

template<class ProcessFn , class = std::enable_if_t<IsProcessFn<ProcessFn>>>
bool	queue_job (Worker &w, ProcessFn fn)

bool	queue_job (Worker &w, std::unique_ptr< Job > j)

template<class... Args>
bool	replace_job (Worker &w, Args &&...args)

bool	stop_current_job (Worker &w, unsigned timeout_ms=0)

bool	stop_queue (Worker &w, unsigned timeout_ms=0)

static wxIcon	main_frame_icon (GUI_App::EAppMode app_mode)

static wxMenu *	generate_help_menu ()

static void	add_common_view_menu_items (wxMenu view_menu, MainFrame mainFrame, std::function< bool(void)> can_change_view)

static double	convert_input (int coord_byte_low, int coord_byte_high, double deadzone)

static void	add_msg_content (wxWindow parent, wxBoxSizer content_sizer, wxString msg, bool monospaced_font=false, bool is_marked_msg=false)

wxString	get_wraped_wxString (const wxString &in, size_t line_len)

	wxDEFINE_EVENT (EVT_EJECT_DRIVE_NOTIFICAION_CLICKED, EjectDriveNotificationClickedEvent)

	wxDEFINE_EVENT (EVT_EXPORT_GCODE_NOTIFICAION_CLICKED, ExportGcodeNotificationClickedEvent)

	wxDEFINE_EVENT (EVT_PRESET_UPDATE_AVAILABLE_CLICKED, PresetUpdateAvailableClickedEvent)

	wxDECLARE_EVENT (EVT_EJECT_DRIVE_NOTIFICAION_CLICKED, EjectDriveNotificationClickedEvent)

	wxDECLARE_EVENT (EVT_EXPORT_GCODE_NOTIFICAION_CLICKED, ExportGcodeNotificationClickedEvent)

	wxDECLARE_EVENT (EVT_PRESET_UPDATE_AVAILABLE_CLICKED, PresetUpdateAvailableClickedEvent)

	wxDEFINE_EVENT (wxCUSTOMEVT_LAST_VOLUME_IS_DELETED, wxCommandEvent)

wxBitmapBundle *	find_bndl (const std::string &bmp_name)

static int	get_root_idx (ObjectDataViewModelNode *parent_node, const ItemType root_type)

static bool	append_root_node (ObjectDataViewModelNode parent_node, ObjectDataViewModelNode *root_node, const ItemType root_type)

	WX_DEFINE_ARRAY_PTR (ObjectDataViewModelNode *, MyObjectTreeModelNodePtrArray)

	wxDECLARE_EVENT (wxCUSTOMEVT_LAST_VOLUME_IS_DELETED, wxCommandEvent)

static bool	is_point_in_rect (const wxPoint &pt, const wxRect &rect)

static wxSize	get_bitmap_size (const wxBitmapBundle bmp, wxWindow parent)

std::string	gl_get_string_safe (GLenum param, const std::string &default_value)

static Semver	parse_version_string (const std::string &version)

	wxDEFINE_EVENT (EVT_SCHEDULE_BACKGROUND_PROCESS, SimpleEvent)

	wxDEFINE_EVENT (EVT_SLICING_UPDATE, SlicingStatusEvent)

	wxDEFINE_EVENT (EVT_SLICING_COMPLETED, wxCommandEvent)

	wxDEFINE_EVENT (EVT_PROCESS_COMPLETED, SlicingProcessCompletedEvent)

	wxDEFINE_EVENT (EVT_EXPORT_BEGAN, wxCommandEvent)

static std::vector< std::pair< int, int > >	reloadable_volumes (const Model &model, const Selection &selection)

static long	GetNumberFromUser (const wxString &msg, const wxString &prompt, const wxString &title, long value, long min, long max, wxWindow *parent)

static void	update_color (wxColourPickerCtrl *color_pckr, const wxColour &color)

static std::shared_ptr< ConfigOptionsGroup >	create_options_tab (const wxString &title, wxBookCtrlBase *tabs)

static void	activate_options_tab (std::shared_ptr< ConfigOptionsGroup > optgroup)

static void	append_bool_option (std::shared_ptr< ConfigOptionsGroup > optgroup, const std::string &opt_key, const std::string &label, const std::string &tooltip, bool def_val, ConfigOptionMode mode=comSimple)

template<typename EnumType >
static void	append_enum_option (std::shared_ptr< ConfigOptionsGroup > optgroup, const std::string &opt_key, const std::string &label, const std::string &tooltip, const ConfigOption *def_val, std::initializer_list< std::pair< std::string_view, std::string_view > > enum_values, ConfigOptionMode mode=comSimple)

static void	append_preferences_option_to_searcher (std::shared_ptr< ConfigOptionsGroup > optgroup, const std::string &opt_key, const wxString &label)

static std::string	suffix (const Preset &preset)

static std::string	suffix (Preset *preset)

static wxString	get_preset_name_with_suffix (const Preset &preset)

static void	run_wizard (ConfigWizard::StartPage sp)

	wxDEFINE_EVENT (EVT_PRINTHOST_PROGRESS, PrintHostQueueDialog::Event)

	wxDEFINE_EVENT (EVT_PRINTHOST_ERROR, PrintHostQueueDialog::Event)

	wxDEFINE_EVENT (EVT_PRINTHOST_CANCEL, PrintHostQueueDialog::Event)

	wxDEFINE_EVENT (EVT_PRINTHOST_INFO, PrintHostQueueDialog::Event)

	wxDECLARE_EVENT (EVT_PRINTHOST_PROGRESS, PrintHostQueueDialog::Event)

	wxDECLARE_EVENT (EVT_PRINTHOST_ERROR, PrintHostQueueDialog::Event)

	wxDECLARE_EVENT (EVT_PRINTHOST_CANCEL, PrintHostQueueDialog::Event)

	wxDECLARE_EVENT (EVT_PRINTHOST_INFO, PrintHostQueueDialog::Event)

	wxDEFINE_EVENT (EVT_REMOVABLE_DRIVE_EJECTED, RemovableDriveEjectEvent)

	wxDEFINE_EVENT (EVT_REMOVABLE_DRIVES_CHANGED, RemovableDrivesChangedEvent)

bool	operator< (const DriveData &lhs, const DriveData &rhs)

bool	operator> (const DriveData &lhs, const DriveData &rhs)

bool	operator== (const DriveData &lhs, const DriveData &rhs)

	wxDECLARE_EVENT (EVT_REMOVABLE_DRIVE_EJECTED, RemovableDriveEjectEvent)

	wxDECLARE_EVENT (EVT_REMOVABLE_DRIVES_CHANGED, RemovableDrivesChangedEvent)

static ColorRGBA	get_color (Axis axis)

static bool	is_left_handed (const Transform3d::ConstLinearPart &m)

static bool	is_left_handed (const Transform3d &m)

static bool	is_rotation_xy_synchronized (const Vec3d &rot_xyz_from, const Vec3d &rot_xyz_to)

static bool	is_rotation_xy_synchronized (const Transform3d::ConstLinearPart &trafo_from, const Transform3d::ConstLinearPart &trafo_to)

static bool	is_rotation_xy_synchronized (const Transform3d &trafo_from, const Transform3d &trafo_to)

static void	verify_instances_rotation_synchronized (const Model &model, const GLVolumePtrs &volumes)

ModelVolume *	get_selected_volume (const Selection &selection)

const GLVolume *	get_selected_gl_volume (const Selection &selection)

static bool	should_dialog_be_shown ()

static void	save_version ()

static std::map< std::string, std::string >	parse_lscpu_etc (const std::string &name, char delimiter)

static std::string	get_unique_id ()

static std::string	generate_system_info_json ()

void	show_send_system_info_dialog_if_needed ()

static std::optional< double >	calc_scale (const Matrix3d &from, const Matrix3d &to, const Vec3d &dir)

bool	on_mouse_surface_drag (const wxMouseEvent &mouse_event, const Camera &camera, std::optional< SurfaceDrag > &surface_drag, GLCanvas3D &canvas, RaycastManager &raycast_manager, std::optional< double > up_limit={})
	Mouse event handler, when move(drag&drop) volume over model surface NOTE: Dragged volume has to be selected. And also has to be hovered on start of dragging.

std::optional< Vec3d >	calc_surface_offset (const Selection &selection, RaycastManager &raycast_manager)
	Calculate translation of volume onto surface of model.

Transform3d	world_matrix_fixed (const GLVolume &gl_volume, const ModelObjectPtrs &objects)
	Get transformation to world.

Transform3d	world_matrix_fixed (const Selection &selection)
	Get transformation to world.

std::string	get_main_info (bool format_as_html)

std::string	get_mem_info (bool format_as_html)

template<class T >
void	add_correct_opts_to_options_list (const std::string &opt_key, std::map< std::string, int > &map, Tab *tab, const int &value)

static wxString	support_combo_value_for_config (const DynamicPrintConfig &config, bool is_fff)

static wxString	pad_combo_value_for_config (const DynamicPrintConfig &config)

static void	validate_custom_gcode_cb (Tab *tab, const wxString &title, const t_config_option_key &opt_key, const boost::any &value)

static wxString	get_info_klipper_string ()

static void	add_options_into_line (ConfigOptionsGroupShp &optgroup, const std::vector< SamePair< std::string > > &prefixes, const std::string &optkey)

	wxDEFINE_EVENT (EVT_DIFF_DIALOG_TRANSFER, SimpleEvent)

	wxDEFINE_EVENT (EVT_DIFF_DIALOG_UPDATE_PRESETS, SimpleEvent)

static std::string	get_icon_name (Preset::Type type, PrinterTechnology pt)

static std::string	def_text_color ()

static void	color_string (wxString &str, const std::string &color)

static void	make_string_bold (wxString &str)

static void	update_children (ModelNode *parent)

static void	update_parents (ModelNode *node)

static void	rescale_children (ModelNode *parent)

static std::string	get_pure_opt_key (std::string opt_key)

static size_t	get_id_from_opt_key (std::string opt_key)

static wxString	get_full_label (std::string opt_key, const DynamicPrintConfig &config)

static wxString	get_string_value (std::string opt_key, const DynamicPrintConfig &config)

static PresetCollection *	get_preset_collection (Preset::Type type, PresetBundle *preset_bundle=nullptr)

static std::string	get_selection (PresetComboBox *preset_combo)

	wxDECLARE_EVENT (EVT_DIFF_DIALOG_TRANSFER, SimpleEvent)

	wxDECLARE_EVENT (EVT_DIFF_DIALOG_UPDATE_PRESETS, SimpleEvent)

static const std::string	CONFIG_UPDATE_WIKI_URL ("https://github.com/prusa3d/PrusaSlicer/wiki/Slic3r-PE-1.40-configuration-update")

bool	mac_dark_mode ()

double	mac_max_scaling_factor ()

static void	start_new_slicer_or_gcodeviewer (const NewSlicerInstanceType instance_type, const std::vector< wxString > paths_to_open, bool single_instance, bool delete_after_load)

static void	start_new_slicer_or_gcodeviewer (const NewSlicerInstanceType instance_type, const wxString *path_to_open, bool single_instance, bool delete_after_load)

void	start_new_slicer (const wxString *path_to_open, bool single_instance, bool delete_after_load)

void	start_new_slicer (const std::vector< wxString > &files, bool single_instance, bool delete_after_load)

void	start_new_gcodeviewer (const wxString *path_to_open)

void	start_new_gcodeviewer_open_file (wxWindow *parent)

RaycastManager::Meshes	create_meshes (GLCanvas3D &canvas, const RaycastManager::AllowVolumes &condition)
	Use scene Raycasters and prepare data for actualize RaycasterManager.

std::optional< RaycastManager::Hit >	ray_from_camera (const RaycastManager &raycaster, const Vec2d &mouse_pos, const Camera &camera, const RaycastManager::ISkip *skip)
	Unproject on mesh by Mesh raycasters.

Variables
static std::vector< std::pair< std::string, std::vector< std::string > > >	MODE_PALETTES

static const std::unordered_map< std::string, std::pair< std::string, std::string > >	legacy_preset_map

const size_t	DOWNLOAD_MAX_CHUNK_SIZE = 10 * 1024 * 1024

const size_t	DOWNLOAD_SIZE_LIMIT = 1024 * 1024 * 1024

static const ColorRGBA	DEFAULT_BASE_COLOR = { 0.625f, 0.625f, 0.625f, 1.0f }

static const ColorRGBA	DEFAULT_DRAG_COLOR = ColorRGBA::WHITE()

static const ColorRGBA	DEFAULT_HIGHLIGHT_COLOR = ColorRGBA::ORANGE()

static const std::array< ColorRGBA, 3 >	AXES_COLOR = {{ ColorRGBA::X(), ColorRGBA::Y(), ColorRGBA::Z() }}

static const ColorRGBA	CONSTRAINED_COLOR = ColorRGBA::GRAY()

static const ColorRGBA	GRABBER_COLOR = ColorRGBA::YELLOW()

static const ColorRGBA	UPPER_PART_COLOR = ColorRGBA::CYAN()

static const ColorRGBA	LOWER_PART_COLOR = ColorRGBA::MAGENTA()

static const ColorRGBA	MODIFIER_COLOR = ColorRGBA(0.75f, 0.75f, 0.75f, 0.5f)

static const ColorRGBA	PLAG_COLOR = ColorRGBA::YELLOW()

static const ColorRGBA	DOWEL_COLOR = ColorRGBA::DARK_YELLOW()

static const ColorRGBA	HOVERED_PLAG_COLOR = ColorRGBA::CYAN()

static const ColorRGBA	HOVERED_DOWEL_COLOR = ColorRGBA(0.0f, 0.5f, 0.5f, 1.0f)

static const ColorRGBA	SELECTED_PLAG_COLOR = ColorRGBA::GRAY()

static const ColorRGBA	SELECTED_DOWEL_COLOR = ColorRGBA::DARK_GRAY()

static const ColorRGBA	CONNECTOR_DEF_COLOR = ColorRGBA(1.0f, 1.0f, 1.0f, 0.5f)

static const ColorRGBA	CONNECTOR_ERR_COLOR = ColorRGBA(1.0f, 0.3f, 0.3f, 0.5f)

static const ColorRGBA	HOVERED_ERR_COLOR = ColorRGBA(1.0f, 0.3f, 0.3f, 1.0f)

const unsigned int	AngleResolution = 64

const unsigned int	ScaleStepsCount = 72

const float	ScaleStepRad = 2.0f * float(PI) / ScaleStepsCount

const unsigned int	ScaleLongEvery = 2

const float	ScaleLongTooth = 0.1f

const unsigned int	SnapRegionsCount = 8

const float	UndefFloat = -999.f

const std::string	UndefLabel = " "

static const Slic3r::ColorRGBA	DEFAULT_PLANE_COLOR = { 0.9f, 0.9f, 0.9f, 0.5f }

static const Slic3r::ColorRGBA	DEFAULT_HOVER_PLANE_COLOR = { 0.9f, 0.9f, 0.9f, 0.75f }

static const Slic3r::ColorRGBA	SELECTED_1ST_COLOR = { 0.25f, 0.75f, 0.75f, 1.0f }

static const Slic3r::ColorRGBA	SELECTED_2ND_COLOR = { 0.75f, 0.25f, 0.75f, 1.0f }

static const Slic3r::ColorRGBA	NEUTRAL_COLOR = { 0.5f, 0.5f, 0.5f, 1.0f }

static const int	POINT_ID = 100

static const int	EDGE_ID = 200

static const int	CIRCLE_ID = 300

static const int	PLANE_ID = 400

static const int	SEL_SPHERE_1_ID = 501

static const int	SEL_SPHERE_2_ID = 502

static const float	TRIANGLE_BASE = 10.0f

static const float	TRIANGLE_HEIGHT = TRIANGLE_BASE * 1.618033f

static const std::string	CTRL_STR

static const ColorRGBA	DISABLED_COLOR = ColorRGBA::DARK_GRAY()

static const int	VOLUME_RAYCASTERS_BASE_ID = (int)SceneRaycaster::EIdBase::Gizmo

static const FileWildcards	file_wildcards_by_type [FT_SIZE]

static SettingsFactory::Bundle	FREQ_SETTINGS_BUNDLE_FFF

static SettingsFactory::Bundle	FREQ_SETTINGS_BUNDLE_SLA

static const constexpr std::array< std::pair< const char , const char >, 5 >	ADD_VOLUME_MENU_ITEMS

static const constexpr std::array< std::pair< const char , const char >, 3 >	TEXT_VOLUME_ICONS

static const wxString	axes_color_text [] = { "#990000", "#009900", "#000099" }

static const wxString	axes_color_back [] = { "#f5dcdc", "#dcf5dc", "#dcdcf5" }

static const char	axes [] = { 'x', 'y', 'z' }

const std::string	BOLD_MARKER_START = "<b>"

const std::string	BOLD_MARKER_END = "</b>"

const std::string	HYPERTEXT_MARKER_START = "<a>"

const std::string	HYPERTEXT_MARKER_END = "</a>"

static const std::map< const wchar_t, std::string >	font_icons

static const std::map< const wchar_t, std::string >	font_icons_large

static const std::map< const wchar_t, std::string >	font_icons_extra_large

static const constexpr double	LOGICAL_BED_GAP = 1. / 5.

constexpr int	ABORT_WAIT_MAX_MS = 10000

template<class Fn >
constexpr bool	IsProcessFn = std::is_invocable_v<Fn, Job::Ctl&>

template<class Fn >
constexpr bool	IsFinishFn = std::is_invocable_v<Fn, bool, std::exception_ptr&>

static const wxString	sep = " - "

static const wxString	sep_space = ""

BitmapCache *	m_bitmap_cache = nullptr

static constexpr char	LayerRootIcon [] = "edit_layers_all"

static constexpr char	LayerIcon [] = "edit_layers_some"

static constexpr char	WarningIcon [] = "exclamation"

static constexpr char	WarningManifoldIcon [] = "exclamation_manifold"

static constexpr char	LockIcon [] = "cut_"

const std::map< InfoItemType, InfoItemAtributes >	INFO_ITEMS

static const std::set< std::string >	options_without_field

static const char *	CONFIG_KEY_PATH = "printhost_path"

static const char *	CONFIG_KEY_GROUP = "printhost_group"

static const char *	CONFIG_KEY_STORAGE = "printhost_storage"

constexpr auto	BORDER_W = 10

static std::map< Preset::Type, std::string >	TOP_LABELS

static const std::string	SEND_SYSTEM_INFO_DOMAIN = "prusa3d.com"

static const std::string	SEND_SYSTEM_INFO_URL = "https://files." + SEND_SYSTEM_INFO_DOMAIN + "/wp-json/v1/ps"

const std::vector< std::string >	extruder_options

static const std::map< Preset::Type, std::string >	type_icon_names

static std::string	grey = "#808080"

static std::string	orange = "#ed6b21"

static std::string	none {"none"}

static const char *	URL_CHANGELOG = "https://files.prusa3d.com/?latest=slicer-stable&lng=%1%"

static const char *	URL_DOWNLOAD = "https://www.prusa3d.com/slicerweb&lng=%1%"

static const char *	URL_DEV = "https://github.com/prusa3d/PrusaSlicer/releases/tag/version_%1%"

Class Documentation

◆ Slic3r::GUI::BackgroundTexture

struct Slic3r::GUI::BackgroundTexture

Collaboration diagram for Slic3r::GUI::BackgroundTexture:

Class Members
Metadata	metadata
GLTexture	texture

◆ Slic3r::GUI::BlockingWait

struct Slic3r::GUI::BlockingWait

Collaboration diagram for Slic3r::GUI::BlockingWait:

Class Members
atomic< bool > *	pop_flag = nullptr
unsigned	timeout_ms = 0

◆ Slic3r::GUI::FileWildcards

struct Slic3r::GUI::FileWildcards

Collaboration diagram for Slic3r::GUI::FileWildcards:

Class Members
vector< string_view >	file_extensions
string_view	title

◆ Slic3r::GUI::FontImageData

struct Slic3r::GUI::FontImageData

Keep data for rasterization of text by font face.

Collaboration diagram for Slic3r::GUI::FontImageData:

Class Members
shared_ptr< atomic< bool > >	cancel = nullptr
unsigned int *	count_opened_font_files = nullptr
wxFontEncoding	encoding
wxString	font_name
GLenum	format = GL_ALPHA
unsigned char	gray_level = 5
size_t	index
shared_ptr< bool >	is_created = nullptr
GLint	level = 0
Vec2i	size
string	text
GLuint	texture_id
GLenum	type = GL_UNSIGNED_BYTE

◆ Slic3r::GUI::GUI_InitParams

struct Slic3r::GUI::GUI_InitParams

Collaboration diagram for Slic3r::GUI::GUI_InitParams:

Class Members
int	argc
char **	argv
bool	delete_after_load
string	download_url
DynamicPrintConfig	extra_config
vector< string >	input_files
vector< string >	load_configs
PresetsConfigSubstitutions	preset_substitutions
bool	start_as_gcodeviewer
bool	start_downloader

◆ Slic3r::GUI::HintData

struct Slic3r::GUI::HintData

Collaboration diagram for Slic3r::GUI::HintData:

Class Members
function< void(void)>	callback { nullptr }
string	disabled_tags
string	documentation_link
string	enabled_tags
string	follow_text
string	hypertext
string	id_string
bool	runtime_disable
string	text
bool	was_displayed
size_t	weight

◆ Slic3r::GUI::InfoItemAtributes

struct Slic3r::GUI::InfoItemAtributes

Collaboration diagram for Slic3r::GUI::InfoItemAtributes:

Class Members
string	bmp_name
string	name

◆ Slic3r::GUI::MeshErrorsInfo

struct Slic3r::GUI::MeshErrorsInfo

Collaboration diagram for Slic3r::GUI::MeshErrorsInfo:

Class Members
wxString	tooltip
string	warning_icon_name

◆ Slic3r::GUI::PresetTab

struct Slic3r::GUI::PresetTab

Collaboration diagram for Slic3r::GUI::PresetTab:

Class Members
string	name
Tab *	panel
PrinterTechnology	technology

◆ Slic3r::GUI::SurfaceDrag

struct Slic3r::GUI::SurfaceDrag

Collaboration diagram for Slic3r::GUI::SurfaceDrag:

Class Members
AllowVolumes	condition
bool	exist_hit = true
GLVolume *	gl_volume
Transform3d	instance_inv
Vec2d	mouse_offset
Vec2d	mouse_offset_without_sla_shift
optional< float >	start_angle
Transform3d	world

Typedef Documentation

◆ CancelFn

using Slic3r::GUI::CancelFn = typedef std::function<void()>

◆ choice_ctrl

typedef wxComboBox Slic3r::GUI::choice_ctrl

◆ column_t

using Slic3r::GUI::column_t = typedef std::function<wxWindow*(wxWindow* parent, const Line&)>

◆ ConfigOptionsGroupShp

typedef std::shared_ptr< ConfigOptionsGroup > Slic3r::GUI::ConfigOptionsGroupShp

◆ ConfigOptionsGroupWkp

using Slic3r::GUI::ConfigOptionsGroupWkp = typedef std::weak_ptr<ConfigOptionsGroup>

◆ coordf_t

typedef double Slic3r::GUI::coordf_t

◆ DPIDialog

typedef DPIAware<wxDialog> Slic3r::GUI::DPIDialog

◆ DPIFrame

typedef DPIAware<wxFrame> Slic3r::GUI::DPIFrame

◆ EjectDriveNotificationClickedEvent

using Slic3r::GUI::EjectDriveNotificationClickedEvent = typedef SimpleEvent

◆ ExportGcodeNotificationClickedEvent

using Slic3r::GUI::ExportGcodeNotificationClickedEvent = typedef SimpleEvent

◆ FullSettingsHierarchy

typedef std::map< std::string, std::vector< std::pair<std::string, std::string> > > Slic3r::GUI::FullSettingsHierarchy

◆ HeightProfileSmoothEvent

using Slic3r::GUI::HeightProfileSmoothEvent = typedef Event<HeightProfileSmoothingParams>

◆ InstanceGoToFrontEvent

using Slic3r::GUI::InstanceGoToFrontEvent = typedef SimpleEvent

◆ LoadFromOtherInstanceEvent

using Slic3r::GUI::LoadFromOtherInstanceEvent = typedef Event<std::vector<boost::filesystem::path> >

◆ ModelFilter

typedef std::function<bool(const VendorProfile::PrinterModel&)> Slic3r::GUI::ModelFilter

◆ ModelNodePtrArray

using Slic3r::GUI::ModelNodePtrArray = typedef std::vector<std::unique_ptr<ModelNode> >

◆ Pages3rdparty

typedef std::map<std::string , std::pair<PagePrinters* , PagePrinters* > > Slic3r::GUI::Pages3rdparty

◆ PageShp

using Slic3r::GUI::PageShp = typedef std::shared_ptr<Page>

◆ PresetAliases

typedef std::map<std::string, std::set<std::string> > Slic3r::GUI::PresetAliases

◆ PresetList

typedef DataList<wxCheckListBox, std::string> Slic3r::GUI::PresetList

◆ PresetUpdateAvailableClickedEvent

using Slic3r::GUI::PresetUpdateAvailableClickedEvent = typedef SimpleEvent

◆ RBtnEvent

using Slic3r::GUI::RBtnEvent = typedef Event<std::pair<Vec2d, bool> >

◆ RemovableDriveEjectEvent

using Slic3r::GUI::RemovableDriveEjectEvent = typedef Event<std::pair<DriveData, bool> >

◆ RemovableDrivesChangedEvent

using Slic3r::GUI::RemovableDrivesChangedEvent = typedef SimpleEvent

◆ StartDownloadOtherInstanceEvent

using Slic3r::GUI::StartDownloadOtherInstanceEvent = typedef Event<std::vector<std::string> >

◆ StringList

typedef DataList<wxListBox, std::string> Slic3r::GUI::StringList

◆ t_back_to_init

using Slic3r::GUI::t_back_to_init = typedef std::function<void(const std::string&)>

◆ t_change

using Slic3r::GUI::t_change = typedef std::function<void(const t_config_option_key&, const boost::any&)>

◆ t_field

using Slic3r::GUI::t_field = typedef std::unique_ptr<Field>

◆ t_kill_focus

using Slic3r::GUI::t_kill_focus = typedef std::function<void(const std::string&)>

◆ t_layer_height_range

typedef std::pair< coordf_t, coordf_t > Slic3r::GUI::t_layer_height_range

◆ t_opt_map

using Slic3r::GUI::t_opt_map = typedef std::map< std::string, std::pair<std::string, int> >

◆ t_optgroups

using Slic3r::GUI::t_optgroups = typedef std::vector <std::shared_ptr<ConfigOptionsGroup> >

◆ t_option

using Slic3r::GUI::t_option = typedef std::unique_ptr<Option>

◆ t_optionfield_map

using Slic3r::GUI::t_optionfield_map = typedef std::map<t_config_option_key, t_field>

◆ Vec2dEvent

using Slic3r::GUI::Vec2dEvent = typedef Event<Vec2d>

◆ Vec2dsEvent

template<size_t N>

using Slic3r::GUI::Vec2dsEvent = typedef ArrayEvent<Vec2d, N>

◆ Vec3dEvent

using Slic3r::GUI::Vec3dEvent = typedef Event<Vec3d>

◆ Vec3dsEvent

template<size_t N>

using Slic3r::GUI::Vec3dsEvent = typedef ArrayEvent<Vec3d, N>

◆ widget_t

using Slic3r::GUI::widget_t = typedef std::function<wxSizer*(wxWindow*)>

Widget type describes a function object that returns a wxWindow (our widget) and accepts a wxWidget (parent window).

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
WRAP_WIDTH
MODEL_MIN_WRAP
DIALOG_MARGIN
INDEX_MARGIN
BTN_SPACING
INDENT_SPACING
VERTICAL_SPACING
MAX_COLS
ROW_SPACING

     {
    WRAP_WIDTH = 500,
    MODEL_MIN_WRAP = 150,
 
    DIALOG_MARGIN = 15,
    INDEX_MARGIN = 40,
    BTN_SPACING = 10,
    INDENT_SPACING = 30,
    VERTICAL_SPACING = 10,
 
    MAX_COLS = 4,
    ROW_SPACING = 75,
};

◆ anonymous enum

anonymous enum

Enumerator
DPI_DEFAULT

52{ DPI_DEFAULT = 96 };

Slic3r::GUI::DPI_DEFAULT

@ DPI_DEFAULT

Definition GUI_Utils.hpp:52

◆ Action

enum class Slic3r::GUI::Action

strong

Enumerator
Undef
Transfer
Discard
Save

                  {
    Undef,
    Transfer,
    Discard,
    Save
};

◆ ActionButtons

enum Slic3r::GUI::ActionButtons

Enumerator
TRANSFER
KEEP
SAVE
DONT_SAVE

                   {
    TRANSFER = 1,
    KEEP = 2,
    SAVE = 4,
    DONT_SAVE = 8,
};

◆ ActionButtonType

enum class Slic3r::GUI::ActionButtonType : int

strong

Enumerator
abReslice
abExport
abSendGCode

                            : int {
    abReslice,
    abExport,
    abSendGCode
};

◆ BundleLocation

enum Slic3r::GUI::BundleLocation

Enumerator
IN_VENDOR
IN_ARCHIVE
IN_RESOURCES

                   {
    IN_VENDOR,
    IN_ARCHIVE,
    IN_RESOURCES
};

◆ ColumnNumber

enum Slic3r::GUI::ColumnNumber

Enumerator
colName
colPrint
colExtruder
colEditing

{
    colName         = 0,    // item name
    colPrint           ,    // printable property
    colExtruder        ,    // extruder selection
    colEditing         ,    // item editing
};

◆ CommonGizmosDataID

enum class Slic3r::GUI::CommonGizmosDataID

strong

Enumerator
None
SelectionInfo
InstancesHider
Raycaster
ObjectClipper
SupportsClipper

                              {
    None                 = 0,
    SelectionInfo        = 1 << 0,
    InstancesHider       = 1 << 1,
    Raycaster            = 1 << 3,
    ObjectClipper        = 1 << 4,
    SupportsClipper      = 1 << 5,
 
};

◆ ConfigMenuIDs

enum Slic3r::GUI::ConfigMenuIDs

Enumerator
ConfigMenuWizard
ConfigMenuSnapshots
ConfigMenuTakeSnapshot
ConfigMenuUpdateConf
ConfigMenuUpdateApp
ConfigMenuDesktopIntegration
ConfigMenuPreferences
ConfigMenuModeSimple
ConfigMenuModeAdvanced
ConfigMenuModeExpert
ConfigMenuLanguage
ConfigMenuFlashFirmware
ConfigMenuCnt

                   {
    ConfigMenuWizard,
    ConfigMenuSnapshots,
    ConfigMenuTakeSnapshot,
    ConfigMenuUpdateConf,
    ConfigMenuUpdateApp,
    ConfigMenuDesktopIntegration,
    ConfigMenuPreferences,
    ConfigMenuModeSimple,
    ConfigMenuModeAdvanced,
    ConfigMenuModeExpert,
    ConfigMenuLanguage,
    ConfigMenuFlashFirmware,
    ConfigMenuCnt,
};

◆ DownloaderUserAction

enum Slic3r::GUI::DownloaderUserAction

Enumerator
DownloadUserCanceled
DownloadUserPaused
DownloadUserContinued
DownloadUserOpenedFolder

{
    DownloadUserCanceled,
    DownloadUserPaused,
    DownloadUserContinued,
    DownloadUserOpenedFolder
};

◆ DownloadState

enum Slic3r::GUI::DownloadState

Enumerator
DownloadPending
DownloadOngoing
DownloadStopped
DownloadDone
DownloadError
DownloadPaused
DownloadStateUnknown

{
    DownloadPending = 0,
    DownloadOngoing,
    DownloadStopped,
    DownloadDone,
    DownloadError,
    DownloadPaused,
    DownloadStateUnknown
};

◆ ECoordinatesType

enum class Slic3r::GUI::ECoordinatesType : unsigned char

strong

Enumerator
World
Instance
Local

{
    World,
    Instance,
    Local
};

◆ EditorType

enum Slic3r::GUI::EditorType

Enumerator
etUndef
etMinZ
etMaxZ
etLayerHeight

{
    etUndef         = 0,
    etMinZ          = 1,
    etMaxZ          = 2,
    etLayerHeight   = 4,
};

◆ ERescaleTarget

enum class Slic3r::GUI::ERescaleTarget

strong

Enumerator
Mainframe
SettingsDialog

{
    Mainframe,
    SettingsDialog
};

◆ ExportingStatus

enum Slic3r::GUI::ExportingStatus

Enumerator
NOT_EXPORTING
EXPORTING_TO_REMOVABLE
EXPORTING_TO_LOCAL

                    {
    NOT_EXPORTING,
    EXPORTING_TO_REMOVABLE,
    EXPORTING_TO_LOCAL
};

◆ FileType

enum Slic3r::GUI::FileType

Enumerator
FT_STL
FT_OBJ
FT_OBJECT
FT_STEP
FT_AMF
FT_3MF
FT_GCODE
FT_MODEL
FT_PROJECT
FT_FONTS
FT_GALLERY
FT_INI
FT_SVG
FT_TEX
FT_SL1
FT_ZIP
FT_SIZE

{
    FT_STL,
    FT_OBJ,
    FT_OBJECT,
    FT_STEP,
    FT_AMF,
    FT_3MF,
    FT_GCODE,
    FT_MODEL,
    FT_PROJECT,
    FT_FONTS,
    FT_GALLERY,
 
    FT_INI,
    FT_SVG,
 
    FT_TEX,
 
    FT_SL1,
 
    FT_ZIP,
 
    FT_SIZE,
};

◆ InfoItemType

enum class Slic3r::GUI::InfoItemType

strong

Enumerator
Undef
CustomSupports
CustomSeam
CutConnectors
MmuSegmentation
Sinking
VariableLayerHeight

{
    Undef,
    CustomSupports,
    CustomSeam,
    CutConnectors,
    MmuSegmentation,
    Sinking,
    VariableLayerHeight
};

◆ ItemType

enum Slic3r::GUI::ItemType

Enumerator
itUndef
itObject
itVolume
itInstanceRoot
itInstance
itSettings
itLayerRoot
itLayer
itInfo

              {
    itUndef         = 0,
    itObject        = 1,
    itVolume        = 2,
    itInstanceRoot  = 4,
    itInstance      = 8,
    itSettings      = 16,
    itLayerRoot     = 32,
    itLayer         = 64,
    itInfo          = 128
};

◆ NewSlicerInstanceType

enum class Slic3r::GUI::NewSlicerInstanceType

strong

Enumerator
Slicer
GCodeViewer

                                 {
  Slicer,
  GCodeViewer
};

◆ NotificationType

enum class Slic3r::GUI::NotificationType

strong

Enumerator
CustomNotification
ExportFinished
Mouse3dDisconnected
NewAppAvailable
NewAlphaAvailable
NewBetaAvailable
NoNewReleaseAvailable
PresetUpdateAvailable
ValidateError
ValidateWarning
SlicingError
SlicingWarning
PlaterError
PlaterWarning
ProgressBar
PrintHostUpload
AppDownload
SlicingProgress
EmptyColorChangeCode
CustomSupportsAndSeamRemovedAfterRepair
EmptyAutoColorChange
SignDetected
QuitSLAManualMode
DesktopIntegrationSuccess
DesktopIntegrationFail
UndoDesktopIntegrationSuccess
UndoDesktopIntegrationFail
MmSegmentationExceededExtrudersLimit
DidYouKnowHint
UpdatedItemsInfo
ProgressIndicator
SimplifySuggestion
UnknownFont
NetfabbFinished
ExportOngoing
URLDownload
URLNotRegistered

{
  CustomNotification,
//  SlicingNotPossible,
  // Notification on end of export to a removable media, with hyperling to eject the external media.
  // Obsolete by ExportFinished
//  ExportToRemovableFinished,
  // Notification on end of export, with hyperling to see folder and eject if export was to external media.
  // Own subclass.
  ExportFinished,
  // Works on OSX only.
  //FIXME Do we want to have it on Linux and Windows? Is it possible to get the Disconnect event on Windows?
  Mouse3dDisconnected,
//  Mouse3dConnected,
//  NewPresetsAviable,
  // Notification on the start of PrusaSlicer, when a new PrusaSlicer version is published.
  // Contains a hyperlink to open a web browser pointing to the PrusaSlicer download location.
  NewAppAvailable,
  // Like NewAppAvailable but with text and link for alpha / bet release
  NewAlphaAvailable,
  NewBetaAvailable,
  NoNewReleaseAvailable,
  // Notification on the start of PrusaSlicer, when updates of system profiles are detected.
  // Contains a hyperlink to execute installation of the new system profiles.
  PresetUpdateAvailable,
//  LoadingFailed,
  // Errors emmited by Print::validate
  // difference from Slicing error is that they disappear not grey out at update_background_process
  ValidateError,
  // Notification emitted by Print::validate
  ValidateWarning,
  // Slicing error produced by BackgroundSlicingProcess::validate() or by the BackgroundSlicingProcess background
  // thread thowing a SlicingError exception.
  SlicingError,
  // Slicing warnings, issued by the slicing process.
  // Slicing warnings are registered for a particular Print milestone or a PrintObject and its milestone.
  SlicingWarning,
  // Object partially outside the print volume. Cannot slice.
  PlaterError,
  // Object fully outside the print volume, or extrusion outside the print volume. Slicing is not disabled.
  PlaterWarning,
  // Progress bar instead of text.
  ProgressBar,
  // Progress bar with info from Print Host Upload Queue dialog.
  PrintHostUpload,
  // Progress bar of download next version app.
  AppDownload,
  // Progress bar with cancel button, cannot be closed
  // On end of slicing and G-code processing (the full G-code preview is available),
  // contains a hyperlink to export the G-code to a removable media or hdd.
  SlicingProgress,
  // Notification, when Color Change G-code is empty and user try to add color change on DoubleSlider.
    EmptyColorChangeCode,
    // Notification that custom supports/seams were deleted after mesh repair.
    CustomSupportsAndSeamRemovedAfterRepair,
    // Notification that auto adding of color changes is impossible
    EmptyAutoColorChange,
    // Notification about detected sign
    SignDetected,
    // Notification telling user to quit SLA supports manual editing
    QuitSLAManualMode,
    // Desktop integration basic info
    DesktopIntegrationSuccess,
    DesktopIntegrationFail,
    UndoDesktopIntegrationSuccess,
    UndoDesktopIntegrationFail,
    // Notification that a printer has more extruders than are supported by MM Gizmo/segmentation.
    MmSegmentationExceededExtrudersLimit,
  // Did you know Notification appearing on startup with arrows to change hint
  DidYouKnowHint,
  // Shows when  ObjectList::update_info_items finds information that should be stressed to the user
  // Might contain logo taken from gizmos
  UpdatedItemsInfo,
  // Progress bar notification with methods to replace ProgressIndicator class.
  ProgressIndicator,
  // Give user advice to simplify object with big amount of triangles
  // Contains ObjectID for closing when object is deleted
  SimplifySuggestion,
  // Change of text will change font to similar one on.
  UnknownFont,
  // information about netfabb is finished repairing model (blocking proccess)
  NetfabbFinished,
  // Short meesage to fill space between start and finish of export
  ExportOngoing,
  // Progressbar of download from prusaslicer:// url
  URLDownload,
  // MacOS specific - PS comes forward even when downloader is not allowed
  URLNotRegistered,
};

◆ PainterGizmoType

enum class Slic3r::GUI::PainterGizmoType

strong

Enumerator
FDM_SUPPORTS
SEAM
MMU_SEGMENTATION

                            {
    FDM_SUPPORTS,
    SEAM,
    MMU_SEGMENTATION
};

◆ PrintIndicator

enum Slic3r::GUI::PrintIndicator

Enumerator
piUndef
piPrintable
piUnprintable

{
    piUndef         = 0,    // no print indicator
    piPrintable        ,    // printable
    piUnprintable      ,    // unprintable
};

◆ QuickSlice

enum Slic3r::GUI::QuickSlice

Enumerator
qsUndef
qsReslice
qsSaveAs
qsExportSVG
qsExportPNG

{
    qsUndef = 0,
    qsReslice = 1,
    qsSaveAs = 2,
    qsExportSVG = 4,
    qsExportPNG = 8
};

◆ SLAGizmoEventType [1/2]

enum class Slic3r::GUI::SLAGizmoEventType : unsigned char

strong

Enumerator
LeftDown
LeftUp
RightDown
Dragging
Delete
SelectAll
ShiftUp
AltUp
ApplyChanges
DiscardChanges
AutomaticGeneration
ManualEditing
MouseWheelUp
MouseWheelDown
ResetClippingPlane
LeftDown
LeftUp
RightDown
RightUp
Dragging
Delete
SelectAll
CtrlDown
CtrlUp
ShiftDown
ShiftUp
AltUp
Escape
ApplyChanges
DiscardChanges
AutomaticGeneration
ManualEditing
MouseWheelUp
MouseWheelDown
ResetClippingPlane
Moving

                             : unsigned char {
    LeftDown = 1,
    LeftUp,
    RightDown,
    Dragging,
    Delete,
    SelectAll,
    ShiftUp,
    AltUp,
    ApplyChanges,
    DiscardChanges,
    AutomaticGeneration,
    ManualEditing,
    MouseWheelUp,
    MouseWheelDown,
    ResetClippingPlane
};

◆ SLAGizmoEventType [2/2]

enum class Slic3r::GUI::SLAGizmoEventType : unsigned char

strong

Enumerator
LeftDown
LeftUp
RightDown
Dragging
Delete
SelectAll
ShiftUp
AltUp
ApplyChanges
DiscardChanges
AutomaticGeneration
ManualEditing
MouseWheelUp
MouseWheelDown
ResetClippingPlane
LeftDown
LeftUp
RightDown
RightUp
Dragging
Delete
SelectAll
CtrlDown
CtrlUp
ShiftDown
ShiftUp
AltUp
Escape
ApplyChanges
DiscardChanges
AutomaticGeneration
ManualEditing
MouseWheelUp
MouseWheelDown
ResetClippingPlane
Moving

                             : unsigned char {
    LeftDown = 1,
    LeftUp,
    RightDown,
    RightUp,
    Dragging,
    Delete,
    SelectAll,
    CtrlDown,
    CtrlUp,
    ShiftDown,
    ShiftUp,
    AltUp,
    Escape,
    ApplyChanges,
    DiscardChanges,
    AutomaticGeneration,
    ManualEditing,
    MouseWheelUp,
    MouseWheelDown,
    ResetClippingPlane,
    Moving
};

◆ SlicedInfoIdx

enum Slic3r::GUI::SlicedInfoIdx

Enumerator
siFilament_g
siFilament_m
siFilament_mm3
siMateril_unit
siCost
siEstimatedTime
siWTNumbetOfToolchanges
siCount

{
    siFilament_g,
    siFilament_m,
    siFilament_mm3,
    siMateril_unit,
    siCost,
    siEstimatedTime,
    siWTNumbetOfToolchanges,
 
    siCount
};

◆ Technology

enum Slic3r::GUI::Technology

Enumerator
T_FFF
T_SLA
T_ANY

                {
    // Bitflag equivalent of PrinterTechnology
    T_FFF = 0x1,
    T_SLA = 0x2,
    T_ANY = ~0,
};

Function Documentation

◆ about()

void Slic3r::GUI::about ( )

{
    AboutDialog dlg;
    dlg.ShowModal();
}

Referenced by generate_help_menu().

Here is the caller graph for this function:

◆ activate_options_tab()

static void Slic3r::GUI::activate_options_tab ( std::shared_ptr< ConfigOptionsGroup > optgroup )

static

{
  optgroup->activate([](){}, wxALIGN_RIGHT);
  optgroup->update_visibility(comSimple);
  wxBoxSizer* sizer = static_cast<wxBoxSizer*>(static_cast<wxPanel*>(optgroup->parent())->GetSizer());
  sizer->Add(optgroup->sizer, 0, wxEXPAND | wxALL, 10);
 
  // apply sercher
  wxGetApp().sidebar().get_searcher().append_preferences_options(optgroup->get_lines());
}

References Slic3r::comSimple.

Referenced by Slic3r::GUI::PreferencesDialog::build().

Here is the caller graph for this function:

◆ add_common_view_menu_items()

static void Slic3r::GUI::add_common_view_menu_items	(	wxMenu *	view_menu,
		MainFrame *	mainFrame,
		std::function< bool(void)>	can_change_view
	)

static

{
    // The camera control accelerators are captured by GLCanvas3D::on_char().
    append_menu_item(view_menu, wxID_ANY, _L("Iso") + sep + "&0", _L("Iso View"), [mainFrame](wxCommandEvent&) { mainFrame->select_view("iso"); },
        "", nullptr, [can_change_view]() { return can_change_view(); }, mainFrame);
    view_menu->AppendSeparator();
    //TRN Main menu: View->Top 
    append_menu_item(view_menu, wxID_ANY, _L("Top") + sep + "&1", _L("Top View"), [mainFrame](wxCommandEvent&) { mainFrame->select_view("top"); },
        "", nullptr, [can_change_view]() { return can_change_view(); }, mainFrame);
    //TRN Main menu: View->Bottom 
    append_menu_item(view_menu, wxID_ANY, _L("Bottom") + sep + "&2", _L("Bottom View"), [mainFrame](wxCommandEvent&) { mainFrame->select_view("bottom"); },
        "", nullptr, [can_change_view]() { return can_change_view(); }, mainFrame);
    append_menu_item(view_menu, wxID_ANY, _L("Front") + sep + "&3", _L("Front View"), [mainFrame](wxCommandEvent&) { mainFrame->select_view("front"); },
        "", nullptr, [can_change_view]() { return can_change_view(); }, mainFrame);
    append_menu_item(view_menu, wxID_ANY, _L("Rear") + sep + "&4", _L("Rear View"), [mainFrame](wxCommandEvent&) { mainFrame->select_view("rear"); },
        "", nullptr, [can_change_view]() { return can_change_view(); }, mainFrame);
    append_menu_item(view_menu, wxID_ANY, _L("Left") + sep + "&5", _L("Left View"), [mainFrame](wxCommandEvent&) { mainFrame->select_view("left"); },
        "", nullptr, [can_change_view]() { return can_change_view(); }, mainFrame);
    append_menu_item(view_menu, wxID_ANY, _L("Right") + sep + "&6", _L("Right View"), [mainFrame](wxCommandEvent&) { mainFrame->select_view("right"); },
        "", nullptr, [can_change_view]() { return can_change_view(); }, mainFrame);
}

References _L, append_menu_item(), Slic3r::GUI::MainFrame::can_change_view(), Slic3r::GUI::MainFrame::select_view(), and sep.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor(), and Slic3r::GUI::MainFrame::init_menubar_as_gcodeviewer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_config_substitutions()

static void Slic3r::GUI::add_config_substitutions	(	const ConfigSubstitutions &	conf_substitutions,
		wxString &	changes
	)

static

{
  changes += "<table>";
  for (const ConfigSubstitution& conf_substitution : conf_substitutions) {
    wxString new_val;
    const ConfigOptionDef* def = conf_substitution.opt_def;
    if (!def)
      continue;
    switch (def->type) {
    case coEnum:
    {
      auto opt = def->enum_def->enum_to_index(conf_substitution.new_value->getInt());
      new_val = opt.has_value() ?
        wxString("\"") + def->enum_def->value(*opt) + "\"" + " (" +
          _(from_u8(def->enum_def->label(*opt))) + ")" :
        _L("Undefined");
      break;
    }
    case coBool:
      new_val = conf_substitution.new_value->getBool() ? "true" : "false";
      break;
    case coBools:
      if (conf_substitution.new_value->nullable())
        for (const char v : static_cast<const ConfigOptionBoolsNullable*>(conf_substitution.new_value.get())->values)
          new_val += std::string(v == ConfigOptionBoolsNullable::nil_value() ? "nil" : v ? "true" : "false") + ", ";
      else
        for (const char v : static_cast<const ConfigOptionBools*>(conf_substitution.new_value.get())->values)
          new_val += std::string(v ? "true" : "false") + ", ";
      if (! new_val.empty())
        new_val.erase(new_val.begin() + new_val.size() - 2, new_val.end());
      break;
    default:
      assert(false);
    }
 
    changes += format_wxstr("<tr><td><b>\"%1%\" (%2%)</b></td><td>: ", def->opt_key, _(def->label)) +
           format_wxstr(_L("%1% was substituted with %2%"), bold_string(conf_substitution.old_value), bold(new_val)) + 
           "</td></tr>";
  }
  changes += "</table>";
}

References _, _L, bold(), bold_string(), Slic3r::coBool, Slic3r::coBools, Slic3r::coEnum, Slic3r::ConfigOptionDef::enum_def, format_wxstr(), from_u8(), Slic3r::ConfigOptionDef::label, Slic3r::ConfigOptionBoolsTempl< NULLABLE >::nil_value(), Slic3r::ConfigOptionDef::opt_key, and Slic3r::ConfigOptionDef::type.

Referenced by show_substitutions_info(), and show_substitutions_info().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_correct_opts_to_options_list()

template<class T >

void Slic3r::GUI::add_correct_opts_to_options_list	(	const std::string &	opt_key,
		std::map< std::string, int > &	map,
		Tab *	tab,
		const int &	value
	)

{
    T *opt_cur = static_cast<T*>(tab->m_config->option(opt_key));
    for (size_t i = 0; i < opt_cur->values.size(); i++)
        map.emplace(opt_key + "#" + std::to_string(i), value);
}

References add_correct_opts_to_options_list(), Slic3r::GUI::Tab::m_config, and Slic3r::ConfigBase::option().

Referenced by add_correct_opts_to_options_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_default_image()

static void Slic3r::GUI::add_default_image	(	wxImageList *	img_list,
		bool	is_system,
		wxWindow *	parent_win
	)

static

{
    wxBitmapBundle* bmp_bndl = get_bmp_bundle("cog", IMG_PX_CNT);
#ifdef __APPLE__
    wxBitmap bmp = bmp_bndl->GetBitmap(bmp_bndl->GetDefaultSize() * mac_max_scaling_factor());
#else
    wxBitmap bmp = bmp_bndl->GetBitmapFor(parent_win);
#endif
 
    bmp = bmp.ConvertToDisabled();
    if (is_system) {
        wxImage image = bmp.ConvertToImage();
        if (image.IsOk() && image.GetWidth() != 0 && image.GetHeight() != 0) {
            add_lock(image, parent_win);
#ifdef __APPLE__
            bmp = wxBitmap(std::move(image), -1, mac_max_scaling_factor());
#else
            bmp = wxBitmap(std::move(image));
#endif
        }
    }
 
    img_list->Add(bmp);
};

References add_lock(), get_bmp_bundle(), IMG_PX_CNT, and mac_max_scaling_factor().

Here is the call graph for this function:

◆ add_lock()

static void Slic3r::GUI::add_lock	(	wxImage &	image,
		wxWindow *	parent_win
	)

static

{
    wxBitmapBundle* bmp_bndl = get_bmp_bundle("lock", 22);
#ifdef __APPLE__
    wxBitmap bmp = bmp_bndl->GetBitmap(bmp_bndl->GetDefaultSize() * mac_max_scaling_factor());
#else
    wxBitmap bmp = bmp_bndl->GetBitmapFor(parent_win);
#endif
 
    wxImage lock_image = bmp.ConvertToImage();
    if (!lock_image.IsOk() || lock_image.GetWidth() == 0 || lock_image.GetHeight() == 0)
        return;
 
    auto lock_px_data = (uint8_t*)lock_image.GetData();
    auto lock_a_data = (uint8_t*)lock_image.GetAlpha();
    int lock_width  = lock_image.GetWidth();
    int lock_height = lock_image.GetHeight();
    
    auto px_data = (uint8_t*)image.GetData();
    auto a_data = (uint8_t*)image.GetAlpha();
 
    int width = image.GetWidth();
    int height = image.GetHeight();
 
    size_t beg_x = width - lock_width;
    size_t beg_y = height - lock_height;
    for (size_t x = 0; x < (size_t)lock_width; ++x) {
        for (size_t y = 0; y < (size_t)lock_height; ++y) {
            const size_t lock_idx = (x + y * lock_width);
            if (lock_a_data && lock_a_data[lock_idx] == 0)
                continue;
 
            const size_t idx = (beg_x + x + (beg_y + y) * width);
            if (a_data)
                a_data[idx] = lock_a_data[lock_idx];
 
            const size_t idx_rgb = (beg_x + x + (beg_y + y) * width) * 3;
            const size_t lock_idx_rgb = (x + y * lock_width) * 3;
            px_data[idx_rgb] = lock_px_data[lock_idx_rgb];
            px_data[idx_rgb + 1] = lock_px_data[lock_idx_rgb + 1];
            px_data[idx_rgb + 2] = lock_px_data[lock_idx_rgb + 2];
        }
    }
}

References get_bmp_bundle(), and mac_max_scaling_factor().

Referenced by add_default_image().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_menus()

void Slic3r::GUI::add_menus	(	wxMenuBar *	menu,
		int	event_preferences_changed,
		int	event_language_change
	)

◆ add_msg_content()

static void Slic3r::GUI::add_msg_content	(	wxWindow *	parent,
		wxBoxSizer *	content_sizer,
		wxString	msg,
		bool	monospaced_font = `false`,
		bool	is_marked_msg = `false`
	)

static

{
    wxHtmlWindow* html = new wxHtmlWindow(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxHW_SCROLLBAR_AUTO);
 
    // count lines in the message
    int msg_lines = 0;
    if (!monospaced_font) {
        int line_len = 55;// count of symbols in one line
        int start_line = 0;
        for (auto i = msg.begin(); i != msg.end(); ++i) {
            if (*i == '\n') {
                int cur_line_len = i - msg.begin() - start_line;
                start_line = i - msg.begin();
                if (cur_line_len == 0 || line_len > cur_line_len)
                    msg_lines++;
                else
                    msg_lines += std::lround((double)(cur_line_len) / line_len);
            }
        }
        msg_lines++;
    }
 
    wxFont      font = wxGetApp().normal_font();//wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
    wxFont      monospace = wxGetApp().code_font();
    wxColour    text_clr = wxGetApp().get_label_clr_default();
    wxColour    bgr_clr = parent->GetBackgroundColour();
 
#ifdef __APPLE__
    // On macOS 10.13 and older the background color returned by wxWidgets
    // is wrong, which leads to https://github.com/prusa3d/PrusaSlicer/issues/7603
    // and https://github.com/prusa3d/PrusaSlicer/issues/3775. wxSYS_COLOUR_WINDOW
    // may not match the window background exactly, but it seems to never end up
    // as black on black.
    
    if (wxPlatformInfo::Get().GetOSMajorVersion() == 10
     && wxPlatformInfo::Get().GetOSMinorVersion() < 14)
        bgr_clr = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
#endif
 
    auto        text_clr_str = encode_color(ColorRGB(text_clr.Red(), text_clr.Green(), text_clr.Blue()));
    auto        bgr_clr_str = encode_color(ColorRGB(bgr_clr.Red(), bgr_clr.Green(), bgr_clr.Blue()));
    const int   font_size = font.GetPointSize();
    int         size[] = { font_size, font_size, font_size, font_size, font_size, font_size, font_size };
    html->SetFonts(font.GetFaceName(), monospace.GetFaceName(), size);
    html->SetBorders(2);
 
    // calculate html page size from text
    wxSize page_size;
    int em = wxGetApp().em_unit();
    if (!wxGetApp().mainframe) {
        // If mainframe is nullptr, it means that GUI_App::on_init_inner() isn't completed 
        // (We just show information dialog about configuration version now)
        // And as a result the em_unit value wasn't created yet
        // So, calculate it from the scale factor of Dialog
#if defined(__WXGTK__)
        // Linux specific issue : get_dpi_for_window(this) still doesn't responce to the Display's scale in new wxWidgets(3.1.3).
        // So, initialize default width_unit according to the width of the one symbol ("m") of the currently active font of this window.
        em = std::max<size_t>(10, parent->GetTextExtent("m").x - 1);
#else
        double scale_factor = (double)get_dpi_for_window(parent) / (double)DPI_DEFAULT;
        em = std::max<size_t>(10, 10.0f * scale_factor);
#endif // __WXGTK__
    }
 
    // if message containes the table
    if (msg.Contains("<tr>")) {
        int lines = msg.Freq('\n') + 1;
        int pos = 0;
        while (pos < (int)msg.Len() && pos != wxNOT_FOUND) {
            pos = msg.find("<tr>", pos + 1);
            lines += 2;
        }
        int page_height = std::min(int(font.GetPixelSize().y+2) * lines, 68 * em);
        page_size = wxSize(68 * em, page_height);
    }
    else {
        wxClientDC dc(parent);
        wxSize msg_sz = dc.GetMultiLineTextExtent(msg);
        page_size = wxSize(std::min(msg_sz.GetX() + 2 * em, 68 * em),
                           std::min(msg_sz.GetY() + 2 * em, 68 * em));
    }
    html->SetMinSize(page_size);
 
    std::string msg_escaped = xml_escape(into_u8(msg), is_marked_msg);
    boost::replace_all(msg_escaped, "\r\n", "<br>");
    boost::replace_all(msg_escaped, "\n", "<br>");
    if (monospaced_font)
        // Code formatting will be preserved. This is useful for reporting errors from the placeholder parser.
        msg_escaped = std::string("<pre><code>") + msg_escaped + "</code></pre>";
    html->SetPage(format_wxstr("<html>"
                                    "<body bgcolor=%1% link=%2%>"
                                        "<font color=%2%>"
                                            "%3%"
                                        "</font>"
                                    "</body>"
                               "</html>", 
                    bgr_clr_str, text_clr_str, from_u8(msg_escaped)));
 
    html->Bind(wxEVT_HTML_LINK_CLICKED, [parent](wxHtmlLinkEvent& event) {
        wxGetApp().open_browser_with_warning_dialog(event.GetLinkInfo().GetHref(), parent, false);
        event.Skip(false);
    });
 
    content_sizer->Add(html, 1, wxEXPAND);
    wxGetApp().UpdateDarkUI(html);
}

References DPI_DEFAULT, Slic3r::encode_color(), format_wxstr(), from_u8(), get_dpi_for_window(), into_u8(), wxEVT_HTML_LINK_CLICKED, and Slic3r::xml_escape().

Referenced by Slic3r::GUI::ErrorDialog::ErrorDialog(), Slic3r::GUI::InfoDialog::InfoDialog(), and Slic3r::GUI::WarningDialog::WarningDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_options_into_line()

static void Slic3r::GUI::add_options_into_line	(	ConfigOptionsGroupShp &	optgroup,
		const std::vector< SamePair< std::string > > &	prefixes,
		const std::string &	optkey
	)

static

{
    auto opt = optgroup->get_option(prefixes.front().first + optkey);
    Line line{ opt.opt.label, "" };
    line.full_width = 1;
    for (auto &prefix : prefixes) {
        opt = optgroup->get_option(prefix.first + optkey);
        opt.opt.label = prefix.second;
        opt.opt.width = 12; // TODO
        line.append_option(opt);
    }
    optgroup->append_line(line);
}

References Slic3r::GUI::Line::label.

Referenced by Slic3r::GUI::TabSLAPrint::build_sla_support_params().

Here is the caller graph for this function:

◆ add_row_to_table()

static void Slic3r::GUI::add_row_to_table	(	std::function< void(void)>	col_1 = `nullptr`,
		std::function< void(void)>	col_2 = `nullptr`
	)

static

{
    assert(col_1 != nullptr && col_2 != nullptr);
    ImGui::TableNextRow();
    ImGui::TableSetColumnIndex(0);
    col_1();
    ImGui::TableSetColumnIndex(1);
    col_2();
}

References ImGui::TableNextRow(), and ImGui::TableSetColumnIndex().

Referenced by add_strings_row_to_table(), and Slic3r::GUI::GLGizmoMeasure::on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_strings_row_to_table()

static void Slic3r::GUI::add_strings_row_to_table	(	ImGuiWrapper &	imgui,
		const std::string &	col_1,
		const ImVec4 &	col_1_color,
		const std::string &	col_2,
		const ImVec4 &	col_2_color
	)

static

{
    add_row_to_table([&]() { imgui.text_colored(col_1_color, col_1); }, [&]() { imgui.text_colored(col_2_color, col_2); });
};

References add_row_to_table(), and Slic3r::GUI::ImGuiWrapper::text_colored().

Referenced by Slic3r::GUI::GLCanvas3D::_picking_pass(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), and Slic3r::GUI::GCodeViewer::render_legend().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ all_vertices_inside()

template<typename Fn >

bool Slic3r::GUI::all_vertices_inside	(	const GLModel::Geometry &	geometry,
		Fn	fn
	)

inline

{
    const size_t position_stride_floats = geometry.position_stride_floats(geometry.format);
    const size_t position_offset_floats = geometry.position_offset_floats(geometry.format);
    assert(position_stride_floats == 3);
    if (geometry.vertices.empty() || position_stride_floats != 3)
        return false;
 
    for (auto it = geometry.vertices.begin(); it != geometry.vertices.end(); ) {
        it += position_offset_floats;
        if (!fn({ *it, *(it + 1), *(it + 2) }))
            return false;
        it += (geometry.vertex_stride_floats(geometry.format) - position_offset_floats - position_stride_floats);
    }
    return true;
}

References Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::GLModel::Geometry::position_offset_floats(), Slic3r::GUI::GLModel::Geometry::position_stride_floats(), Slic3r::GUI::GLModel::Geometry::vertex_stride_floats(), and Slic3r::GUI::GLModel::Geometry::vertices.

Referenced by contains().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ append_bool_option()

static void Slic3r::GUI::append_bool_option	(	std::shared_ptr< ConfigOptionsGroup >	optgroup,
		const std::string &	opt_key,
		const std::string &	label,
		const std::string &	tooltip,
		bool	def_val,
		ConfigOptionMode	mode = `comSimple`
	)

static

{
  ConfigOptionDef def = {opt_key, coBool};
  def.label = label;
  def.tooltip = tooltip;
  def.mode = mode;
  def.set_default_value(new ConfigOptionBool{ def_val });
  Option option(def, opt_key);
  optgroup->append_single_option_line(option);
 
  // fill data to the Search Dialog
  wxGetApp().sidebar().get_searcher().add_key(opt_key, Preset::TYPE_PREFERENCES, optgroup->config_category(), L("Preferences"));
}

References Slic3r::coBool, L, Slic3r::ConfigOptionDef::label, Slic3r::ConfigOptionDef::mode, Slic3r::ConfigOptionDef::set_default_value(), Slic3r::ConfigOptionDef::tooltip, and Slic3r::Preset::TYPE_PREFERENCES.

Referenced by Slic3r::GUI::PreferencesDialog::build().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ append_enum_option()

template<typename EnumType >

static void Slic3r::GUI::append_enum_option	(	std::shared_ptr< ConfigOptionsGroup >	optgroup,
		const std::string &	opt_key,
		const std::string &	label,
		const std::string &	tooltip,
		const ConfigOption *	def_val,
		std::initializer_list< std::pair< std::string_view, std::string_view > >	enum_values,
		ConfigOptionMode	mode = `comSimple`
	)

static

{
  ConfigOptionDef def = {opt_key, coEnum };
  def.label = label;
  def.tooltip = tooltip;
  def.mode = mode;
  def.set_enum<EnumType>(enum_values);
 
  def.set_default_value(def_val);
  Option option(def, opt_key);
  optgroup->append_single_option_line(option);
 
  // fill data to the Search Dialog
  wxGetApp().sidebar().get_searcher().add_key(opt_key, Preset::TYPE_PREFERENCES, optgroup->config_category(), L("Preferences"));
}

References Slic3r::coEnum, L, Slic3r::ConfigOptionDef::label, Slic3r::ConfigOptionDef::mode, Slic3r::ConfigOptionDef::set_default_value(), Slic3r::ConfigOptionDef::set_enum(), Slic3r::ConfigOptionDef::tooltip, and Slic3r::Preset::TYPE_PREFERENCES.

Here is the call graph for this function:

◆ append_preferences_option_to_searcher()

static void Slic3r::GUI::append_preferences_option_to_searcher	(	std::shared_ptr< ConfigOptionsGroup >	optgroup,
		const std::string &	opt_key,
		const wxString &	label
	)

static

{
  // fill data to the Search Dialog
  wxGetApp().sidebar().get_searcher().add_key(opt_key, Preset::TYPE_PREFERENCES, optgroup->config_category(), L("Preferences"));
  // apply sercher
  wxGetApp().sidebar().get_searcher().append_preferences_option(Line(opt_key, label, ""));
}

References L, and Slic3r::Preset::TYPE_PREFERENCES.

Referenced by Slic3r::GUI::PreferencesDialog::create_downloader_path_sizer(), Slic3r::GUI::PreferencesDialog::create_settings_font_widget(), Slic3r::GUI::PreferencesDialog::create_settings_mode_color_widget(), Slic3r::GUI::PreferencesDialog::create_settings_mode_widget(), and Slic3r::GUI::PreferencesDialog::create_settings_text_color_widget().

Here is the caller graph for this function:

◆ append_root_node()

static bool Slic3r::GUI::append_root_node	(	ObjectDataViewModelNode *	parent_node,
		ObjectDataViewModelNode **	root_node,
		const ItemType	root_type
	)

static

{
    const int inst_root_id = get_root_idx(parent_node, root_type);
 
    *root_node = inst_root_id < 0 ?
                new ObjectDataViewModelNode(parent_node, root_type) :
                parent_node->GetNthChild(inst_root_id);
    
    if (inst_root_id < 0) {
        if ((root_type&itInstanceRoot) ||
            ( (root_type&itLayerRoot) && get_root_idx(parent_node, itInstanceRoot)<0) )
            parent_node->Append(*root_node);
        else if (root_type&itLayerRoot)
            parent_node->Insert(*root_node, static_cast<unsigned int>(get_root_idx(parent_node, itInstanceRoot)));
        return true;
    }
 
    return false;
}

References Slic3r::GUI::ObjectDataViewModelNode::Append(), get_root_idx(), Slic3r::GUI::ObjectDataViewModelNode::GetNthChild(), Slic3r::GUI::ObjectDataViewModelNode::Insert(), itInstanceRoot, and itLayerRoot.

Referenced by Slic3r::GUI::ObjectDataViewModel::AddRoot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assign_logical_beds()

void Slic3r::GUI::assign_logical_beds	(	std::vector< arrangement::ArrangePolygon > &	items,
		const arrangement::ArrangeBed &	bed,
		double	stride
	)

{
    // The strides have to be removed from the fixed items. For the
    // arrangeable (selected) items bed_idx is ignored and the
    // translation is irrelevant.
    coord_t bedx = bounding_box(bed).min.x();
    for (auto &itm : items) {
        auto bedidx = std::max(arrangement::UNARRANGED,
                               static_cast<int>(std::floor(
                                   (get_extents(itm.transformed_poly()).min.x() - bedx) /
                                   stride)));
 
        itm.bed_idx = bedidx;
 
        if (bedidx >= 0)
            itm.translation.x() -= bedidx * stride;
    }
}

References Slic3r::bounding_box(), Slic3r::get_extents(), Slic3r::BoundingBoxBase< PointType, APointsType >::min, and Slic3r::arrangement::UNARRANGED.

Referenced by Slic3r::GUI::ArrangeJob::prepare(), and Slic3r::GUI::FillBedJob::prepare().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bed_stride()

double Slic3r::GUI::bed_stride ( const Plater * plater )

                                        {
    double bedwidth = plater->build_volume().bounding_volume().size().x();
    return scaled<double>((1. + LOGICAL_BED_GAP) * bedwidth);
}

References Slic3r::BuildVolume::bounding_volume(), Slic3r::GUI::Plater::build_volume(), LOGICAL_BED_GAP, plater(), and Slic3r::BoundingBox3Base< PointType >::size().

Referenced by get_arrange_poly(), Slic3r::GUI::ArrangeJob::prepare(), and Slic3r::GUI::FillBedJob::prepare().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bold()

static wxString Slic3r::GUI::bold ( const wxString & str )

static

{
  return wxString::Format("<b>%s</b>", str);
};

Referenced by add_config_substitutions().

Here is the caller graph for this function:

◆ bold_string()

static wxString Slic3r::GUI::bold_string ( const wxString & str )

static

{ 
  return wxString::Format("<b>\"%s\"</b>", str); 
};

Referenced by add_config_substitutions(), and show_substitutions_info().

Here is the caller graph for this function:

◆ break_to_debugger()

void Slic3r::GUI::break_to_debugger ( )

{
    #ifdef _WIN32
    if (IsDebuggerPresent())
        DebugBreak();
    #endif /* _WIN32 */
}

◆ brim_offset()

static coord_t Slic3r::GUI::brim_offset	(	const PrintObject &	po,
		const ModelInstance &	inst
	)

static

{
    const BrimType brim_type         = po.config().brim_type.value;
    const float    brim_separation   = po.config().brim_separation.getFloat();
    const float    brim_width        = po.config().brim_width.getFloat();
    const bool     has_outer_brim    = brim_type == BrimType::btOuterOnly ||
                                       brim_type == BrimType::btOuterAndInner;
 
    // How wide is the brim? (in scaled units)
    return  has_outer_brim ? scaled(brim_width + brim_separation) : 0;
}

References Slic3r::btOuterAndInner, Slic3r::btOuterOnly, Slic3r::PrintObject::config(), and Slic3r::scaled().

Referenced by get_arrange_poly().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buffer_id()

static unsigned char Slic3r::GUI::buffer_id ( EMoveType type )

static

                                               {
    return static_cast<unsigned char>(type) - static_cast<unsigned char>(EMoveType::Retract);
}

References Slic3r::Retract.

Referenced by Slic3r::GUI::GCodeViewer::can_export_toolpaths(), Slic3r::GUI::GCodeViewer::export_toolpaths_to_obj(), Slic3r::GUI::GCodeViewer::is_toolpath_move_type_visible(), Slic3r::GUI::GCodeViewer::load_toolpaths(), Slic3r::GUI::GCodeViewer::refresh(), Slic3r::GUI::GCodeViewer::refresh_render_paths(), Slic3r::GUI::GCodeViewer::render_legend(), Slic3r::GUI::GCodeViewer::render_toolpaths(), and Slic3r::GUI::GCodeViewer::set_toolpath_move_type_visible().

Here is the caller graph for this function:

◆ buffer_type()

static EMoveType Slic3r::GUI::buffer_type ( unsigned char id )

static

                                               {
    return static_cast<EMoveType>(static_cast<unsigned char>(EMoveType::Retract) + id);
}

References Slic3r::Retract.

Referenced by Slic3r::GUI::GCodeViewer::init().

Here is the caller graph for this function:

◆ button()

bool Slic3r::GUI::button	(	const IconManager::Icon &	activ,
		const IconManager::Icon &	hover,
		const IconManager::Icon &	disable,
		bool	disabled = `false`
	)

Use icon as button with 3 states activ hover and disabled.

Parameters

activ	Not disabled not hovered image
hover	Hovered image
disable	Disabled image

Returns: True when click on enabled, otherwise False

{
    if (disabled) {
        draw(disable);
        return false;
    }
    return clickable(activ, hover);
}

References clickable(), and draw().

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_advanced(), priv::draw_button(), Slic3r::GUI::ObjectLayers::sys_color_changed(), and Slic3r::GUI::ObjectManipulation::update_mirror_buttons_visibility().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calc_scale()

static std::optional< double > Slic3r::GUI::calc_scale	(	const Matrix3d &	from,
		const Matrix3d &	to,
		const Vec3d &	dir
	)

static

{
    Vec3d  from_dir      = from * dir;
    Vec3d  to_dir        = to * dir;
    double from_scale_sq = from_dir.squaredNorm();
    double to_scale_sq   = to_dir.squaredNorm();
    if (is_approx(from_scale_sq, to_scale_sq, 1e-3))
        return {}; // no scale
    return sqrt(from_scale_sq / to_scale_sq);
}

References Slic3r::is_approx(), and sqrt().

Referenced by on_mouse_surface_drag().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calc_surface_offset()

std::optional< Vec3d > Slic3r::GUI::calc_surface_offset	(	const Selection &	selection,
		RaycastManager &	raycast_manager
	)

Calculate translation of volume onto surface of model.

Parameters

selection	Must contain only one selected volume, Transformation of current instance
raycast_manager	AABB trees of object. Actualize object

Returns: Offset of volume in volume coordinate

                                                                                                    {
    const GLVolume *gl_volume_ptr = get_selected_gl_volume(selection);
    if (gl_volume_ptr == nullptr)
        return {};
    const GLVolume& gl_volume = *gl_volume_ptr;
 
    const ModelObjectPtrs &objects = selection.get_model()->objects;
    const ModelVolume* volume = get_model_volume(gl_volume, objects);
    if (volume == nullptr)
        return {};
 
    const ModelInstance* instance = get_model_instance(gl_volume, objects);
    if (instance == nullptr)
        return {};
 
    // Move object on surface
    auto cond = RaycastManager::SkipVolume(volume->id().id);
    raycast_manager.actualize(*instance, &cond);
 
    Transform3d to_world = world_matrix_fixed(gl_volume, selection.get_model()->objects);
    Vec3d point     = to_world * Vec3d::Zero();
    Vec3d direction = to_world.linear() * (-Vec3d::UnitZ());
 
    // ray in direction of text projection(from volume zero to z-dir)
    std::optional<RaycastManager::Hit> hit_opt = raycast_manager.closest_hit(point, direction, &cond);
 
    // Try to find closest point when no hit object in emboss direction
    if (!hit_opt.has_value()) {
        std::optional<RaycastManager::ClosePoint> close_point_opt = raycast_manager.closest(point);
 
        // It should NOT appear. Closest point always exists.
        assert(close_point_opt.has_value());
        if (!close_point_opt.has_value())
            return {};
 
        // It is no neccesary to move with origin by very small value
        if (close_point_opt->squared_distance < EPSILON)
            return {};
 
        const RaycastManager::ClosePoint &close_point = *close_point_opt;
        Transform3d hit_tr = raycast_manager.get_transformation(close_point.tr_key);
        Vec3d    hit_world = hit_tr * close_point.point;
        Vec3d offset_world = hit_world - point; // vector in world
        Vec3d offset_volume = to_world.inverse().linear() * offset_world;
        return offset_volume;
    }
 
    // It is no neccesary to move with origin by very small value
    const RaycastManager::Hit &hit = *hit_opt;
    if (hit.squared_distance < EPSILON)
        return {};
    Transform3d hit_tr = raycast_manager.get_transformation(hit.tr_key);
    Vec3d hit_world    = hit_tr * hit.position;
    Vec3d offset_world = hit_world - point; // vector in world
    // TIP: It should be close to only z move
    Vec3d offset_volume = to_world.inverse().linear() * offset_world;
    return offset_volume;
}

Referenced by Slic3r::GUI::GLGizmoEmboss::process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ call_after_if_active()

static void Slic3r::GUI::call_after_if_active	(	std::function< void()>	fn,
		GUI_App *	app = `&wxGetApp()`
	)

static

{
    // check application GUI
    if (app == nullptr) return;
    app->CallAfter([fn, app]() {
        // app must exist because it call this
        // if (app == nullptr) return;
        const Plater *plater = app->plater();
        if (plater == nullptr) return;
        const GLCanvas3D *canvas = plater->canvas3D();
        if (canvas == nullptr) return;
        const GLGizmosManager &mng = canvas->get_gizmos_manager();
        // check if simplify is still activ gizmo
        if (mng.get_current_type() != GLGizmosManager::Simplify) return;
        fn();
    });
}

References Slic3r::GUI::Plater::canvas3D(), Slic3r::GUI::GLGizmosManager::get_current_type(), Slic3r::GUI::GLCanvas3D::get_gizmos_manager(), plater(), and Slic3r::GUI::GLGizmosManager::Simplify.

Referenced by Slic3r::GUI::GLGizmoSimplify::process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ can_add_volumes_to_object()

static bool Slic3r::GUI::can_add_volumes_to_object ( const ModelObject * object )

static

{
    bool can = object->volumes.size() > 1;
 
    if (can && object->is_cut()) {
        int no_connectors_cnt = 0;
        for (const ModelVolume* v : object->volumes)
            if (!v->is_cut_connector()) {
                if (!v->is_model_part())
                    return true;
                no_connectors_cnt++;
            }
        can = no_connectors_cnt > 1;
    }
 
    return can;
}

References Slic3r::ModelObject::is_cut().

Referenced by Slic3r::GUI::ObjectList::add_volumes_to_object_in_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ center_on_feature_type_as_string()

static std::string Slic3r::GUI::center_on_feature_type_as_string ( Measure::SurfaceFeatureType type )

static

{
    std::string ret;
    switch (type) {
    case Measure::SurfaceFeatureType::Edge:   { ret = _u8L("Center of edge"); break; }
    case Measure::SurfaceFeatureType::Circle: { ret = _u8L("Center of circle"); break; }
    default: { assert(false); break; }
    }
    return ret;
}

References _u8L, Slic3r::Measure::Circle, and Slic3r::Measure::Edge.

Referenced by Slic3r::GUI::GLGizmoMeasure::on_render_input_window().

Here is the caller graph for this function:

◆ change_opt_value()

void Slic3r::GUI::change_opt_value	(	DynamicPrintConfig &	config,
		const t_config_option_key &	opt_key,
		const boost::any &	value,
		int	opt_index
	)

{
  try{
 
        if (config.def()->get(opt_key)->type == coBools && config.def()->get(opt_key)->nullable) {
            ConfigOptionBoolsNullable* vec_new = new ConfigOptionBoolsNullable{ boost::any_cast<unsigned char>(value) };
            config.option<ConfigOptionBoolsNullable>(opt_key)->set_at(vec_new, opt_index, 0);
            return;
        }
 
        const ConfigOptionDef *opt_def = config.def()->get(opt_key);
    switch (opt_def->type) {
    case coFloatOrPercent:{
      std::string str = boost::any_cast<std::string>(value);
      bool percent = false;
      if (str.back() == '%') {
        str.pop_back();
        percent = true;
      }
            double val = std::stod(str); // locale-dependent (on purpose - the input is the actual content of the field)
      config.set_key_value(opt_key, new ConfigOptionFloatOrPercent(val, percent));
      break;}
    case coPercent:
      config.set_key_value(opt_key, new ConfigOptionPercent(boost::any_cast<double>(value)));
      break;
    case coFloat:{
      double& val = config.opt_float(opt_key);
      val = boost::any_cast<double>(value);
      break;
    }
    case coFloatsOrPercents:{
      std::string str = boost::any_cast<std::string>(value);
      bool percent = false;
      if (str.back() == '%') {
        str.pop_back();
        percent = true;
      }
            double val = std::stod(str); // locale-dependent (on purpose - the input is the actual content of the field)
      ConfigOptionFloatsOrPercents* vec_new = new ConfigOptionFloatsOrPercents({ {val, percent} });
      config.option<ConfigOptionFloatsOrPercents>(opt_key)->set_at(vec_new, opt_index, opt_index);
      break;
    }
    case coPercents:{
      ConfigOptionPercents* vec_new = new ConfigOptionPercents{ boost::any_cast<double>(value) };
      config.option<ConfigOptionPercents>(opt_key)->set_at(vec_new, opt_index, opt_index);
      break;
    }
    case coFloats:{
      ConfigOptionFloats* vec_new = new ConfigOptionFloats{ boost::any_cast<double>(value) };
      config.option<ConfigOptionFloats>(opt_key)->set_at(vec_new, opt_index, opt_index);
      break;
    }
    case coString:
      config.set_key_value(opt_key, new ConfigOptionString(boost::any_cast<std::string>(value)));
      break;
    case coStrings:{
      if (opt_key == "compatible_prints" || opt_key == "compatible_printers" || opt_key == "gcode_substitutions") {
        config.option<ConfigOptionStrings>(opt_key)->values =
          boost::any_cast<std::vector<std::string>>(value);
      }
      else if (config.def()->get(opt_key)->gui_flags.compare("serialized") == 0) {
        std::string str = boost::any_cast<std::string>(value);
                std::vector<std::string> values {};
                if (!str.empty()) {
            if (str.back() == ';') str.pop_back();
            // Split a string to multiple strings by a semi - colon.This is the old way of storing multi - string values.
            // Currently used for the post_process config value only.
            boost::split(values, str, boost::is_any_of(";"));
            if (values.size() == 1 && values[0] == "")
              values.resize(0);
                }
        config.option<ConfigOptionStrings>(opt_key)->values = values;
      }
      else{
        ConfigOptionStrings* vec_new = new ConfigOptionStrings{ boost::any_cast<std::string>(value) };
        config.option<ConfigOptionStrings>(opt_key)->set_at(vec_new, opt_index, 0);
      }
      }
      break;
    case coBool:
      config.set_key_value(opt_key, new ConfigOptionBool(boost::any_cast<bool>(value)));
      break;
    case coBools:{
      ConfigOptionBools* vec_new = new ConfigOptionBools{ boost::any_cast<unsigned char>(value) != 0 };
      config.option<ConfigOptionBools>(opt_key)->set_at(vec_new, opt_index, 0);
      break;}
    case coInt:
      config.set_key_value(opt_key, new ConfigOptionInt(boost::any_cast<int>(value)));
      break;
    case coInts:{
      ConfigOptionInts* vec_new = new ConfigOptionInts{ boost::any_cast<int>(value) };
      config.option<ConfigOptionInts>(opt_key)->set_at(vec_new, opt_index, 0);
      }
      break;
    case coEnum:{
      auto *opt = opt_def->default_value.get()->clone();
      opt->setInt(boost::any_cast<int>(value));
      config.set_key_value(opt_key, opt);
      }
      break;
    case coPoints:{
      if (opt_key == "bed_shape" || opt_key == "thumbnails") {
        config.option<ConfigOptionPoints>(opt_key)->values = boost::any_cast<std::vector<Vec2d>>(value);
        break;
      }
      ConfigOptionPoints* vec_new = new ConfigOptionPoints{ boost::any_cast<Vec2d>(value) };
      config.option<ConfigOptionPoints>(opt_key)->set_at(vec_new, opt_index, 0);
      }
      break;
    case coNone:
      break;
    default:
      break;
    }
  }
  catch (const std::exception &e)
  {
    wxLogError(format_wxstr("Internal error when changing value for %1%: %2%", opt_key, e.what()));
  }
}

References Slic3r::coBool, Slic3r::coBools, Slic3r::coEnum, Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coFloats, Slic3r::coFloatsOrPercents, Slic3r::coInt, Slic3r::coInts, Slic3r::coNone, Slic3r::coPercent, Slic3r::coPercents, Slic3r::coPoints, Slic3r::coString, Slic3r::coStrings, Slic3r::DynamicPrintConfig::def(), Slic3r::ConfigOptionDef::default_value, format_wxstr(), Slic3r::ConfigDef::get(), Slic3r::ConfigOptionDef::gui_flags, Slic3r::ConfigOptionDef::nullable, Slic3r::ConfigBase::opt_float(), Slic3r::ConfigBase::option(), Slic3r::DynamicConfig::set_key_value(), and Slic3r::ConfigOptionDef::type.

Referenced by Slic3r::GUI::ConfigOptionsGroup::change_opt_value(), and Slic3r::GUI::Tab::load_key_value().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_dark_mode()

bool Slic3r::GUI::check_dark_mode ( )

                       {
#if wxCHECK_VERSION(3,1,3)
    return wxSystemSettings::GetAppearance().IsDark();
#else
    const unsigned luma = wxGetApp().get_colour_approx_luma(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
    return luma < 128;
#endif
}

Referenced by Slic3r::GUI::GUI_App::dark_mode().

Here is the caller graph for this function:

◆ circular_arrow()

GLModel::Geometry Slic3r::GUI::circular_arrow	(	unsigned int	resolution,
		float	radius,
		float	tip_height,
		float	tip_width,
		float	stem_width,
		float	thickness
	)

{
    resolution = std::max<unsigned int>(2, resolution);
 
    GLModel::Geometry data;
    data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3N3 };
    data.reserve_vertices(8 * (resolution + 1) + 30);
    data.reserve_indices((8 * resolution + 16) * 3);
 
    const float half_thickness = 0.5f * thickness;
    const float half_stem_width = 0.5f * stem_width;
    const float half_tip_width = 0.5f * tip_width;
 
    const float outer_radius = radius + half_stem_width;
    const float inner_radius = radius - half_stem_width;
    const float step_angle = 0.5f * float(PI) / float(resolution);
 
    // tip
    // top face vertices
    data.add_vertex(Vec3f(0.0f, outer_radius, half_thickness), (Vec3f)Vec3f::UnitZ());
    data.add_vertex(Vec3f(0.0f, radius + half_tip_width, half_thickness), (Vec3f)Vec3f::UnitZ());
    data.add_vertex(Vec3f(-tip_height, radius, half_thickness), (Vec3f)Vec3f::UnitZ());
    data.add_vertex(Vec3f(0.0f, radius - half_tip_width, half_thickness), (Vec3f)Vec3f::UnitZ());
    data.add_vertex(Vec3f(0.0f, inner_radius, half_thickness), (Vec3f)Vec3f::UnitZ());
 
    // top face triangles
    data.add_triangle(0, 1, 2);
    data.add_triangle(0, 2, 4);
    data.add_triangle(4, 2, 3);
 
    // bottom face vertices
    data.add_vertex(Vec3f(0.0f, outer_radius, -half_thickness), (Vec3f)(-Vec3f::UnitZ()));
    data.add_vertex(Vec3f(0.0f, radius + half_tip_width, -half_thickness), (Vec3f)(-Vec3f::UnitZ()));
    data.add_vertex(Vec3f(-tip_height, radius, -half_thickness), (Vec3f)(-Vec3f::UnitZ()));
    data.add_vertex(Vec3f(0.0f, radius - half_tip_width, -half_thickness), (Vec3f)(-Vec3f::UnitZ()));
    data.add_vertex(Vec3f(0.0f, inner_radius, -half_thickness), (Vec3f)(-Vec3f::UnitZ()));
 
    // bottom face triangles
    data.add_triangle(5, 7, 6);
    data.add_triangle(5, 9, 7);
    data.add_triangle(9, 8, 7);
 
    // side faces vertices
    data.add_vertex(Vec3f(0.0f, outer_radius, -half_thickness), (Vec3f)Vec3f::UnitX());
    data.add_vertex(Vec3f(0.0f, radius + half_tip_width, -half_thickness), (Vec3f)Vec3f::UnitX());
    data.add_vertex(Vec3f(0.0f, outer_radius, half_thickness), (Vec3f)Vec3f::UnitX());
    data.add_vertex(Vec3f(0.0f, radius + half_tip_width, half_thickness), (Vec3f)Vec3f::UnitX());
 
    Vec3f normal(-half_tip_width, tip_height, 0.0f);
    normal.normalize();
    data.add_vertex(Vec3f(0.0f, radius + half_tip_width, -half_thickness), normal);
    data.add_vertex(Vec3f(-tip_height, radius, -half_thickness), normal);
    data.add_vertex(Vec3f(0.0f, radius + half_tip_width, half_thickness), normal);
    data.add_vertex(Vec3f(-tip_height, radius, half_thickness), normal);
 
    normal = { -half_tip_width, -tip_height, 0.0f };
    normal.normalize();
    data.add_vertex(Vec3f(-tip_height, radius, -half_thickness), normal);
    data.add_vertex(Vec3f(0.0f, radius - half_tip_width, -half_thickness), normal);
    data.add_vertex(Vec3f(-tip_height, radius, half_thickness), normal);
    data.add_vertex(Vec3f(0.0f, radius - half_tip_width, half_thickness), normal);
 
    data.add_vertex(Vec3f(0.0f, radius - half_tip_width, -half_thickness), (Vec3f)Vec3f::UnitX());
    data.add_vertex(Vec3f(0.0f, inner_radius, -half_thickness), (Vec3f)Vec3f::UnitX());
    data.add_vertex(Vec3f(0.0f, radius - half_tip_width, half_thickness), (Vec3f)Vec3f::UnitX());
    data.add_vertex(Vec3f(0.0f, inner_radius, half_thickness), (Vec3f)Vec3f::UnitX());
 
    // side face triangles
    for (unsigned int i = 0; i < 4; ++i) {
        const unsigned int ii = i * 4;
        data.add_triangle(10 + ii, 11 + ii, 13 + ii);
        data.add_triangle(10 + ii, 13 + ii, 12 + ii);
    }
 
    // stem
    // top face vertices
    for (unsigned int i = 0; i <= resolution; ++i) {
        const float angle = float(i) * step_angle;
        data.add_vertex(Vec3f(inner_radius * ::sin(angle), inner_radius * ::cos(angle), half_thickness), (Vec3f)Vec3f::UnitZ());
    }
 
    for (unsigned int i = 0; i <= resolution; ++i) {
        const float angle = float(i) * step_angle;
        data.add_vertex(Vec3f(outer_radius * ::sin(angle), outer_radius * ::cos(angle), half_thickness), (Vec3f)Vec3f::UnitZ());
    }
 
    // top face triangles
    for (unsigned int i = 0; i < resolution; ++i) {
        data.add_triangle(26 + i, 27 + i, 27 + resolution + i);
        data.add_triangle(27 + i, 28 + resolution + i, 27 + resolution + i);
    }
 
    // bottom face vertices
    for (unsigned int i = 0; i <= resolution; ++i) {
        const float angle = float(i) * step_angle;
        data.add_vertex(Vec3f(inner_radius * ::sin(angle), inner_radius * ::cos(angle), -half_thickness), (Vec3f)(-Vec3f::UnitZ()));
    }
 
    for (unsigned int i = 0; i <= resolution; ++i) {
        const float angle = float(i) * step_angle;
        data.add_vertex(Vec3f(outer_radius * ::sin(angle), outer_radius * ::cos(angle), -half_thickness), (Vec3f)(-Vec3f::UnitZ()));
    }
 
    // bottom face triangles
    for (unsigned int i = 0; i < resolution; ++i) {
        data.add_triangle(28 + 2 * resolution + i, 29 + 3 * resolution + i, 29 + 2 * resolution + i);
        data.add_triangle(29 + 2 * resolution + i, 29 + 3 * resolution + i, 30 + 3 * resolution + i);
    }
 
    // side faces vertices and triangles
    for (unsigned int i = 0; i <= resolution; ++i) {
        const float angle = float(i) * step_angle;
        const float c = ::cos(angle);
        const float s = ::sin(angle);
        data.add_vertex(Vec3f(inner_radius * s, inner_radius * c, -half_thickness), Vec3f(-s, -c, 0.0f));
    }
 
    for (unsigned int i = 0; i <= resolution; ++i) {
        const float angle = float(i) * step_angle;
        const float c = ::cos(angle);
        const float s = ::sin(angle);
        data.add_vertex(Vec3f(inner_radius * s, inner_radius * c, half_thickness), Vec3f(-s, -c, 0.0f));
    }
 
    unsigned int first_id = 26 + 4 * (resolution + 1);
    for (unsigned int i = 0; i < resolution; ++i) {
        const unsigned int ii = first_id + i;
        data.add_triangle(ii, ii + 1, ii + resolution + 2);
        data.add_triangle(ii, ii + resolution + 2, ii + resolution + 1);
    }
 
    data.add_vertex(Vec3f(inner_radius, 0.0f, -half_thickness), (Vec3f)(-Vec3f::UnitY()));
    data.add_vertex(Vec3f(outer_radius, 0.0f, -half_thickness), (Vec3f)(-Vec3f::UnitY()));
    data.add_vertex(Vec3f(inner_radius, 0.0f, half_thickness), (Vec3f)(-Vec3f::UnitY()));
    data.add_vertex(Vec3f(outer_radius, 0.0f, half_thickness), (Vec3f)(-Vec3f::UnitY()));
 
    first_id = 26 + 6 * (resolution + 1);
    data.add_triangle(first_id, first_id + 1, first_id + 3);
    data.add_triangle(first_id, first_id + 3, first_id + 2);
 
    for (int i = resolution; i >= 0; --i) {
        const float angle = float(i) * step_angle;
        const float c = ::cos(angle);
        const float s = ::sin(angle);
        data.add_vertex(Vec3f(outer_radius * s, outer_radius * c, -half_thickness), Vec3f(s, c, 0.0f));
    }
 
    for (int i = resolution; i >= 0; --i) {
        const float angle = float(i) * step_angle;
        const float c = ::cos(angle);
        const float s = ::sin(angle);
        data.add_vertex(Vec3f(outer_radius * s, outer_radius * c, +half_thickness), Vec3f(s, c, 0.0f));
    }
 
    first_id = 30 + 6 * (resolution + 1);
    for (unsigned int i = 0; i < resolution; ++i) {
        const unsigned int ii = first_id + i;
        data.add_triangle(ii, ii + 1, ii + resolution + 2);
        data.add_triangle(ii, ii + resolution + 2, ii + resolution + 1);
    }
 
    return data;
}

References Slic3r::angle(), cos(), Slic3r::GUI::GLModel::Geometry::P3N3, PI, sin(), and Slic3r::GUI::GLModel::Geometry::Triangles.

Referenced by Slic3r::GUI::Selection::init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clickable()

bool Slic3r::GUI::clickable	(	const IconManager::Icon &	icon,
		const IconManager::Icon &	icon_hover
	)

Draw icon which change on hover.

Parameters

icon	Draw when no hover
icon_hover	Draw when hover

Returns: True when click, otherwise False

{
    // check of hover
    float cursor_x = ImGui::GetCursorPosX();
    priv::draw_transparent_icon(icon);
    ImGui::SameLine(cursor_x);
    if (ImGui::IsItemHovered()) {
        // redraw image
        draw(icon_hover);
    } else {
        // redraw normal image
        draw(icon);
    }
    return ImGui::IsItemClicked();
}

References draw(), priv::draw_transparent_icon(), ImGui::GetCursorPosX(), ImGui::IsItemClicked(), ImGui::IsItemHovered(), and ImGui::SameLine().

Referenced by button(), Slic3r::GUI::GLGizmoEmboss::draw_bold_button(), and Slic3r::GUI::GLGizmoEmboss::draw_italic_button().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ color_string()

static void Slic3r::GUI::color_string	(	wxString &	str,
		const std::string &	color
	)

static

{
#if defined(SUPPORTS_MARKUP) && !defined(__APPLE__)
    str = from_u8((boost::format("<span color=\"%1%\">%2%</span>") % color % into_u8(str)).str());
#endif
}

References from_u8(), and into_u8().

Referenced by Slic3r::GUI::ModelNode::ModelNode(), Slic3r::GUI::DiffModel::AddOption(), and Slic3r::GUI::DiffModel::AddPreset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ combochecklist_get_flags()

unsigned int Slic3r::GUI::combochecklist_get_flags ( wxComboCtrl * comboCtrl )

{
  unsigned int flags = 0;
 
  wxCheckListBoxComboPopup* popup = wxDynamicCast(comboCtrl->GetPopupControl(), wxCheckListBoxComboPopup);
  if (popup != nullptr) {
    for (unsigned int i = 0; i < popup->GetCount(); ++i) {
      if (popup->IsChecked(i))
        flags |= 1 << i;
    }
  }
 
  return flags;
}

◆ combochecklist_set_flags()

void Slic3r::GUI::combochecklist_set_flags	(	wxComboCtrl *	comboCtrl,
		unsigned int	flags
	)

{
  wxCheckListBoxComboPopup* popup = wxDynamicCast(comboCtrl->GetPopupControl(), wxCheckListBoxComboPopup);
  if (popup != nullptr) {
    for (unsigned int i = 0; i < popup->GetCount(); ++i) {
      popup->Check(i, (flags & (1 << i)) != 0);
    }
  }
}

◆ composite_id_match()

static bool Slic3r::GUI::composite_id_match	(	const GLVolume::CompositeID &	id1,
		const GLVolume::CompositeID &	id2
	)

static

{
    return id1.object_id == id2.object_id && id1.instance_id == id2.instance_id;
}

References Slic3r::GLVolume::CompositeID::instance_id, and Slic3r::GLVolume::CompositeID::object_id.

◆ concat_strings()

static std::string Slic3r::GUI::concat_strings	(	const std::set< std::string > &	strings,
		const std::string &	delim = `"\n"`
	)

static

{
    return std::accumulate(
        strings.begin(), strings.end(), std::string(""),
        [delim](const std::string &s, const std::string &name) {
            return s + name + delim;
        });
}

Referenced by Slic3r::GUI::ArrangeJob::finalize().

Here is the caller graph for this function:

◆ CONFIG_UPDATE_WIKI_URL()

static const std::string Slic3r::GUI::CONFIG_UPDATE_WIKI_URL ( "https://github.com/prusa3d/PrusaSlicer/wiki/Slic3r-PE-1.40-configuration-update" )

static

Referenced by Slic3r::GUI::MsgDataLegacy::MsgDataLegacy().

Here is the caller graph for this function:

◆ constraint_id()

static int Slic3r::GUI::constraint_id ( int grabber_id )

static

{
  static const std::vector<int> id_map = { 1, 0, 3, 2, 5, 4, 8, 9, 6, 7 };
  return (0 <= grabber_id && grabber_id < (int)id_map.size()) ? id_map[grabber_id] : -1;
}

Referenced by Slic3r::GUI::GLGizmoScale3D::on_mouse(), and Slic3r::GUI::GLGizmoScale3D::on_start_dragging().

Here is the caller graph for this function:

◆ contains()

bool Slic3r::GUI::contains	(	const BuildVolume &	volume,
		const GLModel &	model,
		bool	ignore_bottom
	)

{
    static constexpr const double epsilon = BuildVolume::BedEpsilon;
    switch (volume.type()) {
    case BuildVolume::Type::Rectangle:
    {
        BoundingBox3Base<Vec3d> build_volume = volume.bounding_volume().inflated(epsilon);
        if (volume.max_print_height() == 0.0)
            build_volume.max.z() = std::numeric_limits<double>::max();
        if (ignore_bottom)
            build_volume.min.z() = -std::numeric_limits<double>::max();
        const BoundingBoxf3& model_box = model.get_bounding_box();
        return build_volume.contains(model_box.min) && build_volume.contains(model_box.max);
    }
    case BuildVolume::Type::Circle:
    {
        const Geometry::Circled& circle = volume.circle();
        const Vec2f c = unscaled<float>(circle.center);
        const float r = unscaled<double>(circle.radius) + float(epsilon);
        const float r2 = sqr(r);
        return volume.max_print_height() == 0.0 ?
            all_vertices_inside(model.get_geometry(), [c, r2](const Vec3f& p) { return (to_2d(p) - c).squaredNorm() <= r2; }) :
 
            all_vertices_inside(model.get_geometry(), [c, r2, z = volume.max_print_height() + epsilon](const Vec3f& p) { return (to_2d(p) - c).squaredNorm() <= r2 && p.z() <= z; });
    }
    case BuildVolume::Type::Convex:
        //FIXME doing test on convex hull until we learn to do test on non-convex polygons efficiently.
    case BuildVolume::Type::Custom:
        return volume.max_print_height() == 0.0 ?
            all_vertices_inside(model.get_geometry(), [&volume](const Vec3f& p) { return Geometry::inside_convex_polygon(volume.top_bottom_convex_hull_decomposition_bed(), to_2d(p).cast<double>()); }) :
            all_vertices_inside(model.get_geometry(), [&volume, z = volume.max_print_height() + epsilon](const Vec3f& p) { return Geometry::inside_convex_polygon(volume.top_bottom_convex_hull_decomposition_bed(), to_2d(p).cast<double>()) && p.z() <= z; });
    default:
        return true;
    }
}

References all_vertices_inside(), Slic3r::BuildVolume::BedEpsilon, Slic3r::Geometry::Circle< Vector >::center, Slic3r::BuildVolume::Circle, Slic3r::BoundingBox3Base< PointType >::contains(), Slic3r::BuildVolume::Convex, Slic3r::BuildVolume::Custom, Slic3r::GUI::GLModel::get_bounding_box(), Slic3r::GUI::GLModel::get_geometry(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::Geometry::Circle< Vector >::radius, Slic3r::BuildVolume::Rectangle, and Slic3r::sqr().

Here is the call graph for this function:

◆ convert_input()

static double Slic3r::GUI::convert_input	(	int	coord_byte_low,
		int	coord_byte_high,
		double	deadzone
	)

static

{
    int value = coord_byte_low | (coord_byte_high << 8);
    if (value >= 32768)
      value = value - 65536;
    double ret = (double)value / 350.0;
    return (std::abs(ret) > deadzone) ? ret : 0.0;
}

Referenced by Slic3r::GUI::Mouse3DController::handle_packet_rotation(), and Slic3r::GUI::Mouse3DController::handle_packet_translation().

Here is the caller graph for this function:

◆ create_combochecklist()

void Slic3r::GUI::create_combochecklist	(	wxComboCtrl *	comboCtrl,
		const std::string &	text,
		const std::string &	items
	)

{
    if (comboCtrl == nullptr)
        return;
    wxGetApp().UpdateDarkUI(comboCtrl);
 
    wxCheckListBoxComboPopup* popup = new wxCheckListBoxComboPopup;
    if (popup != nullptr) {
    // FIXME If the following line is removed, the combo box popup list will not react to mouse clicks.
        //  On the other side, with this line the combo box popup cannot be closed by clicking on the combo button on Windows 10.
        comboCtrl->UseAltPopupWindow();
 
    int max_width = 0;
 
    // the following line messes up the popup size the first time it is shown on wxWidgets 3.1.3
//    comboCtrl->EnablePopupAnimation(false);
#ifdef _WIN32
    popup->SetFont(comboCtrl->GetFont());
#endif // _WIN32
    comboCtrl->SetPopupControl(popup);
    wxString title = from_u8(text);
    max_width = std::max(max_width, 60 + comboCtrl->GetTextExtent(title).x);
    popup->SetStringValue(title);
    popup->Bind(wxEVT_CHECKLISTBOX, [popup](wxCommandEvent& evt) { popup->OnCheckListBox(evt); });
    popup->Bind(wxEVT_LISTBOX, [popup](wxCommandEvent& evt) { popup->OnListBoxSelection(evt); });
        popup->Bind(wxEVT_KEY_DOWN, [popup](wxKeyEvent& evt) { popup->OnKeyEvent(evt); });
        popup->Bind(wxEVT_KEY_UP, [popup](wxKeyEvent& evt) { popup->OnKeyEvent(evt); });
 
        std::vector<std::string> items_str;
        boost::split(items_str, items, boost::is_any_of("|"), boost::token_compress_off);
 
    // each item must be composed by 2 parts
    assert(items_str.size() %2 == 0);
 
    for (size_t i = 0; i < items_str.size(); i += 2) {
      wxString label = from_u8(items_str[i]);
      max_width = std::max(max_width, 60 + popup->GetTextExtent(label).x);
      popup->Append(label);
      popup->Check(i / 2, items_str[i + 1] == "1");
    }
 
    comboCtrl->SetMinClientSize(wxSize(max_width, -1));
        wxGetApp().UpdateDarkUI(popup);
  }
}

References from_u8(), wxCheckListBoxComboPopup::OnCheckListBox(), wxCheckListBoxComboPopup::OnKeyEvent(), wxCheckListBoxComboPopup::OnListBoxSelection(), and wxCheckListBoxComboPopup::SetStringValue().

Here is the call graph for this function:

◆ create_freq_settings_popupmenu()

static void Slic3r::GUI::create_freq_settings_popupmenu	(	wxMenu *	menu,
		const bool	is_object_settings,
		wxDataViewItem	item
	)

static

{
    // Add default settings bundles
    const SettingsFactory::Bundle& bundle = printer_technology() == ptFFF ? FREQ_SETTINGS_BUNDLE_FFF : FREQ_SETTINGS_BUNDLE_SLA;
 
    const int extruders_cnt = extruders_count();
 
    for (auto& category : bundle) {
        if (is_improper_category(category.first, extruders_cnt, is_object_settings))
            continue;
 
        append_menu_item(menu, wxID_ANY, _(category.first), "",
            [menu, item, is_object_settings, bundle](wxCommandEvent& event) {
                    wxString category_name = menu->GetLabel(event.GetId());
                    std::vector<std::string> options;
                    for (auto& category : bundle) 
                        if (category_name == _(category.first)) {
                            options = category.second;
                            break;
                        }
                    if (options.empty())
                        return;
                    // Because of we couldn't edited layer_height for ItVolume from settings list,
                    // correct options according to the selected item type : remove "layer_height" option
                    if (!is_object_settings && category_name == _("Layers and Perimeters")) {
                        const auto layer_height_it = std::find(options.begin(), options.end(), "layer_height");
                        if (layer_height_it != options.end())
                            options.erase(layer_height_it);
                    }
 
                    obj_list()->add_category_to_settings_from_frequent(options, item);
                },
            SettingsFactory::get_category_bitmap(category.first), menu,
            []() { return true; }, plater());
    }
#if 0
    // Add "Quick" settings bundles
    const SettingsFactory::Bundle& bundle_quick = printer_technology() == ptFFF ? m_freq_settings_fff : m_freq_settings_sla;
 
    for (auto& category : bundle_quick) {
        if (is_improper_category(category.first, extruders_cnt))
            continue;
 
        append_menu_item(menu, wxID_ANY, format_wxstr(_L("Quick Add Settings (%s)"), _(it.first)), "",
            [menu, item, is_object_settings, bundle](wxCommandEvent& event) {
                wxString category_name = menu->GetLabel(event.GetId());
                std::vector<std::string> options;
                for (auto& category : bundle)
                    if (category_name == from_u8((boost::format(_L("Quick Add Settings (%s)")) % _(category.first)).str())) {
                        options = category.second;
                        break;
                    }
                if (options.empty())
                    return;
                // Because of we couldn't edited layer_height for ItVolume from settings list,
                // correct options according to the selected item type : remove "layer_height" option
                if (!is_object_settings) {
                    const auto layer_height_it = std::find(options.begin(), options.end(), "layer_height");
                    if (layer_height_it != options.end())
                        options.erase(layer_height_it);
                }
                obj_list()->add_category_to_settings_from_frequent(options, item);
            },
            SettingsFactory::get_category_bitmap(category.first), menu,
            [this]() { return true; }, plater());
    }
#endif
}

References _, Slic3r::GUI::ObjectList::add_category_to_settings_from_frequent(), append_menu_item(), extruders_count(), FREQ_SETTINGS_BUNDLE_FFF, FREQ_SETTINGS_BUNDLE_SLA, Slic3r::GUI::SettingsFactory::get_category_bitmap(), if(), is_improper_category(), obj_list(), plater(), printer_technology(), and Slic3r::ptFFF.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_mesh()

static TriangleMesh Slic3r::GUI::create_mesh	(	const std::string &	type_name,
		const BoundingBoxf3 &	bb
	)

static

{
    const double side = wxGetApp().plater()->canvas3D()->get_size_proportional_to_max_bed_size(0.1);
 
    indexed_triangle_set mesh;
    if (type_name == "Box")
        // Sitting on the print bed, left front front corner at (0, 0).
        mesh = its_make_cube(side, side, side);
    else if (type_name == "Cylinder")
        // Centered around 0, sitting on the print bed.
        // The cylinder has the same volume as the box above.
        mesh = its_make_cylinder(0.564 * side, side);
    else if (type_name == "Sphere")
        // Centered around 0, half the sphere below the print bed, half above.
        // The sphere has the same volume as the box above.
        mesh = its_make_sphere(0.62 * side, PI / 18);
    else if (type_name == "Slab")
        // Sitting on the print bed, left front front corner at (0, 0).
        mesh = its_make_cube(bb.size().x() * 1.5, bb.size().y() * 1.5, bb.size().z() * 0.5);
    return TriangleMesh(mesh);
}

References Slic3r::its_make_cube(), Slic3r::its_make_cylinder(), Slic3r::its_make_sphere(), PI, and Slic3r::BoundingBox3Base< PointType >::size().

Referenced by Slic3r::GUI::ObjectList::load_generic_subobject(), and Slic3r::GUI::ObjectList::load_shape_object().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_meshes()

RaycastManager::Meshes Slic3r::GUI::create_meshes	(	GLCanvas3D &	canvas,
		const RaycastManager::AllowVolumes &	condition
	)

Use scene Raycasters and prepare data for actualize RaycasterManager.

Parameters

canvas	contain Scene raycasters
condition	Limit for scene casters

Returns: Meshes

{
    SceneRaycaster::EType type = SceneRaycaster::EType::Volume;
    auto scene_casters = canvas.get_raycasters_for_picking(type);
    if (scene_casters == nullptr)
        return {};
    const std::vector<std::shared_ptr<SceneRaycasterItem>> &casters = *scene_casters;
 
    const GLVolumePtrs    &gl_volumes = canvas.get_volumes().volumes;
    const ModelObjectPtrs &objects    = canvas.get_model()->objects;
 
    RaycastManager::Meshes meshes;
    for (const std::shared_ptr<SceneRaycasterItem> &caster : casters) {
        int index = SceneRaycaster::decode_id(type, caster->get_id());
        if (index < 0)
            continue;
        auto index_ = static_cast<size_t>(index);
        if(index_ >= gl_volumes.size())
            continue;
        const GLVolume *gl_volume = gl_volumes[index_];
        if (gl_volume == nullptr)
            continue;
        const ModelVolume *volume = get_model_volume(*gl_volume, objects);
        if (volume == nullptr)
            continue;
        size_t id = volume->id().id;
        if (condition.skip(id))
            continue;
        auto mesh = std::make_unique<AABBMesh>(caster->get_raycaster()->get_aabb_mesh());
        meshes.emplace_back(std::make_pair(id, std::move(mesh)));
    }
    return meshes;
}

References Slic3r::GUI::SceneRaycaster::decode_id(), Slic3r::GUI::GLCanvas3D::get_model(), get_model_volume(), Slic3r::GUI::GLCanvas3D::get_raycasters_for_picking(), Slic3r::GUI::GLCanvas3D::get_volumes(), Slic3r::Model::objects, Slic3r::GUI::RaycastManager::AllowVolumes::skip(), Slic3r::GUI::SceneRaycaster::Volume, and Slic3r::GLVolumeCollection::volumes.

Referenced by on_mouse_surface_drag(), and priv::start_create_volume_on_surface_job().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_options_tab()

static std::shared_ptr< ConfigOptionsGroup > Slic3r::GUI::create_options_tab	(	const wxString &	title,
		wxBookCtrlBase *	tabs
	)

static

{
  wxPanel* tab = new wxPanel(tabs, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxBK_LEFT | wxTAB_TRAVERSAL);
  tabs->AddPage(tab, _(title));
  tab->SetFont(wxGetApp().normal_font());
 
  wxBoxSizer* sizer = new wxBoxSizer(wxVERTICAL);
  sizer->SetSizeHints(tab);
  tab->SetSizer(sizer);
 
  std::shared_ptr<ConfigOptionsGroup> optgroup = std::make_shared<ConfigOptionsGroup>(tab);
  optgroup->label_width = 40;
  optgroup->set_config_category_and_type(title, int(Preset::TYPE_PREFERENCES));
  return optgroup;
}

References _, and Slic3r::Preset::TYPE_PREFERENCES.

Referenced by Slic3r::GUI::PreferencesDialog::build().

Here is the caller graph for this function:

◆ create_settings_popupmenu()

static wxMenu * Slic3r::GUI::create_settings_popupmenu	(	wxMenu *	parent_menu,
		const bool	is_object_settings,
		wxDataViewItem	item
	)

static

{
    wxMenu* menu = new wxMenu;
 
    FullSettingsHierarchy categories;
    get_full_settings_hierarchy(categories, !is_object_settings);
 
    auto get_selected_options_for_category = [categories, item](const wxString& category_name) {
        wxArrayString names;
        wxArrayInt selections;
 
        std::vector< std::pair<std::string, bool> > category_options;
        for (auto& cat : categories) {
            if (_(cat.first) == category_name) {
                ModelConfig& config = obj_list()->get_item_config(item);
                auto opt_keys = config.keys();
 
                int sel = 0;
                for (const std::pair<std::string, std::string>& pair : cat.second) {
                    names.Add(_(pair.second));
                    if (find(opt_keys.begin(), opt_keys.end(), pair.first) != opt_keys.end())
                        selections.Add(sel);
                    sel++;
                    category_options.push_back(std::make_pair(pair.first, false));
                }
                break;
            }
        }
 
        if (!category_options.empty() &&
            GetSelectedChoices(selections, _L("Select showing settings"), category_name, names) != -1) {
            for (auto sel : selections)
                category_options[sel].second = true;
        }
        return category_options;
 
#if 0
        if (selections.size() > 0)
        {
            // Add selected items to the "Quick menu"
            SettingsFactory::Bundle& freq_settings = printer_technology() == ptSLA ?
                m_freq_settings_sla : m_freq_settings_fff;
            bool changed_existing = false;
 
            std::vector<std::string> tmp_freq_cat = {};
 
            for (auto& cat : freq_settings)
            {
                if (_(cat.first) == category_name)
                {
                    std::vector<std::string>& freq_settings_category = cat.second;
                    freq_settings_category.clear();
                    freq_settings_category.reserve(selection_cnt);
                    for (auto sel : selections)
                        freq_settings_category.push_back((*settings_list)[sel].first);
 
                    changed_existing = true;
                    break;
                }
            }
 
            if (!changed_existing)
            {
                // Create new "Quick menu" item
                for (auto& cat : settings_menu)
                {
                    if (_(cat.first) == category_name)
                    {
                        freq_settings[cat.first] = std::vector<std::string>{};
 
                        std::vector<std::string>& freq_settings_category = freq_settings.find(cat.first)->second;
                        freq_settings_category.reserve(selection_cnt);
                        for (auto sel : selections)
                            freq_settings_category.push_back((*settings_list)[sel].first);
                        break;
                    }
                }
            }
        }
#endif
    };
 
    for (auto cat : categories) {
        append_menu_item(menu, wxID_ANY, _(cat.first), "",
                         [menu, item, get_selected_options_for_category](wxCommandEvent& event) {
                            std::vector< std::pair<std::string, bool> > category_options = get_selected_options_for_category(menu->GetLabel(event.GetId()));
                            obj_list()->add_category_to_settings_from_selection(category_options, item);
                         }, SettingsFactory::get_category_bitmap(cat.first), parent_menu,
                         []() { return true; }, plater());
    }
 
    return menu;
}

References _, _L, append_menu_item(), Slic3r::GUI::SettingsFactory::get_category_bitmap(), get_full_settings_hierarchy(), Slic3r::GUI::ObjectList::get_item_config(), GetSelectedChoices(), Slic3r::ModelConfig::keys(), obj_list(), plater(), printer_technology(), and Slic3r::ptSLA.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_volumes_name()

static std::string Slic3r::GUI::create_volumes_name	(	const std::set< ObjectID > &	ids,
		const Selection &	selection
	)

static

                                                                                             {
    assert(!ids.empty());
    std::string name;
    bool        is_first = true;
    for (const ObjectID &id : ids) {
        if (is_first)
            is_first = false;
        else
            name += " + ";
 
        const ModelVolume *volume = get_volume(id, selection);
        assert(volume != nullptr);
        name += volume->name;
    }
    return name;
}

References get_volume().

Referenced by Slic3r::GUI::GLGizmoSimplify::apply_simplify(), and Slic3r::GUI::GLGizmoSimplify::on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_word_local_combo()

static choice_ctrl * Slic3r::GUI::create_word_local_combo ( wxWindow * parent )

static

{
    wxSize size(15 * wxGetApp().em_unit(), -1);
 
    choice_ctrl* temp = nullptr;
#ifdef __WXOSX__
    /* wxBitmapComboBox with wxCB_READONLY style return NULL for GetTextCtrl(),
     * so ToolTip doesn't shown.
     * Next workaround helps to solve this problem
     */
    temp = new wxBitmapComboBox();
    temp->SetTextCtrlStyle(wxTE_READONLY);
  temp->Create(parent, wxID_ANY, wxString(""), wxDefaultPosition, size, 0, nullptr);
#else
  temp = new choice_ctrl(parent, wxID_ANY, wxString(""), wxDefaultPosition, size, 0, nullptr, wxCB_READONLY | wxBORDER_SIMPLE);
#endif //__WXOSX__
 
    temp->SetFont(Slic3r::GUI::wxGetApp().normal_font());
    if (!wxOSX) temp->SetBackgroundStyle(wxBG_STYLE_PAINT);
 
    temp->Append(ObjectManipulation::coordinate_type_str(ECoordinatesType::World));
    temp->Append(ObjectManipulation::coordinate_type_str(ECoordinatesType::Instance));
    temp->Append(ObjectManipulation::coordinate_type_str(ECoordinatesType::Local));
    temp->Select((int)ECoordinatesType::World);
 
    temp->SetToolTip(_L("Select coordinate space, in which the transformation will be performed."));
  return temp;
}

References _L, Slic3r::GUI::ObjectManipulation::coordinate_type_str(), em_unit(), Instance, Local, World, and wxOSX.

Referenced by Slic3r::GUI::ObjectManipulation::ObjectManipulation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ debugged()

bool Slic3r::GUI::debugged ( )

{
    #ifdef _WIN32
    return IsDebuggerPresent() == TRUE;
  #else
  return false;
    #endif /* _WIN32 */
}

References TRUE.

◆ def_text_color()

static std::string Slic3r::GUI::def_text_color ( )

static

{
    wxColour def_colour = wxGetApp().get_label_clr_default();
    return encode_color(ColorRGB(def_colour.Red(), def_colour.Green(), def_colour.Blue()));
}

References Slic3r::encode_color().

Referenced by Slic3r::GUI::ModelNode::ModelNode(), Slic3r::GUI::DiffModel::AddOption(), Slic3r::GUI::DiffModel::AddPreset(), and Slic3r::GUI::ModelNode::UpdateEnabling().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ desktop_open_datadir_folder()

void Slic3r::GUI::desktop_open_datadir_folder ( )

{
  boost::filesystem::path path(data_dir());
  desktop_open_folder(std::move(path));
}

References Slic3r::data_dir(), and desktop_open_folder().

Referenced by generate_help_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ desktop_open_folder()

void Slic3r::GUI::desktop_open_folder ( const boost::filesystem::path & path )

{
  if (!boost::filesystem::is_directory(path)) 
    return;
 
  // Execute command to open a file explorer, platform dependent.
#ifdef _WIN32
  const wxString widepath = path.wstring();
  const wchar_t* argv[] = { L"explorer", widepath.GetData(), nullptr };
  ::wxExecute(const_cast<wchar_t**>(argv), wxEXEC_ASYNC, nullptr);
#elif __APPLE__
  const char* argv[] = { "open", path.string().c_str(), nullptr };
  ::wxExecute(const_cast<char**>(argv), wxEXEC_ASYNC, nullptr);
#else
  const char* argv[] = { "xdg-open", path.string().c_str(), nullptr };
  desktop_execute(argv);
#endif
}

References L.

Referenced by desktop_open_datadir_folder(), and Slic3r::AppUpdater::sync_download().

Here is the caller graph for this function:

◆ diamond()

GLModel::Geometry Slic3r::GUI::diamond ( unsigned int resolution )

{
    resolution = std::max<unsigned int>(4, resolution);
 
    GLModel::Geometry data;
    data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3N3 };
    data.reserve_vertices(resolution + 2);
    data.reserve_indices((2 * (resolution + 1)) * 3);
 
    const float step = 2.0f * float(PI) / float(resolution);
 
    // vertices
    for (unsigned int i = 0; i < resolution; ++i) {
        const float ii = float(i) * step;
        const Vec3f p = { 0.5f * ::cos(ii), 0.5f * ::sin(ii), 0.0f };
        data.add_vertex(p, (Vec3f)p.normalized());
    }
    Vec3f p = { 0.0f, 0.0f, 0.5f };
    data.add_vertex(p, (Vec3f)p.normalized());
    p = { 0.0f, 0.0f, -0.5f };
    data.add_vertex(p, (Vec3f)p.normalized());
 
    // triangles
    // top
    for (unsigned int i = 0; i < resolution; ++i) {
        data.add_triangle(i + 0, i + 1, resolution);
    }
    data.add_triangle(resolution - 1, 0, resolution);
 
    // bottom
    for (unsigned int i = 0; i < resolution; ++i) {
        data.add_triangle(i + 0, resolution + 1, i + 1);
    }
    data.add_triangle(resolution - 1, resolution + 1, 0);
 
    return data;
}

References cos(), Slic3r::GUI::GLModel::Geometry::P3N3, PI, sin(), and Slic3r::GUI::GLModel::Geometry::Triangles.

Referenced by Slic3r::GUI::GCodeViewer::init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ disable_screensaver()

void Slic3r::GUI::disable_screensaver ( )

{
    #if __APPLE__
    CFStringRef reasonForActivity = CFSTR("Slic3r");
    [[maybe_unused]]IOReturn success = IOPMAssertionCreateWithName(kIOPMAssertionTypeNoDisplaySleep,
        kIOPMAssertionLevelOn, reasonForActivity, &assertionID);
    // ignore result: success == kIOReturnSuccess
    #elif _WIN32
    SetThreadExecutionState(ES_DISPLAY_REQUIRED | ES_CONTINUOUS);
    #endif
}

◆ dots()

static wxString Slic3r::GUI::dots	(	"…"	,
		wxConvUTF8
	)

static

Referenced by Slic3r::GUI::AboutDialog::AboutDialog(), Slic3r::GUI::FreqChangedParams::FreqChangedParams(), Slic3r::GUI::Sidebar::Sidebar(), Slic3r::GUI::GUI_App::add_config_menu(), Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings(), Slic3r::GUI::GLGizmoEmboss::draw_font_preview(), Slic3r::GUI::NotificationManager::PrintHostUploadNotification::generate_text(), Slic3r::GUI::DiffViewCtrl::get_short_string(), Slic3r::GUI::MainFrame::init_menubar_as_editor(), Slic3r::GUI::MainFrame::init_menubar_as_gcodeviewer(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::ObjectList::load_modifier(), Slic3r::GUI::GLGizmoFdmSupports::on_init(), Slic3r::GUI::GUI_App::on_init_inner(), Slic3r::GUI::MainFrame::open_menubar_item(), Slic3r::GUI::GUI_App::open_preferences(), Slic3r::GUI::GUI_App::recreate_GUI(), Slic3r::GUI::NotificationManager::URLDownloadNotification::render_bar(), Slic3r::GUI::Plater::reslice(), Slic3r::GUI::GUI_App::switch_language(), Slic3r::GUI::Plater::priv::update_background_process(), and Slic3r::GUI::MainFrame::update_menubar().

Here is the caller graph for this function:

◆ double_to_string()

wxString Slic3r::GUI::double_to_string	(	double const	value,
		const int	max_precision
	)

{
// Style_NoTrailingZeroes does not work on OSX. It also does not work correctly with some locales on Windows.
//  return wxNumberFormatter::ToString(value, max_precision, wxNumberFormatter::Style_NoTrailingZeroes);
 
  wxString s = wxNumberFormatter::ToString(value, std::abs(value) < 0.0001 ? 10 : max_precision, wxNumberFormatter::Style_None);
 
  // The following code comes from wxNumberFormatter::RemoveTrailingZeroes(wxString& s)
  // with the exception that here one sets the decimal separator explicitely to dot.
    // If number is in scientific format, trailing zeroes belong to the exponent and cannot be removed.
    if (s.find_first_of("eE") == wxString::npos) {
        char dec_sep = is_decimal_separator_point() ? '.' : ',';
        const size_t posDecSep = s.find(dec_sep);
      // No decimal point => removing trailing zeroes irrelevant for integer number.
      if (posDecSep != wxString::npos) {
        // Find the last character to keep.
        size_t posLastNonZero = s.find_last_not_of("0");
            // If it's the decimal separator itself, don't keep it either.
        if (posLastNonZero == posDecSep)
            -- posLastNonZero;
        s.erase(posLastNonZero + 1);
        // Remove sign from orphaned zero.
        if (s.compare("-0") == 0)
            s = "0";
    }
  }
 
    return s;
}

References Slic3r::is_decimal_separator_point().

Referenced by Slic3r::GUI::ExtruderSequenceDialog::ExtruderSequenceDialog(), Slic3r::GUI::LayerRangeEditor::LayerRangeEditor(), Slic3r::GUI::PageBuildVolume::PageBuildVolume(), Slic3r::GUI::PageDiameters::PageDiameters(), Slic3r::GUI::BedShape::apply_optgroup_values(), Slic3r::GUI::TextCtrl::BUILD(), Slic3r::GUI::ObjectLayers::create_layer(), focus_event(), Slic3r::GUI::ConfigOptionsGroup::get_config_value(), Slic3r::GUI::BedShape::get_full_name_with_params(), get_string_value(), Slic3r::GUI::Field::get_value_by_opt_type(), Slic3r::DoubleSlider::get_value_to_jump(), Slic3r::GUI::GLGizmoCut3D::render_build_size(), Slic3r::GUI::Choice::set_selection(), Slic3r::GUI::ObjectManipulation::update_if_dirty(), and Slic3r::GUI::ObjectManipulation::update_ui_from_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw()

void Slic3r::GUI::draw	(	const IconManager::Icon &	icon,
		const ImVec2 &	size = `ImVec2(0, 0)`,
		const ImVec4 &	tint_col = `ImVec4(1, 1, 1, 1)`,
		const ImVec4 &	border_col = `ImVec4(0, 0, 0, 0)`
	)

Draw imgui image with icon.

Parameters

icon	Place in texture
size	[optional]Size of image, wen zero than use same size as stored texture
tint_col	viz ImGui::Image
border_col	viz ImGui::Image

{
    // Check input
    if (!icon.is_valid()) {
        assert(false);
        BOOST_LOG_TRIVIAL(warning) << "Drawing invalid Icon.";
        ImGui::Text("?");
        return;
    }
 
    ImTextureID id = (void *)static_cast<intptr_t>(icon.tex_id);
    const ImVec2 &s  = (size.x < 1 || size.y < 1) ? icon.size : size;
    ImGui::Image(id, s, icon.tl, icon.br, tint_col, border_col);
}

References Slic3r::GUI::IconManager::Icon::br, ImGui::Image(), Slic3r::GUI::IconManager::Icon::is_valid(), Slic3r::GUI::IconManager::Icon::size, Slic3r::GUI::IconManager::Icon::tex_id, ImGui::Text(), and Slic3r::GUI::IconManager::Icon::tl.

Referenced by button(), clickable(), Slic3r::GUI::GLGizmoEmboss::draw_bold_button(), Slic3r::GUI::GLGizmoEmboss::draw_italic_button(), Slic3r::GUI::GLGizmoEmboss::draw_text_input(), priv::draw_transparent_icon(), and Slic3r::GUI::GLGizmoEmboss::revertible().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ enable_screensaver()

void Slic3r::GUI::enable_screensaver ( )

{
    #if __APPLE__
    IOPMAssertionRelease(assertionID);
    #elif _WIN32
    SetThreadExecutionState(ES_CONTINUOUS);
    #endif
}

◆ extruder2str()

static wxString Slic3r::GUI::extruder2str ( int extruder )

static

{
    return extruder == 0 ? _L("default") : wxString::Format("%d", extruder);
}

References _L.

Referenced by Slic3r::GUI::ObjectList::add_layer_item(), Slic3r::GUI::ObjectList::add_object_to_list(), and Slic3r::GUI::ObjectList::add_volumes_to_object_in_list().

Here is the caller graph for this function:

◆ extruders_count() [1/2]

static int Slic3r::GUI::extruders_count ( )

static

{
    return wxGetApp().extruders_edited_cnt();
}

Referenced by Slic3r::GUI::ObjectList::ObjectList(), Slic3r::GUI::MenuFactory::append_menu_item_change_extruder(), create_freq_settings_popupmenu(), get_extruders_names(), get_full_settings_hierarchy(), Slic3r::GUI::ObjectList::key_event(), Slic3r::GUI::GCodeViewer::load_shells(), Slic3r::GUI::MenuFactory::multi_selection_menu(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::ObjectList::update_objects_list_extruder_column(), and Slic3r::GUI::Sidebar::update_objects_list_extruder_column().

Here is the caller graph for this function:

◆ extruders_count() [2/2]

static int Slic3r::GUI::extruders_count ( )

static

{
    return wxGetApp().extruders_edited_cnt();
}

◆ fatal_error()

void Slic3r::GUI::fatal_error ( wxWindow * parent )

{
    show_error(parent, "");
    //     exit 1; // #ys_FIXME
}

References show_error().

Here is the call graph for this function:

◆ file_wildcards() [1/2]

static wxString Slic3r::GUI::file_wildcards ( const FileWildcards & data )

static

{
    std::string title;
    std::string mask;
 
    // Generate cumulative first item
    for (const std::string_view& ext : data.file_extensions) {
        if (title.empty()) {
            title = "*";
            title += ext;
            mask = title;
        }
        else {
            title += ", *";
            title += ext;
            mask += ";*";
            mask += ext;
        }
        mask += ";*";
        mask += boost::to_upper_copy(std::string(ext));
    }
 
    wxString ret = GUI::format_wxstr("%s (%s)|%s", data.title, title, mask);
 
    // Adds an item for each of the extensions
    if (data.file_extensions.size() > 1) {
        for (const std::string_view& ext : data.file_extensions) {
            title = "*";
            title += ext;
            ret += GUI::format_wxstr("|%s (%s)|%s", data.title, title, title);
        }
    }
 
    return ret;
}

References format_wxstr().

Referenced by Slic3r::GUI::MainFrame::export_config(), Slic3r::GUI::MainFrame::export_configbundle(), Slic3r::GUI::Plater::export_gcode(), Slic3r::GUI::Plater::priv::get_export_file(), Slic3r::GUI::GUI_App::import_model(), Slic3r::GUI::GUI_App::import_zip(), Slic3r::GUI::MainFrame::load_configbundle(), Slic3r::GUI::GUI_App::load_gcode(), Slic3r::GUI::BedShapePanel::load_model(), Slic3r::GUI::GUI_App::load_project(), Slic3r::GUI::BedShapePanel::load_stl(), Slic3r::GUI::BedShapePanel::load_texture(), Slic3r::GUI::Plater::priv::reload_from_disk(), Slic3r::GUI::MainFrame::repair_stl(), Slic3r::GUI::Plater::priv::replace_with_stl(), sla_wildcards(), and start_new_gcodeviewer_open_file().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_wildcards() [2/2]

wxString Slic3r::GUI::file_wildcards	(	FileType	file_type,
		const std::string &	custom_extension
	)

{
    const FileWildcards& data = file_wildcards_by_type[file_type];
    std::string title;
    std::string mask;
    std::string custom_ext_lower;
 
    if (! custom_extension.empty()) {
        // Generate an extension into the title mask and into the list of extensions.
        custom_ext_lower = boost::to_lower_copy(custom_extension);
        const std::string custom_ext_upper = boost::to_upper_copy(custom_extension);
        if (custom_ext_lower == custom_extension) {
            // Add a lower case version.
            title = std::string("*") + custom_ext_lower;
            mask = title;
            // Add an upper case version.
            mask  += ";*";
            mask  += custom_ext_upper;
        } else if (custom_ext_upper == custom_extension) {
            // Add an upper case version.
            title = std::string("*") + custom_ext_upper;
            mask = title;
            // Add a lower case version.
            mask += ";*";
            mask += custom_ext_lower;
        } else {
            // Add the mixed case version only.
            title = std::string("*") + custom_extension;
            mask = title;
        }
    }
 
    for (const std::string_view &ext : data.file_extensions)
        // Only add an extension if it was not added first as the custom extension.
        if (ext != custom_ext_lower) {
            if (title.empty()) {
                title = "*";
                title += ext;
                mask  = title;
            } else {
                title += ", *";
                title += ext;
                mask  += ";*";
                mask  += ext;
            }
            mask += ";*";
            mask += boost::to_upper_copy(std::string(ext));
        }
 
    return GUI::format_wxstr("%s (%s)|%s", data.title, title, mask);
}

References file_wildcards_by_type, and format_wxstr().

Referenced by Slic3r::GUI::GalleryDialog::add_custom_shapes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_bndl()

wxBitmapBundle * Slic3r::GUI::find_bndl ( const std::string & bmp_name )

{
    if (!m_bitmap_cache)
        m_bitmap_cache = new BitmapCache;
 
    return m_bitmap_cache->find_bndl(bmp_name);
}

References Slic3r::GUI::BitmapCache::find_bndl(), and m_bitmap_cache.

Referenced by Slic3r::GUI::ObjectDataViewModelNode::update_settings_digest_bitmaps(), and Slic3r::GUI::ObjectDataViewModel::UpdateBitmapForNode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_close_layer_idx()

static int Slic3r::GUI::find_close_layer_idx	(	const std::vector< double > &	zs,
		double &	z,
		double	eps
	)

static

{
    if (zs.empty())
        return -1;
    auto it_h = std::lower_bound(zs.begin(), zs.end(), z);
    if (it_h == zs.end()) {
        auto it_l = it_h;
        -- it_l;
        if (z - *it_l < eps)
            return int(zs.size() - 1);
    } else if (it_h == zs.begin()) {
        if (*it_h - z < eps)
            return 0;
    } else {
        auto it_l = it_h;
        -- it_l;
        double dist_l = z - *it_l;
        double dist_h = *it_h - z;
        if (std::min(dist_l, dist_h) < eps) {
            return (dist_l < dist_h) ? int(it_l - zs.begin()) : int(it_h - zs.begin());
        }
    }
    return -1;
}

Referenced by Slic3r::GUI::Preview::update_layers_slider().

Here is the caller graph for this function:

◆ find_toplevel_parent()

wxTopLevelWindow * Slic3r::GUI::find_toplevel_parent ( wxWindow * window )

{
    for (; window != nullptr; window = window->GetParent()) {
        if (window->IsTopLevel()) {
            return dynamic_cast<wxTopLevelWindow*>(window);
        }
    }
 
    return nullptr;
}

Referenced by em_unit(), Slic3r::GUI::ObjectList::fix_through_netfabb(), Slic3r::GUI::Plater::priv::load_files(), and Slic3r::GUI::Tab::OnActivate().

Here is the caller graph for this function:

◆ focus_event()

static void Slic3r::GUI::focus_event	(	wxFocusEvent &	e,
		wxTextCtrl *	ctrl,
		double	def_value
	)

static

{
    e.Skip();
    wxString str = ctrl->GetValue();
 
    const char dec_sep = is_decimal_separator_point() ? '.' : ',';
    const char dec_sep_alt = dec_sep == '.' ? ',' : '.';
    // Replace the first incorrect separator in decimal number.
    bool was_replaced = str.Replace(dec_sep_alt, dec_sep, false) != 0;
 
    double val = 0.0;
    if (!str.ToDouble(&val)) {
        if (val == 0.0)
            val = def_value;
        ctrl->SetValue(double_to_string(val));
        show_error(nullptr, _L("Invalid numeric input."));
        // On Windows, this SetFocus creates an invisible marker.
        //ctrl->SetFocus();
    }
    else if (was_replaced)
        ctrl->SetValue(double_to_string(val));
}

References _L, double_to_string(), Slic3r::is_decimal_separator_point(), and show_error().

Referenced by Slic3r::GUI::PageDiameters::PageDiameters().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ format() [1/3]

template<typename... TArgs>

std::string Slic3r::GUI::format	(	const char *	fmt,
		TArgs &&...	args
	)

inline

                                                          {
    return Slic3r::format(fmt, std::forward<TArgs>(args)...);
}

References Slic3r::format().

Here is the call graph for this function:

◆ format() [2/3]

template<typename... TArgs>

std::string Slic3r::GUI::format	(	const std::string &	fmt,
		TArgs &&...	args
	)

inline

                                                               {
    return Slic3r::format(fmt, std::forward<TArgs>(args)...);
}

References Slic3r::format().

Here is the call graph for this function:

◆ format() [3/3]

template<typename... TArgs>

std::string Slic3r::GUI::format	(	const wxString &	fmt,
		TArgs &&...	args
	)

inline

                                                              {
    return Slic3r::format(fmt.ToUTF8().data(), std::forward<TArgs>(args)...);
}

References Slic3r::format().

Here is the call graph for this function:

◆ format_double()

static std::string Slic3r::GUI::format_double ( double value )

static

{
    char buf[1024];
    sprintf(buf, "%.3f", value);
    return std::string(buf);
}

Referenced by Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), and Slic3r::GUI::GLGizmoMeasure::render_dimensioning().

Here is the caller graph for this function:

◆ format_reason()

static wxString Slic3r::GUI::format_reason ( const Config::Snapshot::Reason reason )

static

{
    switch (reason) {
    case Config::Snapshot::SNAPSHOT_UPGRADE:
        return wxString(_(L("Upgrade")));
    case Config::Snapshot::SNAPSHOT_DOWNGRADE:
        return wxString(_(L("Downgrade")));
    case Config::Snapshot::SNAPSHOT_BEFORE_ROLLBACK:
        return wxString(_(L("Before roll back")));
    case Config::Snapshot::SNAPSHOT_USER:
        return wxString(_(L("User")));
    case Config::Snapshot::SNAPSHOT_UNKNOWN:
    default:
        return wxString(_(L("Unknown")));
    }
}

References _, L, Slic3r::GUI::Config::Snapshot::SNAPSHOT_BEFORE_ROLLBACK, Slic3r::GUI::Config::Snapshot::SNAPSHOT_DOWNGRADE, Slic3r::GUI::Config::Snapshot::SNAPSHOT_UNKNOWN, Slic3r::GUI::Config::Snapshot::SNAPSHOT_UPGRADE, and Slic3r::GUI::Config::Snapshot::SNAPSHOT_USER.

Referenced by generate_html_row().

Here is the caller graph for this function:

◆ format_vec3()

static std::string Slic3r::GUI::format_vec3 ( const Vec3d & v )

static

{
    char buf[1024];
    sprintf(buf, "X: %.3f, Y: %.3f, Z: %.3f", v.x(), v.y(), v.z());
    return std::string(buf);
}

Referenced by Slic3r::GUI::GLGizmoMeasure::on_render_input_window().

Here is the caller graph for this function:

◆ format_wxstr() [1/3]

template<typename... TArgs>

wxString Slic3r::GUI::format_wxstr	(	const char *	fmt,
		TArgs &&...	args
	)

inline

                                                               {
  boost::format message(fmt);
  return wxString::FromUTF8(Slic3r::internal::format::format_recursive(message, std::forward<TArgs>(args)...).c_str());
}

References Slic3r::internal::format::format_recursive(), and format_wxstr().

Here is the call graph for this function:

◆ format_wxstr() [2/3]

template<typename... TArgs>

wxString Slic3r::GUI::format_wxstr	(	const std::string &	fmt,
		TArgs &&...	args
	)

inline

                                                                    {
  boost::format message(fmt);
  return wxString::FromUTF8(Slic3r::internal::format::format_recursive(message, std::forward<TArgs>(args)...).c_str());
}

References Slic3r::internal::format::format_recursive(), and format_wxstr().

Here is the call graph for this function:

◆ format_wxstr() [3/3]

template<typename... TArgs>

wxString Slic3r::GUI::format_wxstr	(	const wxString &	fmt,
		TArgs &&...	args
	)

inline

                                                                   {
  return format_wxstr(fmt.ToUTF8().data(), std::forward<TArgs>(args)...);
}

References format_wxstr().

Here is the call graph for this function:

◆ from_path()

wxString Slic3r::GUI::from_path ( const boost::filesystem::path & path )

{
#ifdef _WIN32
  return wxString(path.string<std::wstring>());
#else
  return from_u8(path.string<std::string>());
#endif
}

References from_u8().

Referenced by Slic3r::GUI::PrintHostQueueDialog::append_job(), Slic3r::GUI::Plater::export_3mf(), Slic3r::GUI::Plater::export_gcode(), Slic3r::GUI::Plater::priv::get_export_file(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::Plater::load_files(), Slic3r::GUI::ObjectList::load_modifier(), Slic3r::GUI::Plater::preview_zip_archive(), Slic3r::GUI::Plater::priv::set_project_filename(), and Slic3r::GUI::MainFrame::update_title().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ from_u8()

wxString Slic3r::GUI::from_u8 ( const std::string & str )

{
  return wxString::FromUTF8(str.c_str());
}

References from_u8().

Here is the call graph for this function:

◆ generate_help_menu()

static wxMenu * Slic3r::GUI::generate_help_menu ( )

static

{
    wxMenu* helpMenu = new wxMenu();
    append_menu_item(helpMenu, wxID_ANY, _L("Prusa 3D &Drivers"), _L("Open the Prusa3D drivers download page in your browser"),
        [](wxCommandEvent&) { wxGetApp().open_web_page_localized("https://www.prusa3d.com/downloads"); });
    append_menu_item(helpMenu, wxID_ANY, _L("Software &Releases"), _L("Open the software releases page in your browser"),
        [](wxCommandEvent&) { wxGetApp().open_browser_with_warning_dialog("https://github.com/prusa3d/PrusaSlicer/releases", nullptr, false); });
//#        my $versioncheck = $self->_append_menu_item($helpMenu, "Check for &Updates...", "Check for new Slic3r versions", sub{
//#            wxTheApp->check_version(1);
//#        });
//#        $versioncheck->Enable(wxTheApp->have_version_check);
    append_menu_item(helpMenu, wxID_ANY, wxString::Format(_L("%s &Website"), SLIC3R_APP_NAME),
        wxString::Format(_L("Open the %s website in your browser"), SLIC3R_APP_NAME),
        [](wxCommandEvent&) { wxGetApp().open_web_page_localized("https://www.prusa3d.com/slicerweb"); });
//        append_menu_item(helpMenu, wxID_ANY, wxString::Format(_L("%s &Manual"), SLIC3R_APP_NAME),
//                                             wxString::Format(_L("Open the %s manual in your browser"), SLIC3R_APP_NAME),
//            [this](wxCommandEvent&) { wxGetApp().open_browser_with_warning_dialog("http://manual.slic3r.org/"); });
    helpMenu->AppendSeparator();
    append_menu_item(helpMenu, wxID_ANY, _L("System &Info"), _L("Show system information"),
        [](wxCommandEvent&) { wxGetApp().system_info(); });
    append_menu_item(helpMenu, wxID_ANY, _L("Show &Configuration Folder"), _L("Show user configuration folder (datadir)"),
        [](wxCommandEvent&) { Slic3r::GUI::desktop_open_datadir_folder(); });
    append_menu_item(helpMenu, wxID_ANY, _L("Report an I&ssue"), wxString::Format(_L("Report an issue on %s"), SLIC3R_APP_NAME),
        [](wxCommandEvent&) { wxGetApp().open_browser_with_warning_dialog("https://github.com/prusa3d/slic3r/issues/new", nullptr, false); });
    if (wxGetApp().is_editor())
        append_menu_item(helpMenu, wxID_ANY, wxString::Format(_L("&About %s"), SLIC3R_APP_NAME), _L("Show about dialog"),
            [](wxCommandEvent&) { Slic3r::GUI::about(); });
    else
        append_menu_item(helpMenu, wxID_ANY, wxString::Format(_L("&About %s"), GCODEVIEWER_APP_NAME), _L("Show about dialog"),
            [](wxCommandEvent&) { Slic3r::GUI::about(); });
    append_menu_item(helpMenu, wxID_ANY, _L("Show Tip of the Day") 
#if 0//debug
        + "\tCtrl+Shift+T"
#endif
        ,_L("Opens Tip of the day notification in bottom right corner or shows another tip if already opened."),
        [](wxCommandEvent&) { wxGetApp().plater()->get_notification_manager()->push_hint_notification(false); });
    helpMenu->AppendSeparator();
    append_menu_item(helpMenu, wxID_ANY, _L("Keyboard Shortcuts") + sep + "&?", _L("Show the list of the keyboard shortcuts"),
        [](wxCommandEvent&) { wxGetApp().keyboard_shortcuts(); });
#if ENABLE_THUMBNAIL_GENERATOR_DEBUG
    helpMenu->AppendSeparator();
    append_menu_item(helpMenu, wxID_ANY, "DEBUG gcode thumbnails", "DEBUG ONLY - read the selected gcode file and generates png for the contained thumbnails",
        [](wxCommandEvent&) { wxGetApp().gcode_thumbnails_debug(); });
#endif // ENABLE_THUMBNAIL_GENERATOR_DEBUG
 
    return helpMenu;
}

References _L, about(), append_menu_item(), desktop_open_datadir_folder(), GCODEVIEWER_APP_NAME, and sep.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor(), and Slic3r::GUI::MainFrame::init_menubar_as_gcodeviewer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_html_page()

static wxString Slic3r::GUI::generate_html_page	(	const Config::SnapshotDB &	snapshot_db,
		const wxString &	on_snapshot
	)

static

{
    bool dark_mode = wxGetApp().dark_mode();
    wxString text = 
        "<html>"
        "<body bgcolor=\"" + get_color(wxGetApp().get_window_default_clr()/*wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW)*/) + "\" cellspacing=\"2\" cellpadding=\"0\" border=\"0\" link=\"#800000\">"
        "<font color=\"" + get_color(wxGetApp().get_label_clr_default()) + "\">";
    text += "<table style=\"width:100%\">";
    for (size_t i_row = 0; i_row < snapshot_db.snapshots().size(); ++ i_row) {
        const Config::Snapshot &snapshot = snapshot_db.snapshots()[snapshot_db.snapshots().size() - i_row - 1];
        text += generate_html_row(snapshot, i_row & 1, snapshot.id == on_snapshot, dark_mode);
    }
    text +=
        "</table>"
        "</font>"
        "</body>"
        "</html>";
    return text;
}

References generate_html_row(), get_color(), Slic3r::GUI::Config::Snapshot::id, and Slic3r::GUI::Config::SnapshotDB::snapshots().

Referenced by Slic3r::GUI::ConfigSnapshotDialog::ConfigSnapshotDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_html_row()

static wxString Slic3r::GUI::generate_html_row	(	const Config::Snapshot &	snapshot,
		bool	row_even,
		bool	snapshot_active,
		bool	dark_mode
	)

static

{    
    // Start by declaring a row with an alternating background color.
    wxString text = "<tr bgcolor=\"";
    text += snapshot_active ? 
            dark_mode ? "#208a20"  : "#B3FFCB" : 
            (row_even ? get_color(wxGetApp().get_window_default_clr()/*wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW)*/) : dark_mode ? "#656565" : "#D5D5D5" );
    text += "\">";
    text += "<td>";
    
    static const constexpr char *LOCALE_TIME_FMT = "%x %X";
    wxString datetime = wxDateTime(snapshot.time_captured).Format(LOCALE_TIME_FMT);
    
    // Format the row header.
    text += wxString("<font size=\"5\"><b>") + (snapshot_active ? _(L("Active")) + ": " : "") +
            datetime + ": " + format_reason(snapshot.reason);
    
    if (! snapshot.comment.empty())
        text += " (" + wxString::FromUTF8(snapshot.comment.data()) + ")";
    text += "</b></font><br>";
    // End of row header.
    text += _(L("PrusaSlicer version")) + ": " + snapshot.slic3r_version_captured.to_string() + "<br>";
    bool has_fff = ! snapshot.print.empty() || ! snapshot.filaments.empty();
    bool has_sla = ! snapshot.sla_print.empty() || ! snapshot.sla_material.empty();
    if (has_fff || ! has_sla) {
        text += _(L("print")) + ": " + snapshot.print + "<br>";
        text += _(L("filaments")) + ": " + snapshot.filaments.front() + "<br>";
    }
    if (has_sla) {
        text += _(L("SLA print")) + ": " + snapshot.sla_print + "<br>";
        text += _(L("SLA material")) + ": " + snapshot.sla_material + "<br>";
    }
    text += _(L("printer")) + ": " + (snapshot.physical_printer.empty() ? snapshot.printer : snapshot.physical_printer) + "<br>";
 
    bool compatible = true;
    for (const Config::Snapshot::VendorConfig &vc : snapshot.vendor_configs) {
        text += _(L("vendor")) + ": " + vc.name +", " + _(L("version")) + ": " + vc.version.config_version.to_string() + 
        ", " + _(L("min PrusaSlicer version")) + ": " + vc.version.min_slic3r_version.to_string();
        if (vc.version.max_slic3r_version != Semver::inf())
            text += ", " + _(L("max PrusaSlicer version")) + ": " + vc.version.max_slic3r_version.to_string();
        text += "<br>";
        for (const auto& model : vc.models_variants_installed) {
            text += _(L("model")) + ": " + model.first + ", " + _(L("variants")) + ": ";
            for (const std::string &variant : model.second) {
                if (&variant != &*model.second.begin())
                    text += ", ";
                text += variant;
            }
            text += "<br>";
        }
        if (! vc.version.is_current_slic3r_supported()) { compatible = false; }
    }
 
    if (! compatible) {
        text += "<p align=\"right\">" + format_wxstr(_L("Incompatible with this %s"), SLIC3R_APP_NAME) + "</p>";
    }
    else if (! snapshot_active)
        text += "<p align=\"right\"><a href=\"" + snapshot.id + "\">" + _L("Activate") + "</a></p>";
    text += "</td>";
  text += "</tr>";
    return text;
}

Referenced by generate_html_page().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_system_info_json()

static std::string Slic3r::GUI::generate_system_info_json ( )

static

{
    // Calculate hash of username so it is possible to identify duplicates.
    // The result is mod 10000 so most of the information is lost and it is
    // not possible to unhash the username. It is more than enough to help
    // identify duplicate entries.
    std::string unique_id = get_unique_id();
 
    // Get system language.
    std::string sys_language = "Unknown"; // important to init, see the __APPLE__ block.
    #ifndef __APPLE__
        // Following apparently does not work on macOS.
        const wxLanguage lang_system = wxLanguage(wxLocale::GetSystemLanguage());
        if (lang_system != wxLANGUAGE_UNKNOWN)
            sys_language = wxLocale::GetLanguageInfo(lang_system)->CanonicalName.ToUTF8().data();
    #else // __APPLE__
        CFLocaleRef cflocale = CFLocaleCopyCurrent();
        CFStringRef value = (CFStringRef)CFLocaleGetValue(cflocale, kCFLocaleLanguageCode);
        char temp[10] = "";
        CFStringGetCString(value, temp, 10, kCFStringEncodingUTF8);
        sys_language = temp;
        CFRelease(cflocale);
    #endif
    // Build a property tree with all the information.
    namespace pt = boost::property_tree;
 
    pt::ptree data_node;
    data_node.put("PrusaSlicerVersion", SLIC3R_VERSION);
    data_node.put("BuildID", SLIC3R_BUILD_ID);
    data_node.put("UniqueID", unique_id);
    data_node.put("Platform", platform_to_string(platform()));
    data_node.put("PlatformFlavor", platform_flavor_to_string(platform_flavor()));
    data_node.put("OSDescription", wxPlatformInfo::Get().GetOperatingSystemDescription().ToUTF8().data());
#ifdef __linux__
    std::string distro_id = wxGetLinuxDistributionInfo().Id.ToUTF8().data(); // uses lsb-release
    std::string distro_ver = wxGetLinuxDistributionInfo().Release.ToUTF8().data();
    if (distro_id.empty()) { // lsb-release probably not available
        std::map<std::string, std::string> dist_info = parse_lscpu_etc("cat /etc/*release", '=');
        distro_id = dist_info["ID"];
        distro_ver = dist_info["VERSION_ID"];
    }
    data_node.put("Linux_DistroID", distro_id);
    data_node.put("Linux_DistroVer", distro_ver);
    data_node.put("Linux_Wayland", wxGetEnv("WAYLAND_DISPLAY", nullptr));
#endif
    data_node.put("wxWidgets", wxVERSION_NUM_DOT_STRING);
#ifdef __WXGTK__
    data_node.put("GTK",
    #if defined(__WXGTK2__)
        2
    #elif defined(__WXGTK3__)
        3
    #elif defined(__WXGTK4__)
        4
    #elif defined(__WXGTK5__)
        5
    #else
        "Unknown"
    #endif
    );
#endif // __WXGTK__
    data_node.put("SystemLanguage", sys_language);
    data_node.put("TranslationLanguage: ", wxGetApp().app_config->get("translation_language"));
 
 
    pt::ptree hw_node;
    {
        hw_node.put("ArchName", wxPlatformInfo::Get().GetBitnessName());
        size_t num = std::round(Slic3r::total_physical_memory()/107374100.);
        hw_node.put("RAM_GiB", std::to_string(num / 10) + "." + std::to_string(num % 10));
    }
 
    // Now get some CPU info:
    pt::ptree cpu_node;
#ifdef _WIN32
    std::map<std::string, std::string> cpu_info = get_cpu_info_from_registry();
    cpu_node.put("Cores",  cpu_info["Cores"]);
    cpu_node.put("Model",  cpu_info["Model"]);
    cpu_node.put("Vendor", cpu_info["Vendor"]);
#elif __APPLE__
     std::map<std::string, std::string> sysctl = parse_lscpu_etc("sysctl -a", ':');
     cpu_node.put("Cores",  sysctl["hw.ncpu"]);
     cpu_node.put("Model",  sysctl["machdep.cpu.brand_string"]);
     cpu_node.put("Vendor", sysctl["machdep.cpu.vendor"]);
#else // linux/BSD
    std::map<std::string, std::string> lscpu = parse_lscpu_etc("cat /proc/cpuinfo", ':');
    if (auto ncpu_it = lscpu.find("processor"); ncpu_it != lscpu.end()) {
        std::string& ncpu = ncpu_it->second;
        if (int num=0; std::from_chars(ncpu.data(), ncpu.data() + ncpu.size(), num).ec != std::errc::invalid_argument)
            ncpu = std::to_string(num + 1);
    }
    cpu_node.put("Cores",  lscpu["processor"]);
    cpu_node.put("Model",  lscpu["model name"]);
    cpu_node.put("Vendor", lscpu["vendor_id"]);
#endif
    hw_node.add_child("CPU", cpu_node);
 
    pt::ptree monitors_node;
    for (int i=0; i<int(wxDisplay::GetCount()); ++i) {
        wxDisplay display(i);
        pt::ptree monitor_node; // Create an unnamed node containing the value
        monitor_node.put("width", display.GetGeometry().GetWidth());
        monitor_node.put("height", display.GetGeometry().GetHeight());
 
        // Only get the scaling on Win, it is not reliable on other platforms.
        #if defined(_WIN32) && wxCHECK_VERSION(3, 1, 2)
            double scaling = display.GetPPI().GetWidth() / 96.;
            std::stringstream ss;
            ss << std::setprecision(3) << scaling;
            monitor_node.put("scaling", ss.str() );
        #endif
        monitors_node.push_back(std::make_pair("", monitor_node));
    }
    hw_node.add_child("Monitors", monitors_node);
    data_node.add_child("Hardware", hw_node);
 
#ifdef _WIN32
    {
        pt::ptree blacklisted_node;
        std::vector<std::wstring> blacklisted_libraries;
        BlacklistedLibraryCheck::get_instance().get_blacklisted(blacklisted_libraries);
        for (const std::wstring& wstr : blacklisted_libraries) {
            std::string utf8 = boost::nowide::narrow(wstr);
            if (size_t last_bs_pos = utf8.find_last_of("\\"); last_bs_pos < utf8.size() - 1) {
                // Remove anything before last backslash so we don't send the path to the DLL.
                utf8.erase(0, last_bs_pos + 1);
            }
            pt::ptree node; // Create an unnamed node containing the value
            node.put("", utf8);
            blacklisted_node.push_back(std::make_pair("", node)); // Add this node to the list.
        }
        if (! blacklisted_libraries.empty())
            data_node.add_child("Blacklisted libraries", blacklisted_node);
    }
#endif // _WIN32
 
    pt::ptree opengl_node;
    opengl_node.put("Version", OpenGLManager::get_gl_info().get_version_string());
    opengl_node.put("GLSLVersion", OpenGLManager::get_gl_info().get_glsl_version_string());
    opengl_node.put("Vendor", OpenGLManager::get_gl_info().get_vendor());
    opengl_node.put("Renderer", OpenGLManager::get_gl_info().get_renderer());
    // Generate list of OpenGL extensions:
#if ENABLE_GL_CORE_PROFILE
    std::vector<std::string> extensions_list = OpenGLManager::get_gl_info().get_extensions_list();
#else
    std::string extensions_str = gl_get_string_safe(GL_EXTENSIONS, "");
    std::vector<std::string> extensions_list;
    boost::split(extensions_list, extensions_str, boost::is_any_of(" "), boost::token_compress_off);
#endif // ENABLE_GL_CORE_PROFILE
    std::sort(extensions_list.begin(), extensions_list.end());
    pt::ptree extensions_node;
    for (const std::string& s : extensions_list) {
        if (s.empty())
            continue;
        pt::ptree ext_node; // Create an unnamed node containing the value
        ext_node.put("", s);
        extensions_node.push_back(std::make_pair("", ext_node)); // Add this node to the list.
    }
    opengl_node.add_child("Extensions", extensions_node);
    data_node.add_child("OpenGL", opengl_node);
 
    pt::ptree root;
    root.add_child("data", data_node);
 
    // Now go through all the values and trim leading/trailing whitespace.
    // Some CPU names etc apparently have trailing spaces...
    std::function<void(pt::ptree&)> remove_whitespace;
    remove_whitespace = [&remove_whitespace](pt::ptree& t) -> void
    {
        if (t.empty()) // Trim whitespace
            boost::algorithm::trim(t.data());
        else
            for (auto it = t.begin(); it != t.end(); ++it)
                remove_whitespace(it->second);
    };
    remove_whitespace(root);
 
    // Serialize the tree into JSON and return it.
    std::stringstream ss;
    pt::write_json(ss, root);
    return ss.str();
}

References Slic3r::GUI::OpenGLManager::get_gl_info(), Slic3r::GUI::OpenGLManager::GLInfo::get_glsl_version_string(), Slic3r::GUI::OpenGLManager::GLInfo::get_renderer(), get_unique_id(), Slic3r::GUI::OpenGLManager::GLInfo::get_vendor(), Slic3r::GUI::OpenGLManager::GLInfo::get_version_string(), gl_get_string_safe(), boost::nowide::narrow(), parse_lscpu_etc(), Slic3r::platform(), Slic3r::platform_flavor(), Slic3r::platform_flavor_to_string(), Slic3r::platform_to_string(), Slic3r::total_physical_memory(), and void().

Here is the call graph for this function:

◆ generate_thumbnail_from_model()

static void Slic3r::GUI::generate_thumbnail_from_model ( const std::string & filename )

static

{
    if (!boost::algorithm::iends_with(filename, ".stl") &&
        !boost::algorithm::iends_with(filename, ".obj")) {
        BOOST_LOG_TRIVIAL(error) << "Found invalid file type in generate_thumbnail_from_model() [" << filename << "]";
        return;
    }
 
    Model model;
    try {
        model = Model::read_from_file(filename);
    }
    catch (std::exception&) {
        BOOST_LOG_TRIVIAL(error) << "Error loading model from " << filename << " in generate_thumbnail_from_model()";
        return;
    }
 
    assert(model.objects.size() == 1);
    assert(model.objects[0]->volumes.size() == 1);
    assert(model.objects[0]->instances.size() == 1);
 
    model.objects[0]->center_around_origin(false);
    model.objects[0]->ensure_on_bed(false);
 
    model.center_instances_around_point(to_2d(wxGetApp().plater()->build_volume().bounding_volume().center()));
 
    GLVolumeCollection volumes;
    volumes.volumes.push_back(new GLVolume());
    GLVolume* volume = volumes.volumes.back();
    volume->model.init_from(model.mesh());
    volume->set_instance_transformation(model.objects[0]->instances[0]->get_transformation());
    volume->set_volume_transformation(model.objects[0]->volumes[0]->get_transformation());
 
    ThumbnailData thumbnail_data;
    const ThumbnailsParams thumbnail_params = { {}, false, false, false, true };
    wxGetApp().plater()->canvas3D()->render_thumbnail(thumbnail_data, 256, 256, thumbnail_params, volumes, Camera::EType::Perspective);
 
    if (thumbnail_data.width == 0 || thumbnail_data.height == 0)
        return;
 
    wxImage image(thumbnail_data.width, thumbnail_data.height);
    image.InitAlpha();
 
    for (unsigned int r = 0; r < thumbnail_data.height; ++r) {
        unsigned int rr = (thumbnail_data.height - 1 - r) * thumbnail_data.width;
        for (unsigned int c = 0; c < thumbnail_data.width; ++c) {
            unsigned char* px = (unsigned char*)thumbnail_data.pixels.data() + 4 * (rr + c);
            image.SetRGB((int)c, (int)r, px[0], px[1], px[2]);
            image.SetAlpha((int)c, (int)r, px[3]);
        }
    }
 
    fs::path out_path = fs::path(filename);
    out_path.replace_extension("png");
    image.SaveFile(from_u8(out_path.string()), wxBITMAP_TYPE_PNG);
}

References Slic3r::Model::center_instances_around_point(), error, from_u8(), Slic3r::ThumbnailData::height, Slic3r::Model::mesh(), Slic3r::Model::objects, Slic3r::GUI::Camera::Perspective, Slic3r::ThumbnailData::pixels, plater(), Slic3r::Model::read_from_file(), Slic3r::to_2d(), Slic3r::GLVolumeCollection::volumes, and Slic3r::ThumbnailData::width.

Here is the call graph for this function:

◆ generic_exception_handle()

static void Slic3r::GUI::generic_exception_handle ( )

static

{
    // Note: Some wxWidgets APIs use wxLogError() to report errors, eg. wxImage
    // - see https://docs.wxwidgets.org/3.1/classwx_image.html#aa249e657259fe6518d68a5208b9043d0
    //
    // wxLogError typically goes around exception handling and display an error dialog some time
    // after an error is logged even if exception handling and OnExceptionInMainLoop() take place.
    // This is why we use wxLogError() here as well instead of a custom dialog, because it accumulates
    // errors if multiple have been collected and displays just one error message for all of them.
    // Otherwise we would get multiple error messages for one missing png, for example.
    //
    // If a custom error message window (or some other solution) were to be used, it would be necessary
    // to turn off wxLogError() usage in wx APIs, most notably in wxImage
    // - see https://docs.wxwidgets.org/trunk/classwx_image.html#aa32e5d3507cc0f8c3330135bc0befc6a
 
    try {
        throw;
    } catch (const std::bad_alloc& ex) {
        // bad_alloc in main thread is most likely fatal. Report immediately to the user (wxLogError would be delayed)
        // and terminate the app so it is at least certain to happen now.
        wxString errmsg = wxString::Format(_L("%s has encountered an error. It was likely caused by running out of memory. "
                              "If you are sure you have enough RAM on your system, this may also be a bug and we would "
                              "be glad if you reported it.\n\nThe application will now terminate."), SLIC3R_APP_NAME);
        wxMessageBox(errmsg + "\n\n" + wxString(ex.what()), _L("Fatal error"), wxOK | wxICON_ERROR);
        BOOST_LOG_TRIVIAL(error) << boost::format("std::bad_alloc exception: %1%") % ex.what();
        std::terminate();
    } catch (const boost::io::bad_format_string& ex) {
        wxString errmsg = _L("PrusaSlicer has encountered a localization error. "
                             "Please report to PrusaSlicer team, what language was active and in which scenario "
                             "this issue happened. Thank you.\n\nThe application will now terminate.");
        wxMessageBox(errmsg + "\n\n" + wxString(ex.what()), _L("Critical error"), wxOK | wxICON_ERROR);
        BOOST_LOG_TRIVIAL(error) << boost::format("Uncaught exception: %1%") % ex.what();
        std::terminate();
        throw;
    } catch (const std::exception& ex) {
        wxLogError(format_wxstr(_L("Internal error: %1%"), ex.what()));
        BOOST_LOG_TRIVIAL(error) << boost::format("Uncaught exception: %1%") % ex.what();
        throw;
    }
}

References _L, error, and format_wxstr().

Referenced by Slic3r::GUI::GUI_App::OnExceptionInMainLoop(), and Slic3r::GUI::GUI_App::OnInit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_app_config()

AppConfig * Slic3r::GUI::get_app_config ( )

{
    return wxGetApp().app_config;
}

Referenced by Slic3r::GUI::DownloaderUtils::Worker::Worker(), Slic3r::GUI::PreferencesDialog::accept(), Slic3r::GUI::PreferencesDialog::build(), Slic3r::GUI::GUI_App::config_wizard_startup(), Slic3r::GUI::PreferencesDialog::create_icon_size_slider(), Slic3r::GUI::PreferencesDialog::create_settings_mode_widget(), Slic3r::GUI::ogStaticText::FocusText(), Slic3r::GUI::OptionsGroup::get_url(), Slic3r::DoubleSlider::Control::is_lower_thumb_editable(), Slic3r::GUI::GUI_App::on_init_inner(), Slic3r::GUI::Plater::priv::on_slicing_update(), Slic3r::GUI::OG_CustomCtrl::OnMotion(), Slic3r::GUI::GCodeViewer::refresh_render_paths(), Slic3r::GUI::OG_CustomCtrl::CtrlLine::render(), Slic3r::GUI::PreferencesDialog::revert(), Slic3r::GUI::Plater::priv::save_project_if_dirty(), Slic3r::GUI::DownloaderUtils::Worker::set_path_name(), Slic3r::GUI::ogStaticText::SetPathEnd(), Slic3r::GUI::PreferencesDialog::show(), Slic3r::Moonraker::upload(), Slic3r::OctoPrint::upload(), Slic3r::OctoPrint::upload_inner_with_host(), and Slic3r::PrusaLink::upload_inner_with_host().

Here is the caller graph for this function:

◆ get_arrange_params()

arrangement::ArrangeParams Slic3r::GUI::get_arrange_params ( Plater * p )

{
    const GLCanvas3D::ArrangeSettings &settings =
        p->canvas3D()->get_arrange_settings();
 
    arrangement::ArrangeParams params;
    params.allow_rotations  = settings.enable_rotation;
    params.min_obj_distance = scaled(settings.distance);
    params.min_bed_distance = scaled(settings.distance_from_bed);
 
    arrangement::Pivots pivot = arrangement::Pivots::Center;
 
    int pivot_max = static_cast<int>(arrangement::Pivots::TopRight);
    if (settings.alignment < 0) {
        pivot = arrangement::Pivots::Center;
    } else if (settings.alignment > pivot_max) {
        // means it should be random
        std::random_device rd{};
        std::mt19937 rng(rd());
        std::uniform_int_distribution<std::mt19937::result_type> dist(0, pivot_max);
        pivot = static_cast<arrangement::Pivots>(dist(rng));
    } else {
        pivot = static_cast<arrangement::Pivots>(settings.alignment);
    }
 
    params.alignment = pivot;
 
    return params;
}

References Slic3r::arrangement::ArrangeParams::alignment, Slic3r::GUI::GLCanvas3D::ArrangeSettings::alignment, Slic3r::arrangement::ArrangeParams::allow_rotations, Slic3r::GUI::Plater::canvas3D(), Slic3r::arrangement::Center, Slic3r::Geometry::dist(), Slic3r::GUI::GLCanvas3D::ArrangeSettings::distance, Slic3r::GUI::GLCanvas3D::ArrangeSettings::distance_from_bed, Slic3r::GUI::GLCanvas3D::ArrangeSettings::enable_rotation, Slic3r::GUI::GLCanvas3D::get_arrange_settings(), Slic3r::arrangement::ArrangeParams::min_bed_distance, Slic3r::arrangement::ArrangeParams::min_obj_distance, Slic3r::scaled(), and Slic3r::arrangement::TopRight.

Referenced by Slic3r::GUI::ArrangeJob::process(), and Slic3r::GUI::FillBedJob::process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_arrange_poly() [1/3]

template<>

arrangement::ArrangePolygon Slic3r::GUI::get_arrange_poly	(	ModelInstance *	inst,
		const Plater *	plater
	)

{
    auto ap = get_arrange_poly(PtrWrapper{inst}, plater);
 
    auto obj_id = inst->get_object()->id();
    if (plater->printer_technology() == ptSLA) {
        const SLAPrintObject *po =
            plater->sla_print().get_print_object_by_model_object_id(obj_id);
 
        if (po) {
            update_arrangepoly_slaprint(ap, *po, *inst);
        }
    } else {
        const PrintObject *po =
            plater->fff_print().get_print_object_by_model_object_id(obj_id);
 
        if (po) {
            ap.inflation = brim_offset(*po, *inst);
        }
    }
 
    return ap;
}

References brim_offset(), Slic3r::GUI::Plater::fff_print(), get_arrange_poly(), Slic3r::ModelInstance::get_object(), Slic3r::Print::get_print_object_by_model_object_id(), Slic3r::SLAPrint::get_print_object_by_model_object_id(), Slic3r::ObjectBase::id(), plater(), Slic3r::GUI::Plater::printer_technology(), Slic3r::ptSLA, Slic3r::GUI::Plater::sla_print(), and update_arrangepoly_slaprint().

Referenced by get_arrange_poly(), Slic3r::GUI::ArrangeJob::get_arrange_poly_(), get_wipe_tower_arrangepoly(), Slic3r::GUI::FillBedJob::prepare(), and Slic3r::GUI::ArrangeJob::prepare_selected().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_arrange_poly() [2/3]

template<>

arrangement::ArrangePolygon Slic3r::GUI::get_arrange_poly	(	ModelInstance *	inst,
		const Plater *	plater
	)

{
    auto ap = get_arrange_poly(PtrWrapper{inst}, plater);
 
    auto obj_id = inst->get_object()->id();
    if (plater->printer_technology() == ptSLA) {
        const SLAPrintObject *po =
            plater->sla_print().get_print_object_by_model_object_id(obj_id);
 
        if (po) {
            update_arrangepoly_slaprint(ap, *po, *inst);
        }
    } else {
        const PrintObject *po =
            plater->fff_print().get_print_object_by_model_object_id(obj_id);
 
        if (po) {
            ap.inflation = brim_offset(*po, *inst);
        }
    }
 
    return ap;
}

References brim_offset(), Slic3r::GUI::Plater::fff_print(), get_arrange_poly(), Slic3r::ModelInstance::get_object(), Slic3r::Print::get_print_object_by_model_object_id(), Slic3r::SLAPrint::get_print_object_by_model_object_id(), Slic3r::ObjectBase::id(), plater(), Slic3r::GUI::Plater::printer_technology(), Slic3r::ptSLA, Slic3r::GUI::Plater::sla_print(), and update_arrangepoly_slaprint().

Referenced by get_arrange_poly(), Slic3r::GUI::ArrangeJob::get_arrange_poly_(), get_wipe_tower_arrangepoly(), Slic3r::GUI::FillBedJob::prepare(), and Slic3r::GUI::ArrangeJob::prepare_selected().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_arrange_poly() [3/3]

template<class T >

arrangement::ArrangePolygon Slic3r::GUI::get_arrange_poly	(	T	obj,
		const Plater *	plater
	)

{
    using ArrangePolygon = arrangement::ArrangePolygon;
 
    ArrangePolygon ap = obj.get_arrange_polygon();
    ap.setter         = [obj, plater](const ArrangePolygon &p) {
        if (p.is_arranged()) {
            Vec2d t = p.translation.cast<double>();
            t.x() += p.bed_idx * bed_stride(plater);
            T{obj}.apply_arrange_result(t, p.rotation);
        }
    };
 
    return ap;
}

References bed_stride(), plater(), and Slic3r::arrangement::ArrangePolygon::setter.

Here is the call graph for this function:

◆ get_bitmap_size()

static wxSize Slic3r::GUI::get_bitmap_size	(	const wxBitmapBundle *	bmp,
		wxWindow *	parent
	)

static

{
#ifdef __WIN32__
    return bmp->GetBitmapFor(parent).GetSize();
#else
    return bmp->GetDefaultSize();
#endif
}

Referenced by Slic3r::GUI::OG_CustomCtrl::OG_CustomCtrl(), Slic3r::GUI::OG_CustomCtrl::CtrlLine::draw_act_bmps(), Slic3r::GUI::OG_CustomCtrl::CtrlLine::draw_blinking_bmp(), Slic3r::GUI::OG_CustomCtrl::CtrlLine::draw_mode_bmp(), Slic3r::GUI::OG_CustomCtrl::CtrlLine::msw_rescale(), and Slic3r::GUI::OG_CustomCtrl::msw_rescale().

Here is the caller graph for this function:

◆ get_color() [1/2]

static ColorRGBA Slic3r::GUI::get_color ( Axis axis )

static

{
    return AXES_COLOR[axis];
}

References AXES_COLOR.

◆ get_color() [2/2]

static std::string Slic3r::GUI::get_color ( wxColour colour )

static

{
    return encode_color(ColorRGB(colour.Red(), colour.Green(), colour.Blue()));
};

References Slic3r::encode_color().

Referenced by generate_html_page(), generate_html_row(), Slic3r::GUI::Selection::render_sidebar_position_hints(), Slic3r::GUI::Selection::render_sidebar_rotation_hints(), and Slic3r::GUI::Selection::render_sidebar_scale_hints().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_cursor_height()

static float Slic3r::GUI::get_cursor_height ( )

static

{
    float ret = 16.0f;
#ifdef _WIN32
    // see: https://forums.codeguru.com/showthread.php?449040-get-the-system-current-cursor-size
    // this code is not perfect because it returns a maximum height equal to 31 even if the cursor bitmap shown on screen is bigger
    // but at least it gives the same result as wxWidgets in the settings tabs
    ICONINFO ii;
    if (::GetIconInfo((HICON)GetCursor(), &ii) != 0) {
        BITMAP bitmap;
        ::GetObject(ii.hbmMask, sizeof(BITMAP), &bitmap);
        const int width = bitmap.bmWidth;
        const int height = (ii.hbmColor == nullptr) ? bitmap.bmHeight / 2 : bitmap.bmHeight;
        HDC dc = ::CreateCompatibleDC(nullptr);
        if (dc != nullptr) {
            if (::SelectObject(dc, ii.hbmMask) != nullptr) {
                for (int i = 0; i < width; ++i) {
                    for (int j = 0; j < height; ++j) {
                        if (::GetPixel(dc, i, j) != RGB(255, 255, 255)) {
                            if (ret < float(j))
                                ret = float(j);
                        }
                    }
                }
                ::DeleteDC(dc);
            }
        }
        ::DeleteObject(ii.hbmColor);
        ::DeleteObject(ii.hbmMask);
    }
#endif //  _WIN32
    return ret;
}

Referenced by Slic3r::GUI::GLCanvas3D::Tooltip::set_text().

Here is the caller graph for this function:

◆ get_default_font()

wxFont Slic3r::GUI::get_default_font ( const wxWindow * window )

inline

56{ return get_default_font_for_dpi(window, get_dpi_for_window(window)); }

Slic3r::GUI::get_default_font_for_dpi

wxFont get_default_font_for_dpi(const wxWindow *window, int dpi)

Definition GUI_Utils.cpp:131

References get_default_font_for_dpi(), and get_dpi_for_window().

Referenced by Slic3r::GUI::AboutDialog::AboutDialog(), Slic3r::GUI::ConfigSnapshotDialog::ConfigSnapshotDialog(), Slic3r::GUI::CopyrightsDialog::CopyrightsDialog(), Slic3r::GUI::SysInfoDialog::SysInfoDialog(), Slic3r::GUI::SplashScreen::init_constant_text(), Slic3r::GUI::ConfigSnapshotDialog::on_dpi_changed(), and Slic3r::GUI::SysInfoDialog::on_dpi_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_default_font_for_dpi()

wxFont Slic3r::GUI::get_default_font_for_dpi	(	const wxWindow *	window,
		int	dpi
	)

{
#ifdef _WIN32
    // First try to load the font with the Windows 10 specific way.
    struct SystemParametersInfoForDpi_t { typedef BOOL (WINAPI *FN)(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni, UINT dpi); };
    static auto SystemParametersInfoForDpi_fn = winapi_get_function<SystemParametersInfoForDpi_t>(L"User32.dll", "SystemParametersInfoForDpi");
    if (SystemParametersInfoForDpi_fn != nullptr) {
        NONCLIENTMETRICS nm;
        memset(&nm, 0, sizeof(NONCLIENTMETRICS));
        nm.cbSize = sizeof(NONCLIENTMETRICS);
        if (SystemParametersInfoForDpi_fn(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &nm, 0, dpi))
            return wxFont(wxNativeFontInfo(nm.lfMessageFont, window));
    }
    // Then try to guesstimate the font DPI scaling on Windows 8.
    // Let's hope that the font returned by the SystemParametersInfo(), which is used by wxWidgets internally, makes sense.
    int dpi_primary = get_dpi_for_window(nullptr);
    if (dpi_primary != dpi) {
        // Rescale the font.
        return wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT).Scaled(float(dpi) / float(dpi_primary));
    }
#endif
    return wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
}

References get_dpi_for_window(), and L.

Referenced by Slic3r::GUI::DPIAware< P >::DPIAware(), get_default_font(), and Slic3r::GUI::PageMaterials::set_compatible_printers_html_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_dir()

static fs::path Slic3r::GUI::get_dir ( bool sys_dir )

static

{
    return fs::absolute(fs::path(sys_dir ? sys_shapes_dir() : custom_shapes_dir())).make_preferred();
}

References Slic3r::custom_shapes_dir(), and Slic3r::sys_shapes_dir().

Referenced by Slic3r::GUI::GalleryDialog::change_thumbnail(), Slic3r::GUI::GalleryDialog::del_custom_shapes(), get_dir_path(), Slic3r::GUI::GalleryDialog::load_files(), and Slic3r::GUI::GalleryDialog::load_label_icon_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_dir_path()

static std::string Slic3r::GUI::get_dir_path ( bool sys_dir )

static

{
    fs::path dir = get_dir(sys_dir);
#ifdef __WXMSW__
    return dir.string() + "\\";
#else
    return dir.string() + "/";
#endif
}

References get_dir().

Referenced by Slic3r::GUI::GalleryDialog::get_input_files(), and Slic3r::GUI::GalleryDialog::load_label_icon_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_dpi_for_window()

int Slic3r::GUI::get_dpi_for_window ( const wxWindow * window )

{
#ifdef _WIN32
    enum MONITOR_DPI_TYPE_ {
        // This enum is inlined here to avoid build-time dependency
        MDT_EFFECTIVE_DPI_ = 0,
        MDT_ANGULAR_DPI_ = 1,
        MDT_RAW_DPI_ = 2,
        MDT_DEFAULT_ = MDT_EFFECTIVE_DPI_,
    };
 
    // Need strong types for winapi_get_function() to work
    struct GetDpiForWindow_t { typedef HRESULT (WINAPI *FN)(HWND hwnd); };
    struct GetDpiForMonitor_t { typedef HRESULT (WINAPI *FN)(HMONITOR hmonitor, MONITOR_DPI_TYPE_ dpiType, UINT *dpiX, UINT *dpiY); };
 
    static auto GetDpiForWindow_fn = winapi_get_function<GetDpiForWindow_t>(L"User32.dll", "GetDpiForWindow");
    static auto GetDpiForMonitor_fn = winapi_get_function<GetDpiForMonitor_t>(L"Shcore.dll", "GetDpiForMonitor");
 
  // Desktop Window is the window of the primary monitor.
  const HWND hwnd = (window == nullptr) ? ::GetDesktopWindow() : window->GetHandle();
 
    if (GetDpiForWindow_fn != nullptr) {
        // We're on Windows 10, we have per-screen DPI settings
        return GetDpiForWindow_fn(hwnd);
    } else if (GetDpiForMonitor_fn != nullptr) {
        // We're on Windows 8.1, we have per-system DPI
        // Note: MonitorFromWindow() is available on all Windows.
 
        const HMONITOR monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
        UINT dpiX;
        UINT dpiY;
        return GetDpiForMonitor_fn(monitor, MDT_EFFECTIVE_DPI_, &dpiX, &dpiY) == S_OK ? dpiX : DPI_DEFAULT;
    } else {
        // We're on Windows earlier than 8.1, use DC
 
        const HDC hdc = GetDC(hwnd);
        if (hdc == NULL) { return DPI_DEFAULT; }
        return GetDeviceCaps(hdc, LOGPIXELSX);
    }
#elif defined __linux__
    // TODO
    return DPI_DEFAULT;
#elif defined __APPLE__
    // TODO
    return DPI_DEFAULT;
#else // freebsd and others
    // TODO
    return DPI_DEFAULT;
#endif
}

References DPI_DEFAULT, and L.

Referenced by Slic3r::GUI::DPIAware< P >::DPIAware(), add_msg_content(), get_default_font(), get_default_font_for_dpi(), Slic3r::GUI::Emboss::StyleManager::init_style_images(), Slic3r::GUI::SplashScreen::scale_font(), Slic3r::GUI::PageMaterials::set_compatible_printers_html_window(), Slic3r::DoubleSlider::Control::Ruler::update_dpi(), and Slic3r::GUI::MainFrame::update_layout().

Here is the caller graph for this function:

◆ get_dragging_half_size()

static double Slic3r::GUI::get_dragging_half_size ( double size )

static

{
    return get_half_size(size) * 1.25;
}

References get_half_size().

Referenced by Slic3r::GUI::GLGizmoBase::Grabber::render(), and Slic3r::GUI::GLGizmoCut3D::render_cut_plane_grabbers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_extruder_id_for_volumes()

static std::vector< int > Slic3r::GUI::get_extruder_id_for_volumes ( const ModelObject & model_object )

static

{
    std::vector<int> extruders_idx;
    extruders_idx.reserve(model_object.volumes.size());
    for (const ModelVolume *model_volume : model_object.volumes) {
        if (!model_volume->is_model_part())
            continue;
 
        extruders_idx.emplace_back(model_volume->extruder_id());
    }
 
    return extruders_idx;
}

References Slic3r::ModelObject::volumes.

Referenced by Slic3r::GUI::GLGizmoMmuSegmentation::data_changed(), and Slic3r::GUI::GLGizmoMmuSegmentation::init_model_triangle_selectors().

Here is the caller graph for this function:

◆ get_extruders_colors()

static std::vector< ColorRGBA > Slic3r::GUI::get_extruders_colors ( )

static

{
    std::vector<std::string> colors = Slic3r::GUI::wxGetApp().plater()->get_extruder_colors_from_plater_config();
    std::vector<ColorRGBA> ret;
    decode_colors(colors, ret);
    return ret;
}

References Slic3r::decode_colors().

Referenced by Slic3r::GUI::GLGizmoMmuSegmentation::data_changed(), Slic3r::GUI::GLGizmoMmuSegmentation::init_extruders_data(), and Slic3r::GUI::GLGizmoMmuSegmentation::update_from_model_object().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_extruders_names()

static std::vector< std::string > Slic3r::GUI::get_extruders_names ( )

static

{
    size_t                   extruders_count = wxGetApp().extruders_edited_cnt();
    std::vector<std::string> extruders_out;
    extruders_out.reserve(extruders_count);
    for (size_t extruder_idx = 1; extruder_idx <= extruders_count; ++extruder_idx)
        extruders_out.emplace_back(_u8L("Extruder") + " " + std::to_string(extruder_idx));
 
    return extruders_out;
}

References _u8L, and extruders_count().

Referenced by Slic3r::GUI::GLGizmoMmuSegmentation::init_extruders_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_feature_offset()

static Vec3d Slic3r::GUI::get_feature_offset ( const Measure::SurfaceFeature & feature )

static

{
    Vec3d ret;
    switch (feature.get_type())
    {
    case Measure::SurfaceFeatureType::Circle:
    {
        const auto [center, radius, normal] = feature.get_circle();
        ret = center;
        break;
    }
    case Measure::SurfaceFeatureType::Edge:
    {
        std::optional<Vec3d> p = feature.get_extra_point();
        assert(p.has_value());
        ret = *p;
        break;
    }
    case Measure::SurfaceFeatureType::Point:
    {
        ret = feature.get_point();
        break;
    }
    default: { assert(false); }
    }
     
    return ret;
}

References Slic3r::Measure::Circle, Slic3r::Measure::Edge, Slic3r::Measure::SurfaceFeature::get_circle(), Slic3r::Measure::SurfaceFeature::get_extra_point(), Slic3r::Measure::SurfaceFeature::get_point(), Slic3r::Measure::SurfaceFeature::get_type(), and Slic3r::Measure::Point.

Referenced by Slic3r::GUI::GLGizmoMeasure::on_mouse(), and Slic3r::GUI::GLGizmoMeasure::on_render().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_first_added_preset()

static std::string Slic3r::GUI::get_first_added_preset	(	const std::map< std::string, std::string > &	old_data,
		const std::map< std::string, std::string > &	new_data
	)

static

{
    std::set<std::string> diff = get_new_added_presets(old_data, new_data);
    if (diff.empty())
        return std::string();
    return *diff.begin();
}

References Slic3r::diff(), and get_new_added_presets().

Referenced by Slic3r::GUI::ConfigWizard::priv::apply_config().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_first_hovered_gl_volume()

GLVolume * Slic3r::GUI::get_first_hovered_gl_volume ( const GLCanvas3D & canvas )

                                                                {
    int hovered_id_signed = canvas.get_first_hover_volume_idx();
    if (hovered_id_signed < 0)
        return nullptr;
 
    size_t hovered_id = static_cast<size_t>(hovered_id_signed);
    const GLVolumePtrs &volumes = canvas.get_volumes().volumes;
    if (hovered_id >= volumes.size())
        return nullptr;
 
    return volumes[hovered_id];
}

References Slic3r::GUI::GLCanvas3D::get_first_hover_volume_idx(), get_first_hovered_gl_volume(), Slic3r::GUI::GLCanvas3D::get_volumes(), and Slic3r::GLVolumeCollection::volumes.

Referenced by Slic3r::GUI::GLGizmoEmboss::create_volume(), and get_first_hovered_gl_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_full_label()

static wxString Slic3r::GUI::get_full_label	(	std::string	opt_key,
		const DynamicPrintConfig &	config
	)

static

{
    opt_key = get_pure_opt_key(opt_key);
 
    if (config.option(opt_key)->is_nil())
        return _L("N/A");
 
    const ConfigOptionDef* opt = config.def()->get(opt_key);
    return opt->full_label.empty() ? opt->label : opt->full_label;
}

References _L, Slic3r::DynamicPrintConfig::def(), Slic3r::ConfigOptionDef::full_label, Slic3r::ConfigDef::get(), get_pure_opt_key(), Slic3r::ConfigOption::is_nil(), Slic3r::ConfigOptionDef::label, and Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::DiffPresetDialog::update_tree().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_full_settings_hierarchy()

static void Slic3r::GUI::get_full_settings_hierarchy	(	FullSettingsHierarchy &	settings_menu,
		const bool	is_part
	)

static

{
    auto options = SettingsFactory::get_options(is_part);
 
    const int extruders_cnt = extruders_count();
 
    DynamicPrintConfig config;
    for (auto& option : options)
    {
        auto const opt = config.def()->get(option);
        auto category = opt->category;
        if (is_improper_category(category, extruders_cnt, !is_part))
            continue;
 
        const std::string& label = !opt->full_label.empty() ? opt->full_label : opt->label;
        std::pair<std::string, std::string> option_label(option, label);
        std::vector< std::pair<std::string, std::string> > new_category;
        auto& cat_opt_label = settings_menu.find(category) == settings_menu.end() ? new_category : settings_menu.at(category);
        cat_opt_label.push_back(option_label);
        if (cat_opt_label.size() == 1)
            settings_menu[category] = cat_opt_label;
    }
}

References Slic3r::ConfigOptionDef::category, Slic3r::DynamicPrintConfig::def(), extruders_count(), Slic3r::ConfigDef::get(), Slic3r::GUI::SettingsFactory::get_options(), and is_improper_category().

Referenced by create_settings_popupmenu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_grabber_mean_size()

static double Slic3r::GUI::get_grabber_mean_size ( const BoundingBoxf3 & bb )

static

{
    return (bb.size().x() + bb.size().y() + bb.size().z()) / 30.;
}

References Slic3r::BoundingBox3Base< PointType >::size().

Referenced by Slic3r::GUI::GLGizmoCut3D::init_picking_models(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane_grabbers(), and Slic3r::GUI::GLGizmoCut3D::update_raycasters_for_picking_transform().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_half_size()

static double Slic3r::GUI::get_half_size ( double size )

static

{
    return std::max(size * 0.35, 0.05);
}

Referenced by get_dragging_half_size(), Slic3r::GUI::GLGizmoBase::Grabber::get_dragging_half_size(), Slic3r::GUI::GLGizmoBase::Grabber::render(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane_grabbers(), and Slic3r::GUI::GLGizmoCut3D::update_raycasters_for_picking_transform().

Here is the caller graph for this function:

◆ get_icon_name()

static std::string Slic3r::GUI::get_icon_name	(	Preset::Type	type,
		PrinterTechnology	pt
	)

static

                                                                      {
    return pt == ptSLA && type == Preset::TYPE_PRINTER ? "sla_printer" : type_icon_names.at(type);
}

References Slic3r::ptSLA, type_icon_names, and Slic3r::Preset::TYPE_PRINTER.

Referenced by Slic3r::GUI::DiffModel::AddPreset().

Here is the caller graph for this function:

◆ get_id_from_opt_key()

static size_t Slic3r::GUI::get_id_from_opt_key ( std::string opt_key )

static

{
    int pos = opt_key.find("#");
    if (pos > 0) {
        boost::erase_head(opt_key, pos + 1);
        return static_cast<size_t>(atoi(opt_key.c_str()));
    }
    return 0;
}

Referenced by get_string_value().

Here is the caller graph for this function:

◆ get_index_type()

static GLenum Slic3r::GUI::get_index_type ( const GLModel::Geometry & data )

static

{
    switch (data.index_type)
    {
    default:
    case GLModel::Geometry::EIndexType::UINT:   { return GL_UNSIGNED_INT; }
    case GLModel::Geometry::EIndexType::USHORT: { return GL_UNSIGNED_SHORT; }
    case GLModel::Geometry::EIndexType::UBYTE:  { return GL_UNSIGNED_BYTE; }
    }
}

References Slic3r::GUI::GLModel::Geometry::UBYTE, Slic3r::GUI::GLModel::Geometry::UINT, and Slic3r::GUI::GLModel::Geometry::USHORT.

Referenced by Slic3r::GUI::GLModel::render(), and Slic3r::GUI::GLModel::render_instanced().

Here is the caller graph for this function:

◆ get_info_klipper_string()

static wxString Slic3r::GUI::get_info_klipper_string ( )

static

{
    return _L("Emitting machine limits to G-code is not supported with Klipper G-code flavor.\n"
              "The option was switched to \"Use for time estimate\".");
}

References _L, and get_info_klipper_string().

Referenced by Slic3r::GUI::TabPrinter::build_fff(), Slic3r::GUI::TabPrinter::build_kinematics_page(), and get_info_klipper_string().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_item_name()

static wxString Slic3r::GUI::get_item_name	(	const std::string &	name,
		const bool	is_text_volume
	)

static

{
    return (is_text_volume ? _L("Text") + " - " : "") + from_u8(name);
}

References _L, and from_u8().

Referenced by Slic3r::GUI::ObjectList::add_object_to_list(), Slic3r::GUI::ObjectList::add_volumes_to_object_in_list(), Slic3r::GUI::ObjectList::del_subobject_from_object(), Slic3r::GUI::ObjectList::update_name_in_list(), and Slic3r::GUI::ObjectList::update_name_in_model().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_main_info()

std::string Slic3r::GUI::get_main_info ( bool format_as_html )

{
    std::stringstream out;
 
    std::string b_start  = format_as_html ? "<b>"  : "";
    std::string b_end    = format_as_html ? "</b>" : "";
    std::string line_end = format_as_html ? "<br>" : "\n";
 
    if (!format_as_html)
        out << b_start << (wxGetApp().is_editor() ? SLIC3R_APP_NAME : GCODEVIEWER_APP_NAME) << b_end << line_end;
    out << b_start << "Version:   "             << b_end << SLIC3R_VERSION << line_end;
    
    std::string build_id = SLIC3R_BUILD_ID;
    if (! wxGetApp().is_editor())
        boost::replace_first(build_id, SLIC3R_APP_NAME, GCODEVIEWER_APP_NAME);
    out << b_start << "Build:     " << b_end << build_id << line_end;
 
    out << line_end;
    out << b_start << "Operating System:    "   << b_end << wxPlatformInfo::Get().GetOperatingSystemFamilyName() << line_end;
    out << b_start << "System Architecture: "   << b_end << wxPlatformInfo::Get().GetBitnessName() << line_end;
    out << b_start << 
#if defined _WIN32
        "Windows Version:     "
#else
        // Hopefully some kind of unix / linux.
        "System Version:      "
#endif
        << b_end << wxPlatformInfo::Get().GetOperatingSystemDescription() << line_end;
    out << b_start << "Total RAM size [MB]: "  << b_end << Slic3r::format_memsize_MB(Slic3r::total_physical_memory());
 
    return out.str();
}

References Slic3r::format_memsize_MB(), GCODEVIEWER_APP_NAME, and Slic3r::total_physical_memory().

Referenced by Slic3r::GUI::SysInfoDialog::SysInfoDialog(), and Slic3r::GUI::SysInfoDialog::onCopyToClipboard().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_max_layer_height()

static double Slic3r::GUI::get_max_layer_height ( const int extruder_idx )

static

{
    const DynamicPrintConfig& config = wxGetApp().preset_bundle->printers.get_edited_preset().config;
    int extruder_idx_zero_based = std::max(0, extruder_idx - 1);
    double max_layer_height = config.opt_float("max_layer_height", extruder_idx_zero_based);
 
    // In case max_layer_height is set to zero, it should default to 75 % of nozzle diameter:
    if (max_layer_height < EPSILON)
        max_layer_height = 0.75 * config.opt_float("nozzle_diameter", extruder_idx_zero_based);
 
    return max_layer_height;
}

References EPSILON, and Slic3r::ConfigBase::opt_float().

Referenced by Slic3r::GUI::ObjectList::edit_layer_range().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_mem_info()

std::string Slic3r::GUI::get_mem_info ( bool format_as_html )

{
    std::stringstream out;
 
    std::string b_start  = format_as_html ? "<b>"  : "";
    std::string b_end    = format_as_html ? "</b>" : "";
    std::string line_end = format_as_html ? "<br>" : "\n";
 
    std::string mem_info_str = log_memory_info(true);
    std::istringstream mem_info(mem_info_str);
    std::string value;
    while (std::getline(mem_info, value, ':')) {
        out << b_start << (value+": ") << b_end;
        std::getline(mem_info, value, ';');
        out << value << line_end;
    }
 
    const Slic3r::UndoRedo::Stack &stack = wxGetApp().plater()->undo_redo_stack_main();
    out << b_start << "RAM size reserved for the Undo / Redo stack: "  << b_end << Slic3r::format_memsize_MB(stack.get_memory_limit()) << line_end;
    out << b_start << "RAM size occupied by the Undo / Redo stack: "  << b_end << Slic3r::format_memsize_MB(stack.memsize()) << line_end << line_end;
 
    return out.str();
}

References Slic3r::format_memsize_MB(), Slic3r::UndoRedo::Stack::get_memory_limit(), Slic3r::log_memory_info(), and Slic3r::UndoRedo::Stack::memsize().

Referenced by Slic3r::GUI::SysInfoDialog::SysInfoDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_min_layer_height()

static double Slic3r::GUI::get_min_layer_height ( const int extruder_idx )

static

{
    const DynamicPrintConfig& config = wxGetApp().preset_bundle->printers.get_edited_preset().config;
    return config.opt_float("min_layer_height", std::max(0, extruder_idx - 1));
}

References Slic3r::ConfigBase::opt_float().

Referenced by Slic3r::GUI::ObjectList::add_layer_range_after_current(), Slic3r::GUI::ObjectList::can_add_new_range_after_current(), and Slic3r::GUI::ObjectList::edit_layer_range().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_model_instance() [1/3]

ModelInstance * Slic3r::GUI::get_model_instance	(	const GLVolume &	gl_volume,
		const Model &	model
	)

                                                                                 {
    return get_model_instance(gl_volume, model.objects);
}

References get_model_instance(), and Slic3r::Model::objects.

Referenced by calc_surface_offset(), get_model_instance(), get_model_instance(), get_model_instance(), and on_mouse_surface_drag().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_model_instance() [2/3]

ModelInstance * Slic3r::GUI::get_model_instance	(	const GLVolume &	gl_volume,
		const ModelObject &	object
	)

                                                                                        {
    if (gl_volume.instance_idx() < 0)
        return nullptr;
    size_t instance_idx = static_cast<size_t>(gl_volume.instance_idx());
    if (instance_idx >= object.instances.size())
        return nullptr;
    return object.instances[instance_idx];
}

References get_model_instance(), and Slic3r::GLVolume::instance_idx().

Here is the call graph for this function:

◆ get_model_instance() [3/3]

ModelInstance * Slic3r::GUI::get_model_instance	(	const GLVolume &	gl_volume,
		const ModelObjectPtrs &	objects
	)

                                                                                             {
    if (gl_volume.instance_idx() < 0)
        return nullptr;
    ModelObject *object = get_model_object(gl_volume, objects);
    return get_model_instance(gl_volume, *object);
}

References get_model_instance(), get_model_object(), and Slic3r::GLVolume::instance_idx().

Here is the call graph for this function:

◆ get_model_object() [1/2]

ModelObject * Slic3r::GUI::get_model_object	(	const GLVolume &	gl_volume,
		const Model &	model
	)

                                                                             {
    return get_model_object(gl_volume, model.objects);
}

References get_model_object(), and Slic3r::Model::objects.

Referenced by get_model_instance(), get_model_object(), get_model_object(), and on_mouse_surface_drag().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_model_object() [2/2]

ModelObject * Slic3r::GUI::get_model_object	(	const GLVolume &	gl_volume,
		const ModelObjectPtrs &	objects
	)

                                                                                         {
    if (gl_volume.object_idx() < 0)
        return nullptr;
    size_t objext_idx = static_cast<size_t>(gl_volume.object_idx());
    if (objext_idx >= objects.size())
        return nullptr;
    return objects[objext_idx];
}

References get_model_object(), and Slic3r::GLVolume::object_idx().

Here is the call graph for this function:

◆ get_model_volume() [1/4]

const ModelVolume * Slic3r::GUI::get_model_volume	(	const GLVolume &	v,
		const Model &	model
	)

{
    const ModelVolume * ret = nullptr;
 
    if (v.object_idx() < (int)model.objects.size()) {
        const ModelObject *obj = model.objects[v.object_idx()];
        if (v.volume_idx() < (int)obj->volumes.size())
            ret = obj->volumes[v.volume_idx()];
    }
 
    return ret;
}

References get_model_volume(), Slic3r::GLVolume::object_idx(), Slic3r::Model::objects, Slic3r::GLVolume::volume_idx(), and Slic3r::ModelObject::volumes.

Referenced by priv::apply_camera_dir(), calc_surface_offset(), create_meshes(), priv::find_closest_volume(), get_model_volume(), get_model_volume(), get_model_volume(), get_model_volume(), get_selected_volume(), Slic3r::GUI::GLGizmoEmboss::on_mouse(), Slic3r::GUI::GLGizmoEmboss::on_mouse_change_selection(), on_mouse_surface_drag(), Slic3r::GUI::GLGizmoEmboss::on_render(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoEmboss::set_volume_by_selection(), and world_matrix_fixed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_model_volume() [2/4]

ModelVolume * Slic3r::GUI::get_model_volume	(	const GLVolume &	v,
		const ModelObject &	object
	)

                                                                            {
    if (v.volume_idx() < 0)
        return nullptr;
 
    size_t volume_idx = static_cast<size_t>(v.volume_idx());
    if (volume_idx >= object.volumes.size())
        return nullptr;
 
    return object.volumes[volume_idx];
}

References get_model_volume(), and Slic3r::GLVolume::volume_idx().

Here is the call graph for this function:

◆ get_model_volume() [3/4]

ModelVolume * Slic3r::GUI::get_model_volume	(	const GLVolume &	v,
		const ModelObjectPtrs &	objects
	)

{
    if (v.object_idx() < 0)
        return nullptr;
    size_t objext_idx = static_cast<size_t>(v.object_idx());
    if (objext_idx >= objects.size())
        return nullptr;
    if (objects[objext_idx] == nullptr)
        return nullptr;
    return get_model_volume(v, *objects[objext_idx]);
}

References get_model_volume(), and Slic3r::GLVolume::object_idx().

Here is the call graph for this function:

◆ get_model_volume() [4/4]

const ModelVolume * Slic3r::GUI::get_model_volume	(	const ObjectID &	volume_id,
		const ModelObjectPtrs &	objects
	)

{
    for (const ModelObject *obj : objects)
        for (const ModelVolume *vol : obj->volumes)
            if (vol->id() == volume_id)
                return vol;
    return nullptr;
}

References get_model_volume().

Here is the call graph for this function:

◆ get_new_added_presets()

static std::set< std::string > Slic3r::GUI::get_new_added_presets	(	const std::map< std::string, std::string > &	old_data,
		const std::map< std::string, std::string > &	new_data
	)

static

{
    auto get_aliases = [](const std::map<std::string, std::string>& data) {
        std::set<std::string> old_aliases;
        for (auto item : data) {
            const std::string& name = item.first;
            size_t pos = name.find("@");
            old_aliases.emplace(pos == std::string::npos ? name : name.substr(0, pos-1));
        }
        return old_aliases;
    };
 
    std::set<std::string> old_aliases = get_aliases(old_data);
    std::set<std::string> new_aliases = get_aliases(new_data);
    std::set<std::string> diff;
    std::set_difference(new_aliases.begin(), new_aliases.end(), old_aliases.begin(), old_aliases.end(), std::inserter(diff, diff.begin()));
 
    return diff;
}

References Slic3r::diff(), and Slic3r::GUI::ConfigWizard::name().

Referenced by get_first_added_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_option_label()

static std::string Slic3r::GUI::get_option_label ( BedShape::Parameter param )

static

{
    switch (param) {
    case BedShape::Parameter::RectSize  : return L("Size");
    case BedShape::Parameter::RectOrigin: return L("Origin");
    case BedShape::Parameter::Diameter  : return L("Diameter");
    default:                              assert(false); return {};
    }
}

References Slic3r::GUI::BedShape::Diameter, L, Slic3r::GUI::BedShape::RectOrigin, and Slic3r::GUI::BedShape::RectSize.

Referenced by Slic3r::GUI::BedShape::append_option_line(), and Slic3r::GUI::BedShape::get_full_name_with_params().

Here is the caller graph for this function:

◆ get_preset_collection()

static PresetCollection * Slic3r::GUI::get_preset_collection	(	Preset::Type	type,
		PresetBundle *	preset_bundle = `nullptr`
	)

static

                                                                                                       {
    if (!preset_bundle)
        preset_bundle = wxGetApp().preset_bundle;
    return  type == Preset::Type::TYPE_PRINT        ? &preset_bundle->prints :
            type == Preset::Type::TYPE_SLA_PRINT    ? &preset_bundle->sla_prints :
            type == Preset::Type::TYPE_FILAMENT     ? &preset_bundle->filaments :
            type == Preset::Type::TYPE_SLA_MATERIAL ? &preset_bundle->sla_materials :
            type == Preset::Type::TYPE_PRINTER      ? &preset_bundle->printers :
            nullptr;
}

References Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, Slic3r::Preset::TYPE_SLA_MATERIAL, and Slic3r::Preset::TYPE_SLA_PRINT.

Referenced by Slic3r::GUI::DiffPresetDialog::create_buttons(), Slic3r::GUI::DiffPresetDialog::create_presets_sizer(), Slic3r::GUI::DiffPresetDialog::update_compatibility(), and Slic3r::GUI::DiffPresetDialog::update_tree().

Here is the caller graph for this function:

◆ get_preset_name_with_suffix()

static wxString Slic3r::GUI::get_preset_name_with_suffix ( const Preset & preset )

static

{
    return from_u8(preset.name + Preset::suffix_modified());
}

References from_u8(), Slic3r::Preset::name, and Slic3r::Preset::suffix_modified().

Referenced by Slic3r::GUI::PresetComboBox::update().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_primitive_mode()

static GLenum Slic3r::GUI::get_primitive_mode ( const GLModel::Geometry::Format & format )

static

{
    switch (format.type)
    {
    case GLModel::Geometry::EPrimitiveType::Points:        { return GL_POINTS; }
    default:
    case GLModel::Geometry::EPrimitiveType::Triangles:     { return GL_TRIANGLES; }
    case GLModel::Geometry::EPrimitiveType::TriangleStrip: { return GL_TRIANGLE_STRIP; }
    case GLModel::Geometry::EPrimitiveType::TriangleFan:   { return GL_TRIANGLE_FAN; }
    case GLModel::Geometry::EPrimitiveType::Lines:         { return GL_LINES; }
    case GLModel::Geometry::EPrimitiveType::LineStrip:     { return GL_LINE_STRIP; }
    case GLModel::Geometry::EPrimitiveType::LineLoop:      { return GL_LINE_LOOP; }
    }
}

References format(), GL_LINE_LOOP, GL_TRIANGLE_FAN, GL_TRIANGLE_STRIP, GL_TRIANGLES, Slic3r::GUI::GLModel::Geometry::LineLoop, Slic3r::GUI::GLModel::Geometry::Lines, Slic3r::GUI::GLModel::Geometry::LineStrip, Slic3r::GUI::GLModel::Geometry::Points, Slic3r::GUI::GLModel::Geometry::TriangleFan, Slic3r::GUI::GLModel::Geometry::Triangles, and Slic3r::GUI::GLModel::Geometry::TriangleStrip.

Referenced by Slic3r::GUI::GLModel::render(), and Slic3r::GUI::GLModel::render_instanced().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_pure_opt_key()

static std::string Slic3r::GUI::get_pure_opt_key ( std::string opt_key )

static

{
    const int pos = opt_key.find("#");
    if (pos > 0)
        boost::erase_tail(opt_key, opt_key.size() - pos);
    return opt_key;
}    

Referenced by get_full_label(), get_string_value(), Slic3r::GUI::DiffViewCtrl::options(), and Slic3r::GUI::DiffViewCtrl::selected_options().

Here is the caller graph for this function:

◆ get_readers_wildcard()

std::string Slic3r::GUI::get_readers_wildcard ( )

{
    std::string ret;
 
    auto registry = registered_sla_archives();
 
    for (const ArchiveEntry &entry : registry) {
        if (!entry.rdfactoryfn)
            continue;
 
        ret += into_u8(_(entry.desc));
        ret += " (";
        std::vector<std::string> extensions = get_extensions(entry);
        for (const std::string &ext : extensions) {
            ret += "*.";
            ret += ext;
            ret += ", ";
        }
        // remove last ", "
        if (!extensions.empty()) {
            ret.pop_back();
            ret.pop_back();
        }
 
        ret += ")|";
 
        for (std::string ext : extensions) {
            boost::algorithm::to_lower(ext);
            ret += "*.";
            ret += ext;
            ret += ";";
 
            boost::algorithm::to_upper(ext);
            ret += "*.";
            ret += ext;
            ret += ";";
        }
 
        // remove last ';'
        if (!extensions.empty())
            ret.pop_back();
 
        ret += "|";
    }
 
    if (ret.back() == '|')
        ret.pop_back();
 
    return ret;
}

References _, Slic3r::get_extensions(), into_u8(), and Slic3r::registered_sla_archives().

Referenced by Slic3r::GUI::SLAImportDialog::SLAImportDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_root_idx()

static int Slic3r::GUI::get_root_idx	(	ObjectDataViewModelNode *	parent_node,
		const ItemType	root_type
	)

static

{
    // because of istance_root and layers_root are at the end of the list, so
    // start locking from the end
    for (int root_idx = parent_node->GetChildCount() - 1; root_idx >= 0; root_idx--)
    {
        // if there is SettingsItem or VolumeItem, then RootItems don't exist in current ObjectItem 
        if (parent_node->GetNthChild(root_idx)->GetType() & (itSettings | itVolume))
            break;
        if (parent_node->GetNthChild(root_idx)->GetType() & root_type)
            return root_idx;
    }
 
    return -1;
}

References Slic3r::GUI::ObjectDataViewModelNode::GetChildCount(), Slic3r::GUI::ObjectDataViewModelNode::GetNthChild(), Slic3r::GUI::ObjectDataViewModelNode::GetType(), itSettings, and itVolume.

Referenced by Slic3r::GUI::ObjectDataViewModel::AddLayersChild(), Slic3r::GUI::ObjectDataViewModel::AddVolumeChild(), append_root_node(), and Slic3r::GUI::ObjectDataViewModel::DeleteLastInstance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_selected_gl_volume() [1/2]

GLVolume * Slic3r::GUI::get_selected_gl_volume ( const GLCanvas3D & canvas )

                                                           {
    const GLVolume *gl_volume = get_selected_gl_volume(canvas.get_selection());
    if (gl_volume == nullptr)
        return nullptr;
 
    const GLVolumePtrs &gl_volumes = canvas.get_volumes().volumes;
    for (GLVolume *v : gl_volumes)
        if (v->composite_id == gl_volume->composite_id)
            return v;
    return nullptr;
}

References Slic3r::GLVolume::composite_id, get_selected_gl_volume(), Slic3r::GUI::GLCanvas3D::get_selection(), Slic3r::GUI::GLCanvas3D::get_volumes(), and Slic3r::GLVolumeCollection::volumes.

Referenced by calc_surface_offset(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), get_selected_gl_volume(), get_selected_volume(), Slic3r::GUI::GLGizmoEmboss::on_mouse_for_translate(), on_mouse_surface_drag(), Slic3r::GUI::GLGizmoEmboss::on_stop_dragging(), Slic3r::GUI::GLGizmoEmboss::set_volume_by_selection(), and world_matrix_fixed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_selected_gl_volume() [2/2]

const GLVolume * Slic3r::GUI::get_selected_gl_volume ( const Selection & selection )

{
    int object_idx = selection.get_object_idx();
    // is more object selected?
    if (object_idx == -1)
        return nullptr;
 
    const auto &list = selection.get_volume_idxs();
    // is more volumes selected?
    if (list.size() != 1)
        return nullptr;
 
    unsigned int volume_idx = *list.begin();
    return selection.get_volume(volume_idx);
}

References Slic3r::GUI::Selection::get_object_idx(), Slic3r::GUI::Selection::get_volume(), and Slic3r::GUI::Selection::get_volume_idxs().

Here is the call graph for this function:

◆ get_selected_volume()

ModelVolume * Slic3r::GUI::get_selected_volume ( const Selection & selection )

{
    const GLVolume *gl_volume = get_selected_gl_volume(selection);
    if (gl_volume == nullptr)
        return nullptr;
    const ModelObjectPtrs &objects = selection.get_model()->objects;
    return get_model_volume(*gl_volume, objects);
}

References Slic3r::GUI::Selection::get_model(), get_model_volume(), get_selected_gl_volume(), and Slic3r::Model::objects.

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_advanced().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_selection() [1/2]

static const Selection & Slic3r::GUI::get_selection ( )

static

{
    return plater()->canvas3D()->get_selection();
}

References Slic3r::GUI::Plater::canvas3D(), Slic3r::GUI::GLCanvas3D::get_selection(), and plater().

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_settings(), Slic3r::GUI::DiffPresetDialog::create_presets_sizer(), Slic3r::GUI::DiffPresetDialog::get_left_preset_name(), Slic3r::GUI::DiffPresetDialog::get_right_preset_name(), Slic3r::GUI::ObjectList::load_shape_object_from_gallery(), and Slic3r::GUI::DiffPresetDialog::update_tree().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_selection() [2/2]

static std::string Slic3r::GUI::get_selection ( PresetComboBox * preset_combo )

static

{
    return into_u8(preset_combo->GetString(preset_combo->GetSelection()));
}

References into_u8().

Here is the call graph for this function:

◆ get_skirt_offset()

coord_t Slic3r::GUI::get_skirt_offset ( const Plater * plater )

                                               {
    float skirt_inset = 0.f;
    // Try to subtract the skirt from the bed shape so we don't arrange outside of it.
    if (plater->printer_technology() == ptFFF && plater->fff_print().has_skirt()) {
        const auto& print = plater->fff_print();
        if (!print.objects().empty()) {
            skirt_inset = print.config().skirts.value * print.skirt_flow().width() +
                          print.config().skirt_distance.value;
        }
    }
 
    return scaled(skirt_inset);
}

References Slic3r::Print::config(), Slic3r::GUI::Plater::fff_print(), Slic3r::Print::has_skirt(), plater(), Slic3r::GUI::Plater::printer_technology(), Slic3r::ptFFF, and Slic3r::scaled().

Referenced by Slic3r::GUI::ArrangeJob::process(), and Slic3r::GUI::FillBedJob::process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_string_value()

static wxString Slic3r::GUI::get_string_value	(	std::string	opt_key,
		const DynamicPrintConfig &	config
	)

static

{
    size_t opt_idx = get_id_from_opt_key(opt_key);
    opt_key = get_pure_opt_key(opt_key);
 
    if (config.option(opt_key)->is_nil())
        return _L("N/A");
 
    wxString out;
 
    const ConfigOptionDef* opt = config.def()->get(opt_key);
    bool is_nullable = opt->nullable;
 
    switch (opt->type) {
    case coInt:
        return from_u8((boost::format("%1%") % config.opt_int(opt_key)).str());
    case coInts: {
        if (is_nullable) {
            auto values = config.opt<ConfigOptionIntsNullable>(opt_key);
            if (opt_idx < values->size())
                return from_u8((boost::format("%1%") % values->get_at(opt_idx)).str());
        }
        else {
            auto values = config.opt<ConfigOptionInts>(opt_key);
            if (opt_idx < values->size())
                return from_u8((boost::format("%1%") % values->get_at(opt_idx)).str());
        }
        return _L("Undef");
    }
    case coBool:
        return config.opt_bool(opt_key) ? "true" : "false";
    case coBools: {
        if (is_nullable) {
            auto values = config.opt<ConfigOptionBoolsNullable>(opt_key);
            if (opt_idx < values->size())
                return values->get_at(opt_idx) ? "true" : "false";
        }
        else {
            auto values = config.opt<ConfigOptionBools>(opt_key);
            if (opt_idx < values->size())
                return values->get_at(opt_idx) ? "true" : "false";
        }
        return _L("Undef");
    }
    case coPercent:
        return from_u8((boost::format("%1%%%") % int(config.optptr(opt_key)->getFloat())).str());
    case coPercents: {
        if (is_nullable) {
            auto values = config.opt<ConfigOptionPercentsNullable>(opt_key);
            if (opt_idx < values->size())
                return from_u8((boost::format("%1%%%") % values->get_at(opt_idx)).str());
        }
        else {
            auto values = config.opt<ConfigOptionPercents>(opt_key);
            if (opt_idx < values->size())
                return from_u8((boost::format("%1%%%") % values->get_at(opt_idx)).str());
        }
        return _L("Undef");
    }
    case coFloat:
        return double_to_string(config.opt_float(opt_key));
    case coFloats: {
        if (is_nullable) {
            auto values = config.opt<ConfigOptionFloatsNullable>(opt_key);
            if (opt_idx < values->size())
                return double_to_string(values->get_at(opt_idx));
        }
        else {
            auto values = config.opt<ConfigOptionFloats>(opt_key);
            if (opt_idx < values->size())
                return double_to_string(values->get_at(opt_idx));
        }
        return _L("Undef");
    }
    case coString:
        return from_u8(config.opt_string(opt_key));
    case coStrings: {
        const ConfigOptionStrings* strings = config.opt<ConfigOptionStrings>(opt_key);
        if (strings) {
            if (opt_key == "compatible_printers" || opt_key == "compatible_prints") {
                if (strings->empty())
                    return _L("All"); 
                for (size_t id = 0; id < strings->size(); id++)
                    out += from_u8(strings->get_at(id)) + "\n";
                out.RemoveLast(1);
                return out;
            }
            if (opt_key == "gcode_substitutions") {
                if (!strings->empty())
                    for (size_t id = 0; id < strings->size(); id += 4)
                        out +=  from_u8(strings->get_at(id))     + ";\t" + 
                                from_u8(strings->get_at(id + 1)) + ";\t" + 
                                from_u8(strings->get_at(id + 2)) + ";\t" +
                                from_u8(strings->get_at(id + 3)) + ";\n";
                return out;
            }
            if (!strings->empty() && opt_idx < strings->values.size())
                return from_u8(strings->get_at(opt_idx));
        }
        break;
        }
    case coFloatOrPercent: {
        const ConfigOptionFloatOrPercent* opt = config.opt<ConfigOptionFloatOrPercent>(opt_key);
        if (opt)
            out = double_to_string(opt->value) + (opt->percent ? "%" : "");
        return out;
    }
    case coFloatsOrPercents: {
        const ConfigOptionFloatsOrPercents* opt = config.opt<ConfigOptionFloatsOrPercents>(opt_key);
        if (opt) {
            const auto val = opt->get_at(opt_idx);
            out = double_to_string(val.value) + (val.percent ? "%" : "");
        }
        return out;
    }
    case coEnum: {
        auto opt = config.option_def(opt_key)->enum_def->enum_to_label(config.option(opt_key)->getInt());
        return opt.has_value() ? _(from_u8(*opt)) : _L("Undef");
    }
    case coPoints: {
        if (opt_key == "bed_shape") {
            BedShape shape(*config.option<ConfigOptionPoints>(opt_key));
            return shape.get_full_name_with_params();
        }
        if (opt_key == "thumbnails")
            return get_thumbnails_string(config.option<ConfigOptionPoints>(opt_key)->values);
 
        Vec2d val = config.opt<ConfigOptionPoints>(opt_key)->get_at(opt_idx);
        return from_u8((boost::format("[%1%]") % ConfigOptionPoint(val).serialize()).str());
    }
    default:
        break;
    }
    return out;
}

References _, _L, Slic3r::coBool, Slic3r::coBools, Slic3r::coEnum, Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coFloats, Slic3r::coFloatsOrPercents, Slic3r::coInt, Slic3r::coInts, Slic3r::coPercent, Slic3r::coPercents, Slic3r::coPoints, Slic3r::coString, Slic3r::coStrings, Slic3r::DynamicPrintConfig::def(), double_to_string(), Slic3r::ConfigOptionVector< T >::empty(), Slic3r::ConfigOptionDef::enum_def, from_u8(), Slic3r::ConfigDef::get(), Slic3r::ConfigOptionBoolsTempl< NULLABLE >::get_at(), Slic3r::ConfigOptionVector< T >::get_at(), Slic3r::GUI::BedShape::get_full_name_with_params(), get_id_from_opt_key(), get_pure_opt_key(), get_thumbnails_string(), Slic3r::ConfigOption::getFloat(), Slic3r::ConfigOption::getInt(), Slic3r::ConfigOption::is_nil(), Slic3r::ConfigOptionDef::nullable, Slic3r::ConfigBase::opt(), Slic3r::ConfigBase::opt_bool(), Slic3r::ConfigBase::opt_float(), Slic3r::ConfigBase::opt_int(), Slic3r::ConfigBase::opt_string(), Slic3r::ConfigBase::option(), Slic3r::ConfigBase::option_def(), Slic3r::DynamicConfig::optptr(), Slic3r::ConfigOptionFloatOrPercent::percent, serialize(), Slic3r::ConfigOptionVector< T >::size(), Slic3r::ConfigOptionDef::type, Slic3r::ConfigOptionSingle< T >::value, and Slic3r::ConfigOptionVector< T >::values.

Referenced by Slic3r::GUI::DiffPresetDialog::update_tree(), and Slic3r::GUI::UnsavedChangesDialog::update_tree().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_thumbnails_string()

wxString Slic3r::GUI::get_thumbnails_string ( const std::vector< Vec2d > & values )

{
    wxString ret_str;
  for (size_t i = 0; i < values.size(); ++ i) {
    const Vec2d& el = values[i];
    ret_str += wxString::Format((i == 0) ? "%ix%i" : ", %ix%i", int(el[0]), int(el[1]));
  }
    return ret_str;
}

Referenced by Slic3r::GUI::TextCtrl::BUILD(), Slic3r::GUI::ConfigOptionsGroup::get_config_value(), get_string_value(), and Slic3r::GUI::Field::get_value_by_opt_type().

Here is the caller graph for this function:

◆ get_unique_id()

static std::string Slic3r::GUI::get_unique_id ( )

static

{
    std::vector<unsigned char> unique;
 
#ifdef _WIN32
    // On Windows, get the MAC address of a network adaptor (preferably Ethernet
    // or IEEE 802.11 wireless
 
    DWORD dwBufLen = sizeof(IP_ADAPTER_INFO);
    PIP_ADAPTER_INFO AdapterInfo = (PIP_ADAPTER_INFO)malloc(dwBufLen);
 
    if (GetAdaptersInfo(AdapterInfo, &dwBufLen) == ERROR_BUFFER_OVERFLOW) {
        free(AdapterInfo);
        AdapterInfo = (IP_ADAPTER_INFO*)malloc(dwBufLen);
    }    
    if (GetAdaptersInfo(AdapterInfo, &dwBufLen) == NO_ERROR) {
        const IP_ADAPTER_INFO* pAdapterInfo = AdapterInfo;
        std::vector<std::vector<unsigned char>> macs;
        bool ethernet_seen = false;
        while (pAdapterInfo) {
            macs.emplace_back();
            for (unsigned char i = 0; i < pAdapterInfo->AddressLength; ++i)
                macs.back().emplace_back(pAdapterInfo->Address[i]);
            // Prefer Ethernet and IEEE 802.11 wireless
            if (! ethernet_seen) {
                if ((pAdapterInfo->Type == MIB_IF_TYPE_ETHERNET && (ethernet_seen = true))
                 ||  pAdapterInfo->Type == IF_TYPE_IEEE80211)
                    std::swap(macs.front(), macs.back());
            }
            pAdapterInfo = pAdapterInfo->Next;
        }
        if (! macs.empty())
            unique = macs.front();
    }
    free(AdapterInfo);
#elif __APPLE__
    constexpr int buf_size = 100;
    char buf[buf_size] = "";
    memset(&buf, 0, sizeof(buf));
    io_registry_entry_t ioRegistryRoot = IORegistryEntryFromPath(kIOMasterPortDefault, "IOService:/");
    if (ioRegistryRoot != MACH_PORT_NULL) {
        CFStringRef uuidCf = (CFStringRef)IORegistryEntryCreateCFProperty(ioRegistryRoot, CFSTR(kIOPlatformUUIDKey), kCFAllocatorDefault, 0);
        IOObjectRelease(ioRegistryRoot);
        CFStringGetCString(uuidCf, buf, buf_size, kCFStringEncodingMacRoman);
        CFRelease(uuidCf);
    }
    // Now convert the string to std::vector<unsigned char>.
    for (char* c = buf; *c != 0; ++c)
        unique.emplace_back((unsigned char)(*c));
#else // Linux/BSD
    constexpr size_t max_len = 100;
    char cline[max_len] = "";
    FILE* fp = popen("cat /etc/machine-id", "r");
    if (fp != NULL) {
        // Maybe the only way to silence -Wunused-result on gcc...
        // cline is simply not modified on failure, who cares.
        [[maybe_unused]]auto dummy = fgets(cline, max_len, fp);
        pclose(fp);
    }
    // Now convert the string to std::vector<unsigned char>.
    for (char* c = cline; *c != 0; ++c)
        unique.emplace_back((unsigned char)(*c));
#endif
 
    // In case that we did not manage to get the unique info, just return an empty
    // string, so it is easily detectable and not masked by the hashing.
    if (unique.empty())
        return "";
 
    // We should have a unique vector<unsigned char>. Append a long prime to be
    // absolutely safe against unhashing.
    uint64_t prime = 1171432692373;
    size_t beg = unique.size();
    unique.resize(beg + 8);
    memcpy(&unique[beg], &prime, 8);
 
    // Compute an MD5 hash and convert to std::string.
    using boost::uuids::detail::md5;
    md5 hash;
    md5::digest_type digest;
    hash.process_bytes(unique.data(), unique.size());
    hash.get_digest(digest);
    const unsigned char* charDigest = reinterpret_cast<const unsigned char*>(&digest);
    std::string result;
    boost::algorithm::hex(charDigest, charDigest + sizeof(md5::digest_type), std::back_inserter(result));
    return result;
}

References free(), and malloc().

Referenced by generate_system_info_json().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_volume()

static ModelVolume * Slic3r::GUI::get_volume	(	const ObjectID &	id,
		const Selection &	selection
	)

static

                                                                               {
    const Selection::IndicesList &volume_ids = selection.get_volume_idxs();
    const ModelObjectPtrs &model_objects     = selection.get_model()->objects;
    for (auto volume_id : volume_ids) {
        const GLVolume *selected_volume = selection.get_volume(volume_id);
        const GLVolume::CompositeID &cid = selected_volume->composite_id;
        ModelObject *obj    = model_objects[cid.object_id];
        ModelVolume *volume = obj->volumes[cid.volume_id];
        if (id == volume->id()) return volume;
    }
    return nullptr;
}

References Slic3r::GLVolume::composite_id, Slic3r::GUI::Selection::get_model(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::GLVolume::CompositeID::object_id, Slic3r::Model::objects, Slic3r::GLVolume::CompositeID::volume_id, and Slic3r::ModelObject::volumes.

Referenced by Slic3r::GUI::GLGizmoSimplify::apply_simplify(), priv::check(), create_volumes_name(), Slic3r::GUI::GLGizmoSimplify::process(), and priv::update_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_volume_ids()

static std::set< ObjectID > Slic3r::GUI::get_volume_ids ( const Selection & selection )

static

{
    const Selection::IndicesList &volume_ids = selection.get_volume_idxs();
    const ModelObjectPtrs &model_objects     = selection.get_model()->objects;
    std::set<ObjectID> result;
    for (auto volume_id : volume_ids) {
        const GLVolume *selected_volume = selection.get_volume(volume_id);
        assert(selected_volume != nullptr);
 
        const GLVolume::CompositeID &cid = selected_volume->composite_id;
 
        assert(cid.object_id >= 0);
        assert(model_objects.size() > static_cast<size_t>(cid.object_id));
 
        const ModelObject *obj    = model_objects[cid.object_id];
        const ModelVolume *volume = obj->volumes[cid.volume_id];
        const ObjectID &   id     = volume->id();
        
        // prevent selection of volume without inidces
        if (volume->mesh().its.indices.empty()) continue;
 
        assert(result.find(id) == result.end());
        result.insert(id);
    }
    return result;
}

References Slic3r::GLVolume::composite_id, Slic3r::GUI::Selection::get_model(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::GLVolume::CompositeID::object_id, Slic3r::Model::objects, Slic3r::GLVolume::CompositeID::volume_id, and Slic3r::ModelObject::volumes.

Referenced by Slic3r::GUI::GLGizmoSimplify::on_render(), and Slic3r::GUI::GLGizmoSimplify::on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_volume_min_z()

static double Slic3r::GUI::get_volume_min_z ( const GLVolume & volume )

static

{
    return volume.transformed_convex_hull_bounding_box().min.z();
}

Referenced by Slic3r::GUI::ObjectManipulation::ObjectManipulation(), and Slic3r::GUI::ObjectManipulation::update_reset_buttons_visibility().

Here is the caller graph for this function:

◆ get_warning_icon_name()

static std::string Slic3r::GUI::get_warning_icon_name ( const TriangleMeshStats & stats )

static

{
    return stats.manifold() ? (stats.repaired() ? "exclamation_manifold" : "") : "exclamation";
}

References Slic3r::TriangleMeshStats::manifold(), and Slic3r::TriangleMeshStats::repaired().

Referenced by Slic3r::GUI::ObjectList::add_object_to_list(), Slic3r::GUI::ObjectList::add_volumes_to_object_in_list(), Slic3r::GUI::ObjectList::del_subobject_item(), Slic3r::GUI::ObjectList::delete_from_model_and_list(), Slic3r::GUI::ObjectList::get_mesh_errors_info(), and Slic3r::GUI::ObjectList::update_item_error_icon().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_wipe_tower()

static WipeTower Slic3r::GUI::get_wipe_tower ( const Plater & plater )

static

{
    return WipeTower{plater.canvas3D()->get_wipe_tower_info()};
}

References Slic3r::GUI::Plater::canvas3D(), Slic3r::GUI::GLCanvas3D::get_wipe_tower_info(), and plater().

Referenced by get_wipe_tower_arrangepoly(), and Slic3r::GUI::ArrangeJob::prepare_selected().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_wipe_tower_arrangepoly()

std::optional< arrangement::ArrangePolygon > Slic3r::GUI::get_wipe_tower_arrangepoly ( const Plater & plater )

{
    if (auto wti = get_wipe_tower(plater))
        return get_arrange_poly(wti, &plater);
 
    return {};
}

References get_arrange_poly(), get_wipe_tower(), and plater().

Referenced by Slic3r::GUI::FillBedJob::prepare(), and Slic3r::GUI::ArrangeJob::prepare_all().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_wraped_wxString()

wxString Slic3r::GUI::get_wraped_wxString	(	const wxString &	in,
		size_t	line_len
	)

{
    wxString out;
 
    for (size_t i = 0; i < in.size();) {
        // Overwrite the character (space or newline) starting at ibreak?
        bool   overwrite = false;
        // UTF8 representation of wxString.
        // Where to break the line, index of character at the start of a UTF-8 sequence.
        size_t ibreak    = size_t(-1);
        // Overwrite the character at ibreak (it is a whitespace) or not?
        size_t j = i;
        for (size_t cnt = 0; j < in.size();) {
            if (bool newline = in[j] == '\n'; in[j] == ' ' || in[j] == '\t' || newline) {
                // Overwrite the whitespace.
                ibreak    = j ++;
                overwrite = true;
                if (newline)
                    break;
            } else if (in[j] == '/'
#ifdef _WIN32
                 || in[j] == '\\'
#endif // _WIN32
                 ) {
                // Insert after the slash.
                ibreak    = ++ j;
                overwrite = false;
            } else
                j += get_utf8_sequence_length(in.c_str() + j, in.size() - j);
            if (++ cnt == line_len) {
                if (ibreak == size_t(-1)) {
                    ibreak    = j;
                    overwrite = false;
                }
                break;
            }
        }
        if (j == in.size()) {
            out.append(in.begin() + i, in.end());
            break;
        }
        assert(ibreak != size_t(-1));
        out.append(in.begin() + i, in.begin() + ibreak);
        out.append('\n');
        i = ibreak;
        if (overwrite)
            ++ i;
    }
 
    return out;
}

References Slic3r::get_utf8_sequence_length().

Referenced by Slic3r::GUI::LoadProjectsDialog::LoadProjectsDialog(), Slic3r::GUI::ProjectDropDialog::ProjectDropDialog(), and Slic3r::GUI::GLGizmoCut3D::render_cut_plane_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetNumberFromUser()

static long Slic3r::GUI::GetNumberFromUser	(	const wxString &	msg,
		const wxString &	prompt,
		const wxString &	title,
		long	value,
		long	min,
		long	max,
		wxWindow *	parent
	)

static

{
#ifdef _WIN32
    wxNumberEntryDialog dialog(parent, msg, prompt, title, value, min, max, wxDefaultPosition);
    wxGetApp().UpdateDlgDarkUI(&dialog);
    if (dialog.ShowModal() == wxID_OK)
        return dialog.GetValue();
 
    return -1;
#else
    return wxGetNumberFromUser(msg, prompt, title, value, min, max, parent);
#endif
}

Referenced by Slic3r::GUI::Plater::set_number_of_copies().

Here is the caller graph for this function:

◆ GetSelectedChoices()

static int Slic3r::GUI::GetSelectedChoices	(	wxArrayInt &	selections,
		const wxString &	message,
		const wxString &	caption,
		const wxArrayString &	choices
	)

static

{
    wxMultiChoiceDialog dialog(nullptr, message, caption, choices);
    wxGetApp().UpdateDlgDarkUI(&dialog);
 
    // call this even if selections array is empty and this then (correctly)
    // deselects the first item which is selected by default
    dialog.SetSelections(selections);
 
#ifdef __APPLE__
    // Improvements for ChoiceListBox: Height of control will restect to items count
    for (auto child : dialog.GetChildren())
        if (dynamic_cast<wxListBox*>(child) && !choices.IsEmpty()) {
            wxClientDC dc(child);
 
            int height = dc.GetTextExtent(choices[0]).y;
            int width = 0;
            for (const auto& string : choices)
                width = std::max(width, dc.GetTextExtent(string).x);
 
            // calculate best size of ListBox
            height += 3 * mac_max_scaling_factor(); // extend height by margins
            width += 3 * height;                   // extend width by checkbox width and margins
 
            // don't make the listbox too tall (limit height to around 10 items)
            // but don't make it too small neither
            int list_height = wxMax(height * wxMin(wxMax(choices.Count(), 3), 10), 70);
            wxSize sz_best = wxSize(width, list_height);
 
            wxSize sz = child->GetSize();
            child->SetMinSize(sz_best);
 
            // extend Dialog size, if calculated best size of ListBox is bigger then its size
            wxSize dlg_sz = dialog.GetSize();
            if (int delta_x = sz_best.x - sz.x; delta_x > 0) dlg_sz.x += delta_x;
            if (int delta_y = sz_best.y - sz.y; delta_y > 0) dlg_sz.y += delta_y;
            dialog.SetSize(dlg_sz);
 
            break;
        }
#endif
 
    if (dialog.ShowModal() != wxID_OK)
    {
        // NB: intentionally do not clear the selections array here, the caller
        //     might want to preserve its original contents if the dialog was
        //     cancelled
        return -1;
    }
 
    selections = dialog.GetSelections();
    return static_cast<int>(selections.GetCount());
}

References mac_max_scaling_factor().

Referenced by create_settings_popupmenu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ gl_get_string_safe()

std::string Slic3r::GUI::gl_get_string_safe	(	GLenum	param,
		const std::string &	default_value
	)

{
    const char* value = (const char*)::glGetString(param);
    glcheck();
    return std::string((value != nullptr) ? value : default_value);
}

References glcheck.

Referenced by Slic3r::GUI::OpenGLManager::GLInfo::detect(), generate_system_info_json(), and Slic3r::GUI::OpenGLManager::GLInfo::to_string().

Here is the caller graph for this function:

◆ GUI_Run()

int Slic3r::GUI::GUI_Run ( GUI_InitParams & params )

{
#if __APPLE__
    // On OSX, we use boost::process::spawn() to launch new instances of PrusaSlicer from another PrusaSlicer.
    // boost::process::spawn() sets SIGCHLD to SIGIGN for the child process, thus if a child PrusaSlicer spawns another
    // subprocess and the subrocess dies, the child PrusaSlicer will not receive information on end of subprocess
    // (posix waitpid() call will always fail).
    // https://jmmv.dev/2008/10/boostprocess-and-sigchld.html
    // The child instance of PrusaSlicer has to reset SIGCHLD to its default, so that posix waitpid() and similar continue to work.
    // See GH issue #5507
    signal(SIGCHLD, SIG_DFL);
#endif // __APPLE__
 
    try {
        GUI::GUI_App* gui = new GUI::GUI_App(params.start_as_gcodeviewer ? GUI::GUI_App::EAppMode::GCodeViewer : GUI::GUI_App::EAppMode::Editor);
        if (gui->get_app_mode() != GUI::GUI_App::EAppMode::GCodeViewer) {
            // G-code viewer is currently not performing instance check, a new G-code viewer is started every time.
            bool gui_single_instance_setting = gui->app_config->get_bool("single_instance");
            if (Slic3r::instance_check(params.argc, params.argv, gui_single_instance_setting)) {
                //TODO: do we have delete gui and other stuff?
                return -1;
            }
        }
 
        GUI::GUI_App::SetInstance(gui);
        gui->init_params = &params;
        return wxEntry(params.argc, params.argv);
    } catch (const Slic3r::Exception &ex) {
        boost::nowide::cerr << ex.what() << std::endl;
        wxMessageBox(boost::nowide::widen(ex.what()), _L("PrusaSlicer GUI initialization failed"), wxICON_STOP);
    } catch (const std::exception &ex) {
        boost::nowide::cerr << "PrusaSlicer GUI initialization failed: " << ex.what() << std::endl;
        wxMessageBox(format_wxstr(_L("Fatal error, exception catched: %1%"), ex.what()), _L("PrusaSlicer GUI initialization failed"), wxICON_STOP);
    }
 
    // error
    return 1;
}

References _L, Slic3r::GUI::GUI_App::app_config, Slic3r::GUI::GUI_InitParams::argc, Slic3r::GUI::GUI_InitParams::argv, Slic3r::GUI::GUI_App::Editor, format_wxstr(), Slic3r::GUI::GUI_App::GCodeViewer, Slic3r::GUI::GUI_App::get_app_mode(), Slic3r::AppConfig::get_bool(), Slic3r::GUI::GUI_App::init_params, Slic3r::instance_check(), Slic3r::GUI::GUI_InitParams::start_as_gcodeviewer, and boost::nowide::widen().

Referenced by Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ image_button_ex()

static bool Slic3r::GUI::image_button_ex	(	ImGuiID	id,
		ImTextureID	texture_id,
		const ImVec2 &	size,
		const ImVec2 &	uv0,
		const ImVec2 &	uv1,
		const ImVec2 &	padding,
		const ImVec4 &	bg_col,
		const ImVec4 &	tint_col,
		ImGuiButtonFlags	flags
	)

static

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = ImGui::GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size + padding * 2);
    ImGui::ItemSize(bb);
    if (!ImGui::ItemAdd(bb, id))
        return false;
 
    bool hovered, held;
    bool pressed = ImGui::ButtonBehavior(bb, id, &hovered, &held, flags);
 
    // Render
    const ImU32 col = ImGui::GetColorU32((held && hovered) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);
    ImGui::RenderNavHighlight(bb, id);
    ImGui::RenderFrame(bb.Min, bb.Max, col, true, ImClamp((float)ImMin(padding.x, padding.y), 0.0f, g.Style.FrameRounding));
    if (bg_col.w > 0.0f)
        window->DrawList->AddRectFilled(bb.Min + padding, bb.Max - padding, ImGui::GetColorU32(bg_col));
    window->DrawList->AddImage(texture_id, bb.Min + padding, bb.Max - padding, uv0, uv1, ImGui::GetColorU32(tint_col));
 
    return pressed;
}

References ImDrawList::AddImage(), ImDrawList::AddRectFilled(), ImGui::ButtonBehavior(), col(), ImGuiWindowTempData::CursorPos, ImGuiWindow::DC, ImGuiWindow::DrawList, ImGuiStyle::FrameRounding, ImGui::GetColorU32(), ImGui::GetCurrentWindow(), GImGui, ImClamp(), ImGuiCol_Button, ImGuiCol_ButtonActive, ImGuiCol_ButtonHovered, ImMin(), ImGui::ItemAdd(), ImGui::ItemSize(), ImRect::Max, ImRect::Min, ImGui::RenderFrame(), ImGui::RenderNavHighlight(), ImGuiWindow::SkipItems, ImGuiContext::Style, ImVec4::w, ImVec2::x, and ImVec2::y.

Referenced by Slic3r::GUI::ImGuiWrapper::image_button().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_from_angle_arc()

static void Slic3r::GUI::init_from_angle_arc	(	GLModel &	model,
		double	angle,
		double	radius
	)

static

{
    model.reset();
 
    const float step_angle = float(angle) / float(AngleResolution);
    const float ex_radius = float(radius);
 
    GLModel::Geometry init_data;
    init_data.format = { GLModel::Geometry::EPrimitiveType::LineStrip, GLModel::Geometry::EVertexLayout::P3 };
    init_data.reserve_vertices(1 + AngleResolution);
    init_data.reserve_indices(1 + AngleResolution);
 
    // vertices + indices
    for (unsigned int i = 0; i <= AngleResolution; ++i) {
        const float angle = float(i) * step_angle;
        init_data.add_vertex(Vec3f(::cos(angle) * ex_radius, ::sin(angle) * ex_radius, 0.0f));
        init_data.add_index(i);
    }
 
    model.init_from(std::move(init_data));
}

References Slic3r::GUI::GLModel::Geometry::add_index(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::angle(), AngleResolution, cos(), Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::GLModel::init_from(), Slic3r::GUI::GLModel::Geometry::LineStrip, Slic3r::GUI::GLModel::Geometry::P3, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::GUI::GLModel::reset(), and sin().

Referenced by Slic3r::GUI::GLGizmoCut3D::init_rendering_items().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_from_circle()

static void Slic3r::GUI::init_from_circle	(	GLModel &	model,
		double	radius
	)

static

– #ysFIXME those functions bodies are ported from GizmoRotation

{
    GLModel::Geometry init_data;
    init_data.format = { GLModel::Geometry::EPrimitiveType::LineLoop, GLModel::Geometry::EVertexLayout::P3 };
    init_data.reserve_vertices(ScaleStepsCount);
    init_data.reserve_indices(ScaleStepsCount);
 
    // vertices + indices
    for (unsigned int i = 0; i < ScaleStepsCount; ++i) {
        const float angle = float(i * ScaleStepRad);
        init_data.add_vertex(Vec3f(::cos(angle) * float(radius), ::sin(angle) * float(radius), 0.0f));
        init_data.add_index(i);
    }
 
    model.init_from(std::move(init_data));
    model.set_color(ColorRGBA::WHITE());
}

References Slic3r::GUI::GLModel::Geometry::add_index(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::angle(), cos(), Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::GLModel::init_from(), Slic3r::GUI::GLModel::Geometry::LineLoop, Slic3r::GUI::GLModel::Geometry::P3, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), ScaleStepRad, ScaleStepsCount, Slic3r::GUI::GLModel::set_color(), sin(), and Slic3r::ColorRGBA::WHITE().

Referenced by Slic3r::GUI::GLGizmoCut3D::init_rendering_items().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_from_scale()

static void Slic3r::GUI::init_from_scale	(	GLModel &	model,
		double	radius
	)

static

{
    const float out_radius_long  = float(radius) * (1.0f + ScaleLongTooth);
    const float out_radius_short = float(radius) * (1.0f + 0.5f * ScaleLongTooth);
 
    GLModel::Geometry init_data;
    init_data.format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3 };
    init_data.reserve_vertices(2 * ScaleStepsCount);
    init_data.reserve_indices(2 * ScaleStepsCount);
 
    // vertices + indices
    for (unsigned int i = 0; i < ScaleStepsCount; ++i) {
        const float angle = float(i * ScaleStepRad);
        const float cosa = ::cos(angle);
        const float sina = ::sin(angle);
        const float in_x = cosa * float(radius);
        const float in_y = sina * float(radius);
        const float out_x = (i % ScaleLongEvery == 0) ? cosa * out_radius_long : cosa * out_radius_short;
        const float out_y = (i % ScaleLongEvery == 0) ? sina * out_radius_long : sina * out_radius_short;
 
        // vertices
        init_data.add_vertex(Vec3f(in_x, in_y, 0.0f));
        init_data.add_vertex(Vec3f(out_x, out_y, 0.0f));
 
        // indices
        init_data.add_line(i * 2, i * 2 + 1);
    }
 
    model.init_from(std::move(init_data));
    model.set_color(ColorRGBA::WHITE());
}

Referenced by Slic3r::GUI::GLGizmoCut3D::init_rendering_items().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_from_snap_radii()

static void Slic3r::GUI::init_from_snap_radii	(	GLModel &	model,
		double	radius
	)

static

{
    const float step = 2.0f * float(PI) / float(SnapRegionsCount);
    const float in_radius = float(radius) / 3.0f;
    const float out_radius = 2.0f * in_radius;
 
    GLModel::Geometry init_data;
    init_data.format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3 };
    init_data.reserve_vertices(2 * ScaleStepsCount);
    init_data.reserve_indices(2 * ScaleStepsCount);
 
    // vertices + indices
    for (unsigned int i = 0; i < ScaleStepsCount; ++i) {
        const float angle = float(i) * step;
        const float cosa = ::cos(angle);
        const float sina = ::sin(angle);
        const float in_x = cosa * in_radius;
        const float in_y = sina * in_radius;
        const float out_x = cosa * out_radius;
        const float out_y = sina * out_radius;
 
        // vertices
        init_data.add_vertex(Vec3f(in_x, in_y, 0.0f));
        init_data.add_vertex(Vec3f(out_x, out_y, 0.0f));
 
        // indices
        init_data.add_line(i * 2, i * 2 + 1);
    }
 
    model.init_from(std::move(init_data));
    model.set_color(ColorRGBA::WHITE());
}

References Slic3r::GUI::GLModel::Geometry::add_line(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::angle(), cos(), Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::GLModel::init_from(), Slic3r::GUI::GLModel::Geometry::Lines, Slic3r::GUI::GLModel::Geometry::P3, PI, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), ScaleStepsCount, Slic3r::GUI::GLModel::set_color(), sin(), SnapRegionsCount, and Slic3r::ColorRGBA::WHITE().

Referenced by Slic3r::GUI::GLGizmoCut3D::init_rendering_items().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_plane_data()

static GLModel::Geometry Slic3r::GUI::init_plane_data	(	const indexed_triangle_set &	its,
		const std::vector< int > &	triangle_indices
	)

static

{
    GLModel::Geometry init_data;
    init_data.format = { GUI::GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3N3 };
    unsigned int i = 0;
    for (int idx : triangle_indices) {
        const Vec3f& v0 = its.vertices[its.indices[idx][0]];
        const Vec3f& v1 = its.vertices[its.indices[idx][1]];
        const Vec3f& v2 = its.vertices[its.indices[idx][2]];
 
        const Vec3f n = (v1 - v0).cross(v2 - v0).normalized();
        init_data.add_vertex(v0, n);
        init_data.add_vertex(v1, n);
        init_data.add_vertex(v2, n);
        init_data.add_triangle(i, i + 1, i + 2);
        i += 3;
    }
 
    return init_data;
}

References Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::cross(), Slic3r::GUI::GLModel::Geometry::format, indexed_triangle_set::indices, Slic3r::GUI::GLModel::Geometry::P3N3, Slic3r::GUI::GLModel::Geometry::Triangles, and indexed_triangle_set::vertices.

Referenced by Slic3r::GUI::GLGizmoMeasure::on_render(), and Slic3r::GUI::GLGizmoMeasure::update_if_needed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_torus_data()

static GLModel::Geometry Slic3r::GUI::init_torus_data	(	unsigned int	primary_resolution,
		unsigned int	secondary_resolution,
		const Vec3f &	center,
		float	radius,
		float	thickness,
		const Vec3f &	model_axis,
		const Transform3f &	world_trafo
	)

static

{
    const unsigned int torus_sector_count = std::max<unsigned int>(4, primary_resolution);
    const unsigned int section_sector_count = std::max<unsigned int>(4, secondary_resolution);
    const float torus_sector_step = 2.0f * float(M_PI) / float(torus_sector_count);
    const float section_sector_step = 2.0f * float(M_PI) / float(section_sector_count);
 
    GLModel::Geometry data;
    data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3N3 };
    data.reserve_vertices(torus_sector_count * section_sector_count);
    data.reserve_indices(torus_sector_count * section_sector_count * 2 * 3);
 
    // vertices
    const Transform3f local_to_world_matrix = world_trafo * Geometry::translation_transform(center.cast<double>()).cast<float>() *
        Eigen::Quaternion<float>::FromTwoVectors(Vec3f::UnitZ(), model_axis);
    for (unsigned int i = 0; i < torus_sector_count; ++i) {
        const float section_angle = torus_sector_step * i;
        const Vec3f radius_dir(std::cos(section_angle), std::sin(section_angle), 0.0f);
        const Vec3f local_section_center = radius * radius_dir;
        const Vec3f world_section_center = local_to_world_matrix * local_section_center;
        const Vec3f local_section_normal = local_section_center.normalized().cross(Vec3f::UnitZ()).normalized();
        const Vec3f world_section_normal = (Vec3f)(local_to_world_matrix.matrix().block(0, 0, 3, 3) * local_section_normal).normalized();
        const Vec3f base_v = thickness * radius_dir;
        for (unsigned int j = 0; j < section_sector_count; ++j) {
            const Vec3f v = Eigen::AngleAxisf(section_sector_step * j, world_section_normal) * base_v;
            data.add_vertex(world_section_center + v, (Vec3f)v.normalized());
        }
    }
 
    // triangles
    for (unsigned int i = 0; i < torus_sector_count; ++i) {
        const unsigned int ii = i * section_sector_count;
        const unsigned int ii_next = ((i + 1) % torus_sector_count) * section_sector_count;
        for (unsigned int j = 0; j < section_sector_count; ++j) {
            const unsigned int j_next = (j + 1) % section_sector_count;
            const unsigned int i0 = ii + j;
            const unsigned int i1 = ii_next + j;
            const unsigned int i2 = ii_next + j_next;
            const unsigned int i3 = ii + j_next;
            data.add_triangle(i0, i1, i2);
            data.add_triangle(i0, i2, i3);
        }
    }
 
    return data;
}

References M_PI, Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::matrix(), Slic3r::GUI::GLModel::Geometry::P3N3, Slic3r::Geometry::translation_transform(), and Slic3r::GUI::GLModel::Geometry::Triangles.

Referenced by Slic3r::GUI::GLGizmoMeasure::on_render().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ input_optional()

template<typename T , typename Func >

static bool Slic3r::GUI::input_optional	(	std::optional< T > &	v,
		Func &	f,
		std::function< bool(const T &)>	is_default,
		const T &	def_val
	)

static

{
    if (v.has_value()) {
        if (f(*v)) {
            if (is_default(*v)) v.reset();
            return true;
        }
    } else {
        T val = def_val;
        if (f(val)) {
            if (!is_default(val)) v = val;
            return true;
        }
    }
    return false;
}

References Slic3r::f().

Referenced by Slic3r::GUI::ImGuiWrapper::drag_optional_float(), Slic3r::GUI::ImGuiWrapper::input_optional_float(), Slic3r::GUI::ImGuiWrapper::input_optional_int(), Slic3r::GUI::ImGuiWrapper::slider_optional_float(), and Slic3r::GUI::ImGuiWrapper::slider_optional_int().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ into_path()

boost::filesystem::path Slic3r::GUI::into_path ( const wxString & str )

{
  return boost::filesystem::path(str.wx_str());
}

Here is the caller graph for this function:

◆ into_u8()

std::string Slic3r::GUI::into_u8 ( const wxString & str )

{
  auto buffer_utf8 = str.utf8_str();
  return std::string(buffer_utf8.data());
}

References into_u8().

Here is the call graph for this function:

◆ is_bad_field()

bool Slic3r::GUI::is_bad_field ( const t_field & obj )

inline

Convenience function, accepts a const reference to t_field and checks to see whether or not both wx pointers are null.

245{ return obj->getSizer() == nullptr && obj->getWindow() == nullptr; }

Referenced by is_sizer_field(), and is_window_field().

Here is the caller graph for this function:

◆ is_defined_input_value()

template<class T >

bool Slic3r::GUI::is_defined_input_value	(	wxWindow *	win,
		const ConfigOptionType &	type
	)

{
    if (!win || (static_cast<T*>(win)->GetValue().empty() && type != coString && type != coStrings && type != coPoints))
        return false;
    return true;
}

References Slic3r::coPoints, Slic3r::coString, Slic3r::coStrings, Slic3r::empty(), and is_defined_input_value().

Referenced by is_defined_input_value().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_feature_with_center()

static bool Slic3r::GUI::is_feature_with_center ( const Measure::SurfaceFeature & feature )

static

{
    const Measure::SurfaceFeatureType type = feature.get_type();
    return (type == Measure::SurfaceFeatureType::Circle || (type == Measure::SurfaceFeatureType::Edge && feature.get_extra_point().has_value()));
}

References Slic3r::Measure::Circle, Slic3r::Measure::Edge, Slic3r::Measure::SurfaceFeature::get_extra_point(), and Slic3r::Measure::SurfaceFeature::get_type().

Referenced by Slic3r::GUI::GLGizmoMeasure::on_mouse(), Slic3r::GUI::GLGizmoMeasure::on_render(), and Slic3r::GUI::GLGizmoMeasure::on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_improper_category()

static bool Slic3r::GUI::is_improper_category	(	const std::string &	category,
		const int	extruders_cnt,
		const bool	is_object_settings = `true`
	)

static

{
    return  category.empty() ||
        (extruders_cnt == 1 && (category == "Extruders" || category == "Wipe options")) ||
        (!is_object_settings && category == "Support material");
}

Referenced by create_freq_settings_popupmenu(), Slic3r::GUI::SettingsFactory::get_bundle(), and get_full_settings_hierarchy().

Here is the caller graph for this function:

◆ is_left_handed() [1/2]

static bool Slic3r::GUI::is_left_handed ( const Transform3d & m )

static

{
    return is_left_handed(m.linear());
}

References is_left_handed(), and Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::linear().

Here is the call graph for this function:

◆ is_left_handed() [2/2]

static bool Slic3r::GUI::is_left_handed ( const Transform3d::ConstLinearPart & m )

static

{
    return m.determinant() < 0;
}

Referenced by Slic3r::GUI::Plater::export_stl_obj(), is_left_handed(), Slic3r::GUI::GLGizmoPainterBase::render_cursor_sphere(), Slic3r::GUI::GLGizmoPainterBase::render_triangles(), Slic3r::GUI::GLGizmoMmuSegmentation::render_triangles(), and Slic3r::GUI::Selection::synchronize_unselected_instances().

Here is the caller graph for this function:

◆ is_point_in_rect()

static bool Slic3r::GUI::is_point_in_rect	(	const wxPoint &	pt,
		const wxRect &	rect
	)

static

{
    return  rect.GetLeft() <= pt.x && pt.x <= rect.GetRight() &&
            rect.GetTop() <= pt.y && pt.y <= rect.GetBottom();
}

Referenced by Slic3r::GUI::OG_CustomCtrl::OnLeftDown(), and Slic3r::GUI::OG_CustomCtrl::OnMotion().

Here is the caller graph for this function:

◆ is_rotation_xy_synchronized() [1/3]

static bool Slic3r::GUI::is_rotation_xy_synchronized	(	const Transform3d &	trafo_from,
		const Transform3d &	trafo_to
	)

static

{
    return is_rotation_xy_synchronized(trafo_from.linear(), trafo_to.linear());
}

References is_rotation_xy_synchronized(), and Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::linear().

Here is the call graph for this function:

◆ is_rotation_xy_synchronized() [2/3]

static bool Slic3r::GUI::is_rotation_xy_synchronized	(	const Transform3d::ConstLinearPart &	trafo_from,
		const Transform3d::ConstLinearPart &	trafo_to
	)

static

{
    auto rot = trafo_to * trafo_from.inverse();
    static constexpr const double eps = EPSILON;
    return 
           // Looks like a rotation around Z: block(0..1, 0..1) + no change of Z component.
           is_approx(rot(0, 0),   rot(1, 1), eps) &&
           is_approx(rot(0, 1), - rot(1, 0), eps) &&
           is_approx(rot(2, 2),          1., eps) &&
           // Rest should be zeros.
           is_approx(rot(0, 2),          0., eps) &&
           is_approx(rot(1, 2),          0., eps) &&
           is_approx(rot(2, 0),          0., eps) &&
           is_approx(rot(2, 1),          0., eps) &&
           // Determinant equals 1
           is_approx(rot.determinant(),  1., eps) &&
           // and finally the rotated X and Y axes shall be perpendicular.
           is_approx(rot(0, 0) * rot(0, 1) + rot(1, 0) * rot(1, 1), 0., eps);
}

References EPSILON, and Slic3r::is_approx().

Here is the call graph for this function:

◆ is_rotation_xy_synchronized() [3/3]

static bool Slic3r::GUI::is_rotation_xy_synchronized	(	const Vec3d &	rot_xyz_from,
		const Vec3d &	rot_xyz_to
	)

static

{
    const Eigen::AngleAxisd angle_axis(Geometry::rotation_xyz_diff(rot_xyz_from, rot_xyz_to));
    const Vec3d  axis = angle_axis.axis();
    const double angle = angle_axis.angle();
    if (std::abs(angle) < 1e-8)
        return true;
    assert(std::abs(axis.x()) < 1e-8);
    assert(std::abs(axis.y()) < 1e-8);
    assert(std::abs(std::abs(axis.z()) - 1.) < 1e-8);
    return std::abs(axis.x()) < 1e-8 && std::abs(axis.y()) < 1e-8 && std::abs(std::abs(axis.z()) - 1.) < 1e-8;
}

References Eigen::AngleAxis< _Scalar >::angle(), Slic3r::angle(), Eigen::AngleAxis< _Scalar >::axis(), and Slic3r::Geometry::rotation_xyz_diff().

Referenced by is_rotation_xy_synchronized(), Slic3r::GUI::Selection::synchronize_unselected_instances(), and verify_instances_rotation_synchronized().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_sizer_field()

bool Slic3r::GUI::is_sizer_field ( const t_field & obj )

inline

Covenience function to determine whether this field is a valid sizer field.

251{ return !is_bad_field(obj) && obj->getSizer() != nullptr; }

Slic3r::GUI::is_bad_field

bool is_bad_field(const t_field &obj)

Convenience function, accepts a const reference to t_field and checks to see whether or not both wx p...

Definition Field.hpp:245

References is_bad_field().

Referenced by Slic3r::GUI::OptionsGroup::activate_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_window_field()

bool Slic3r::GUI::is_window_field ( const t_field & obj )

inline

Covenience function to determine whether this field is a valid window field.

248{ return !is_bad_field(obj) && obj->getWindow() != nullptr && obj->getSizer() == nullptr; }

References is_bad_field().

Referenced by Slic3r::GUI::OptionsGroup::activate_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ its_make_line()

static GLModel::Geometry Slic3r::GUI::its_make_line	(	Vec3f	beg_pos,
		Vec3f	end_pos
	)

static

{
    GLModel::Geometry init_data;
    init_data.format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3 };
    init_data.reserve_vertices(2);
    init_data.reserve_indices(2);
 
    // vertices
    init_data.add_vertex(beg_pos);
    init_data.add_vertex(end_pos);
 
    // indices
    init_data.add_line(0, 1);
    return init_data;
}

References Slic3r::GUI::GLModel::Geometry::add_line(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::GLModel::Geometry::Lines, Slic3r::GUI::GLModel::Geometry::P3, Slic3r::GUI::GLModel::Geometry::reserve_indices(), and Slic3r::GUI::GLModel::Geometry::reserve_vertices().

Referenced by Slic3r::GUI::GLGizmoCut3D::init_rendering_items(), and Slic3r::GUI::GLGizmoCut3D::render_cut_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ L_str()

wxString Slic3r::GUI::L_str ( const std::string & str )

Explicitly specify that the source string is already in UTF-8 encoding

{
  return wxGetTranslation(wxString(str.c_str(), wxConvUTF8));
}

◆ libslic3r_translate_callback()

static std::string Slic3r::GUI::libslic3r_translate_callback ( const char * s )

static

629{ return wxGetTranslation(wxString(s, wxConvUTF8)).utf8_str().data(); }

◆ list_model()

static ObjectDataViewModel * Slic3r::GUI::list_model ( )

static

{
    return wxGetApp().obj_list()->GetModel();
}

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_settings(), and Slic3r::GUI::MenuFactory::multi_selection_menu().

Here is the caller graph for this function:

◆ mac_dark_mode()

bool Slic3r::GUI::mac_dark_mode ( )

{
    NSString *style = [[NSUserDefaults standardUserDefaults] stringForKey:@"AppleInterfaceStyle"];
    return style && [style isEqualToString:@"Dark"];
 
}

References style.

Referenced by Slic3r::GUI::GUI_App::dark_mode().

Here is the caller graph for this function:

◆ mac_max_scaling_factor()

double Slic3r::GUI::mac_max_scaling_factor ( )

{
    double scaling = 1.;
    if ([NSScreen screens] == nil) {
        scaling = [[NSScreen mainScreen] backingScaleFactor];
    } else {
      for (int i = 0; i < [[NSScreen screens] count]; ++ i)
        scaling = std::max<double>(scaling, [[[NSScreen screens] objectAtIndex:0] backingScaleFactor]);
  }
    return scaling;
}

Referenced by Slic3r::GUI::BitmapCache::BitmapCache(), add_default_image(), add_lock(), Slic3r::GUI::OpenGLManager::GLInfo::get_max_tex_size(), and GetSelectedChoices().

Here is the caller graph for this function:

◆ main_frame_icon()

static wxIcon Slic3r::GUI::main_frame_icon ( GUI_App::EAppMode app_mode )

static

{
#if _WIN32
    std::wstring path(size_t(MAX_PATH), wchar_t(0));
    int len = int(::GetModuleFileName(nullptr, path.data(), MAX_PATH));
    if (len > 0 && len < MAX_PATH) {
        path.erase(path.begin() + len, path.end());
        if (app_mode == GUI_App::EAppMode::GCodeViewer) {
            // Only in case the slicer was started with --gcodeviewer parameter try to load the icon from prusa-gcodeviewer.exe
            // Otherwise load it from the exe.
            for (const std::wstring_view exe_name : { std::wstring_view(L"prusa-slicer.exe"), std::wstring_view(L"prusa-slicer-console.exe") })
                if (boost::iends_with(path, exe_name)) {
                    path.erase(path.end() - exe_name.size(), path.end());
                    path += L"prusa-gcodeviewer.exe";
                    break;
                }
        }
    }
    return wxIcon(path, wxBITMAP_TYPE_ICO);
#else // _WIN32
    return wxIcon(Slic3r::var(app_mode == GUI_App::EAppMode::Editor ? "PrusaSlicer_128px.png" : "PrusaSlicer-gcodeviewer_128px.png"), wxBITMAP_TYPE_PNG);
#endif // _WIN32
}

References Slic3r::GUI::GUI_App::Editor, Slic3r::GUI::GUI_App::GCodeViewer, L, and Slic3r::var().

Referenced by Slic3r::GUI::MainFrame::MainFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_string_bold()

static void Slic3r::GUI::make_string_bold ( wxString & str )

static

{
#if defined(SUPPORTS_MARKUP) && !defined(__APPLE__)
    str = from_u8((boost::format("<b>%1%</b>") % into_u8(str)).str());
#endif
}

References from_u8(), and into_u8().

Referenced by Slic3r::GUI::DiffModel::AddOption(), and Slic3r::GUI::DiffModel::AddPreset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ msw_rescale_word_local_combo()

void Slic3r::GUI::msw_rescale_word_local_combo ( choice_ctrl * combo )

{
#ifdef __WXOSX__
    const wxString selection = combo->GetString(combo->GetSelection());
 
    /* To correct scaling (set new controll size) of a wxBitmapCombobox
     * we need to refill control with new bitmaps. So, in our case :
     * 1. clear control
     * 2. add content
     * 3. add scaled "empty" bitmap to the at least one item
     */
    combo->Clear();
    wxSize size(wxDefaultSize);
    size.SetWidth(15 * wxGetApp().em_unit());
 
    // Set rescaled min height to correct layout
    combo->SetMinSize(wxSize(-1, int(1.5f*combo->GetFont().GetPixelSize().y + 0.5f)));
    // Set rescaled size
    combo->SetSize(size);
    
    combo->Append(ObjectManipulation::coordinate_type_str(ECoordinatesType::World));
    combo->Append(ObjectManipulation::coordinate_type_str(ECoordinatesType::Instance));
    combo->Append(ObjectManipulation::coordinate_type_str(ECoordinatesType::Local));
 
    combo->SetValue(selection);
#else
#ifdef _WIN32
    combo->Rescale();
#endif
    combo->SetMinSize(wxSize(15 * wxGetApp().em_unit(), -1));
#endif
}

References Slic3r::GUI::ObjectManipulation::coordinate_type_str(), em_unit(), Instance, Local, and World.

Referenced by Slic3r::GUI::ObjectManipulation::msw_rescale().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ na_value()

static wxString Slic3r::GUI::na_value ( bool for_spin_ctrl = false )

static

{
#ifdef __linux__
    if (for_spin_ctrl)
        return "";
#endif
    return _(L("N/A"));
}

References _, L, and na_value().

Referenced by Slic3r::GUI::SpinCtrl::get_value(), Slic3r::GUI::Field::get_value_by_opt_type(), na_value(), Slic3r::GUI::TextCtrl::propagate_value(), Slic3r::GUI::TextCtrl::set_na_value(), Slic3r::GUI::SpinCtrl::set_na_value(), Slic3r::GUI::TextCtrl::set_value(), and Slic3r::GUI::SpinCtrl::set_value().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ obj_list()

static ObjectList * Slic3r::GUI::obj_list ( )

static

{
    return wxGetApp().obj_list();
}

Here is the caller graph for this function:

◆ object_contains_negative_volumes()

static bool Slic3r::GUI::object_contains_negative_volumes	(	const Model &	model,
		int	obj_id
	)

static

                                                                             {
    return (0 <= obj_id && obj_id < (int)model.objects.size()) ? model.objects[obj_id]->has_negative_volume_mesh() : false;
}

References Slic3r::Model::objects.

Referenced by Slic3r::GUI::GLCanvas3D::SLAView::detect_type_from_volumes(), and Slic3r::GUI::GLCanvas3D::SLAView::render_switch_button().

Here is the caller graph for this function:

◆ object_has_sla_drain_holes()

static bool Slic3r::GUI::object_has_sla_drain_holes	(	const Model &	model,
		int	obj_id
	)

static

                                                                       {
    return (0 <= obj_id && obj_id < (int)model.objects.size()) ? model.objects[obj_id]->has_sla_drain_holes() : false;
}

References Slic3r::Model::objects.

Referenced by Slic3r::GUI::GLCanvas3D::SLAView::detect_type_from_volumes().

Here is the caller graph for this function:

◆ on_mouse_surface_drag()

bool Slic3r::GUI::on_mouse_surface_drag	(	const wxMouseEvent &	mouse_event,
		const Camera &	camera,
		std::optional< SurfaceDrag > &	surface_drag,
		GLCanvas3D &	canvas,
		RaycastManager &	raycast_manager,
		std::optional< double >	up_limit = `{}`
	)

Mouse event handler, when move(drag&drop) volume over model surface NOTE: Dragged volume has to be selected. And also has to be hovered on start of dragging.

Parameters

mouse_event	Contain type of event and mouse position
camera	Actual viewport of camera
surface_drag	Structure which keep information about dragging
canvas	Contain gl_volumes and selection
raycast_manager	AABB trees for raycast in object Refresh state inside of function
up_limit	When set than use correction of up vector

Returns: True when event is processed otherwise false

{
    // Fix when leave window during dragging
    // Fix when click right button
    if (surface_drag.has_value() && !mouse_event.Dragging()) {
        // write transformation from UI into model
        canvas.do_move(L("Surface move"));
 
        // allow moving with object again
        canvas.enable_moving(true);
        canvas.enable_picking(true);
        surface_drag.reset();
 
        // only left up is correct
        // otherwise it is fix state and return false
        return mouse_event.LeftUp();
    }
 
    if (mouse_event.Moving())
        return false;
 
    // detect start text dragging
    if (mouse_event.LeftDown()) {
        // selected volume
        GLVolume *gl_volume = get_selected_gl_volume(canvas);
        if (gl_volume == nullptr)
            return false;
 
        // is selected volume closest hovered?
        const GLVolumePtrs &gl_volumes = canvas.get_volumes().volumes;        
        if (int hovered_idx = canvas.get_first_hover_volume_idx();
            hovered_idx < 0)
            return false;        
        else if (auto hovered_idx_ = static_cast<size_t>(hovered_idx);
            hovered_idx_ >= gl_volumes.size() || 
            gl_volumes[hovered_idx_] != gl_volume)
            return false;
 
        const ModelObjectPtrs &objects = canvas.get_model()->objects;
        const ModelObject *object = get_model_object(*gl_volume, objects);
        assert(object != nullptr);
        if (object == nullptr)
            return false;
 
        const ModelInstance *instance = get_model_instance(*gl_volume, *object);
        const ModelVolume   *volume   = get_model_volume(*gl_volume, *object);
        assert(instance != nullptr && volume != nullptr);
        if (object == nullptr || instance == nullptr || volume == nullptr)
            return false;
 
        // allowed drag&drop by canvas for object
        if (volume->is_the_only_one_part())
            return false;
 
        const ModelVolumePtrs &volumes = object->volumes;
        std::vector<size_t>    allowed_volumes_id;
        if (volumes.size() > 1) {
            allowed_volumes_id.reserve(volumes.size() - 1);
            for (auto &v : volumes) {
                // skip actual selected object
                if (v->id() == volume->id())
                    continue;
                // drag only above part not modifiers or negative surface
                if (!v->is_model_part())
                    continue;
                allowed_volumes_id.emplace_back(v->id().id);
            }
        }
        RaycastManager::AllowVolumes condition(std::move(allowed_volumes_id));
        RaycastManager::Meshes meshes = create_meshes(canvas, condition);
        // initialize raycasters
        // INFO: It could slows down for big objects
        // (may be move to thread and do not show drag until it finish)
        raycast_manager.actualize(*instance, &condition, &meshes);
 
        // wxCoord == int --> wx/types.h
        Vec2i mouse_coord(mouse_event.GetX(), mouse_event.GetY());
        Vec2d mouse_pos    = mouse_coord.cast<double>();
 
        // world_matrix_fixed() without sla shift
        Transform3d to_world = world_matrix_fixed(*gl_volume, objects);
        
        // zero point of volume in world coordinate system
        Vec3d volume_center = to_world.translation();
        // screen coordinate of volume center
        Vec2i coor = CameraUtils::project(camera, volume_center);
        Vec2d mouse_offset = coor.cast<double>() - mouse_pos;
        Vec2d mouse_offset_without_sla_shift = mouse_offset;
        if (double sla_shift = gl_volume->get_sla_shift_z(); !is_approx(sla_shift, 0.)) {        
            Transform3d to_world_without_sla_move = instance->get_matrix() * volume->get_matrix();
            if (volume->text_configuration.has_value() && volume->text_configuration->fix_3mf_tr.has_value())
                to_world_without_sla_move = to_world_without_sla_move * (*volume->text_configuration->fix_3mf_tr);
            // zero point of volume in world coordinate system
            volume_center = to_world_without_sla_move.translation();
            // screen coordinate of volume center
            coor = CameraUtils::project(camera, volume_center);
            mouse_offset_without_sla_shift = coor.cast<double>() - mouse_pos;            
        }
 
        Transform3d volume_tr = gl_volume->get_volume_transformation().get_matrix();
 
        if (volume->text_configuration.has_value()) {
            const TextConfiguration &tc = *volume->text_configuration;
            // fix baked transformation from .3mf store process
            if (tc.fix_3mf_tr.has_value())
                volume_tr = volume_tr * tc.fix_3mf_tr->inverse();
        }
 
        Transform3d instance_tr     = instance->get_matrix();
        Transform3d instance_tr_inv = instance_tr.inverse();
        Transform3d world_tr        = instance_tr * volume_tr;
        std::optional<float> start_angle;
        if (up_limit.has_value())
            start_angle = Emboss::calc_up(world_tr, *up_limit);        
        surface_drag = SurfaceDrag{mouse_offset, world_tr, instance_tr_inv, gl_volume, condition, start_angle, true, mouse_offset_without_sla_shift};
 
        // disable moving with object by mouse
        canvas.enable_moving(false);
        canvas.enable_picking(false);
        return true;
    }
 
    // Dragging starts out of window
    if (!surface_drag.has_value())
        return false;
 
    if (mouse_event.Dragging()) {
        // wxCoord == int --> wx/types.h
        Vec2i mouse_coord(mouse_event.GetX(), mouse_event.GetY());
        Vec2d mouse_pos      = mouse_coord.cast<double>();
        Vec2d offseted_mouse = mouse_pos + surface_drag->mouse_offset_without_sla_shift;
 
        std::optional<RaycastManager::Hit> hit = ray_from_camera(
            raycast_manager, offseted_mouse, camera, &surface_drag->condition);
 
        surface_drag->exist_hit = hit.has_value();
        if (!hit.has_value()) {
            // cross hair need redraw
            canvas.set_as_dirty();
            return true;
        }
 
        auto world_linear = surface_drag->world.linear();
        // Calculate offset: transformation to wanted position
        {
            // Reset skew of the text Z axis:
            // Project the old Z axis into a new Z axis, which is perpendicular to the old XY plane.
            Vec3d old_z         = world_linear.col(2);
            Vec3d new_z         = world_linear.col(0).cross(world_linear.col(1));
            world_linear.col(2) = new_z * (old_z.dot(new_z) / new_z.squaredNorm());
        }
 
        Vec3d       text_z_world     = world_linear.col(2); // world_linear * Vec3d::UnitZ()
        auto        z_rotation       = Eigen::Quaternion<double, Eigen::DontAlign>::FromTwoVectors(text_z_world, hit->normal);
        Transform3d world_new        = z_rotation * surface_drag->world;
        auto        world_new_linear = world_new.linear();
 
        // Fix direction of up vector to zero initial rotation
        if(up_limit.has_value()){
            Vec3d z_world = world_new_linear.col(2);
            z_world.normalize();
            Vec3d wanted_up = Emboss::suggest_up(z_world, *up_limit);
 
            Vec3d y_world    = world_new_linear.col(1);
            auto  y_rotation = Eigen::Quaternion<double, Eigen::DontAlign>::FromTwoVectors(y_world, wanted_up);
 
            world_new        = y_rotation * world_new;
            world_new_linear = world_new.linear();
        }
        
        // Edit position from right
        Transform3d volume_new{Eigen::Translation<double, 3>(surface_drag->instance_inv * hit->position)};
        volume_new.linear() = surface_drag->instance_inv.linear() * world_new_linear;
 
        // Check that transformation matrix is valid transformation
        assert(volume_new.matrix()(0, 0) == volume_new.matrix()(0, 0)); // Check valid transformation not a NAN
        if (volume_new.matrix()(0, 0) != volume_new.matrix()(0, 0))
            return true;
 
        // Check that scale in world did not changed
        assert(!calc_scale(world_linear, world_new_linear, Vec3d::UnitY()).has_value());
        assert(!calc_scale(world_linear, world_new_linear, Vec3d::UnitZ()).has_value());
 
        const ModelVolume *volume = get_model_volume(*surface_drag->gl_volume, canvas.get_model()->objects);
        if (volume != nullptr && volume->text_configuration.has_value()) {
            const TextConfiguration &tc = *volume->text_configuration;
            // fix baked transformation from .3mf store process
            if (tc.fix_3mf_tr.has_value())
                volume_new = volume_new * (*tc.fix_3mf_tr);
 
            // apply move in Z direction and rotation by up vector
            Emboss::apply_transformation(surface_drag->start_angle, tc.style.prop.distance, volume_new);
        }
 
        // Update transformation for all instances
        for (GLVolume *vol : canvas.get_volumes().volumes) {
            if (vol->object_idx() != surface_drag->gl_volume->object_idx() || vol->volume_idx() != surface_drag->gl_volume->volume_idx())
                continue;
            vol->set_volume_transformation(volume_new);
        }
 
        canvas.set_as_dirty();
        return true;
    }
    return false;
}

References Slic3r::GUI::RaycastManager::actualize(), Slic3r::Emboss::apply_transformation(), calc_scale(), Slic3r::Emboss::calc_up(), create_meshes(), Slic3r::FontProp::distance, Slic3r::GUI::GLCanvas3D::do_move(), Slic3r::GUI::GLCanvas3D::enable_moving(), Slic3r::GUI::GLCanvas3D::enable_picking(), Slic3r::TextConfiguration::fix_3mf_tr, Eigen::Quaternion< _Scalar, _Options >::FromTwoVectors(), Slic3r::GUI::GLCanvas3D::get_first_hover_volume_idx(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::ModelInstance::get_matrix(), Slic3r::GUI::GLCanvas3D::get_model(), get_model_instance(), get_model_object(), get_model_volume(), get_selected_gl_volume(), Slic3r::GLVolume::get_sla_shift_z(), Slic3r::GLVolume::get_volume_transformation(), Slic3r::GUI::GLCanvas3D::get_volumes(), Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::inverse(), Slic3r::is_approx(), L, Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::linear(), Slic3r::Model::objects, Slic3r::GUI::CameraUtils::project(), Slic3r::EmbossStyle::prop, ray_from_camera(), Slic3r::GUI::GLCanvas3D::set_as_dirty(), Slic3r::TextConfiguration::style, Slic3r::Emboss::suggest_up(), Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::translation(), Slic3r::GLVolumeCollection::volumes, and world_matrix_fixed().

Referenced by Slic3r::GUI::GLGizmoEmboss::on_mouse_for_translate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_window_geometry()

void Slic3r::GUI::on_window_geometry	(	wxTopLevelWindow *	tlw,
		std::function< void()>	callback
	)

{
#ifdef _WIN32
    // On windows, the wxEVT_SHOW is not received if the window is created maximized
    // cf. https://groups.google.com/forum/#!topic/wx-users/c7ntMt6piRI
    // OTOH the geometry is available very soon, so we can call the callback right away
    callback();
#elif defined __linux__
    tlw->Bind(wxEVT_SHOW, [=](wxShowEvent &evt) {
        // On Linux, the geometry is only available after wxEVT_SHOW + CallAfter
        // cf. https://groups.google.com/forum/?pli=1#!topic/wx-users/fERSXdpVwAI
        tlw->CallAfter([=]() { callback(); });
        evt.Skip();
    });
#elif defined __APPLE__
    tlw->Bind(wxEVT_SHOW, [=](wxShowEvent &evt) {
        callback();
        evt.Skip();
    });
#endif
}

Referenced by Slic3r::GUI::ConfigWizard::ConfigWizard(), and Slic3r::GUI::GUI_App::persist_window_geometry().

Here is the caller graph for this function:

◆ operator<()

bool Slic3r::GUI::operator<	(	const DriveData &	lhs,
		const DriveData &	rhs
	)

inline

31{ return lhs.path < rhs.path; }

Slic3r::GUI::DriveData::path

std::string path

Definition RemovableDriveManager.hpp:20

References Slic3r::GUI::DriveData::path.

◆ operator<<()

std::ostream & Slic3r::GUI::operator<<	(	std::ostream &	os,
		const WindowMetrics &	metrics
	)

{
    return os << '(' << metrics.serialize() << ')';
}

References Slic3r::GUI::WindowMetrics::serialize().

Here is the call graph for this function:

◆ operator==()

bool Slic3r::GUI::operator==	(	const DriveData &	lhs,
		const DriveData &	rhs
	)

inline

33{ return lhs.path == rhs.path; }

References Slic3r::GUI::DriveData::path.

◆ operator>()

bool Slic3r::GUI::operator>	(	const DriveData &	lhs,
		const DriveData &	rhs
	)

inline

32{ return lhs.path > rhs.path; }

References Slic3r::GUI::DriveData::path.

◆ pad_combo_value_for_config()

static wxString Slic3r::GUI::pad_combo_value_for_config ( const DynamicPrintConfig & config )

static

{
    return config.opt_bool("pad_enable") ? (config.opt_bool("pad_around_object") ? _("Around object") : _("Below object")) : _("None");
}

References _, Slic3r::ConfigBase::opt_bool(), and pad_combo_value_for_config().

Referenced by Slic3r::GUI::Tab::on_value_change(), pad_combo_value_for_config(), and Slic3r::GUI::Tab::update_frequently_changed_parameters().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_lscpu_etc()

static std::map< std::string, std::string > Slic3r::GUI::parse_lscpu_etc	(	const std::string &	name,
		char	delimiter
	)

static

{
    std::map<std::string, std::string> out;
    constexpr size_t max_len = 1000;
    char cline[max_len] = "";
    FILE* fp = popen(name.data(), "r");
    if (fp != NULL) {
        while (fgets(cline, max_len, fp) != NULL) {
            std::string line(cline);
            line.erase(std::remove_if(line.begin(), line.end(),
                [](char c) { return c == '\"' || c == '\r' || c == '\n'; }),
                line.end());
            size_t pos = line.find(delimiter);
            if (pos < line.size() - 1) {
                std::string key = line.substr(0, pos);
                std::string value = line.substr(pos + 1);
                boost::trim_all(key); // remove leading and trailing spaces
                boost::trim_all(value);
                out[key] = value;
            }
        }
        pclose(fp);
    }
    return out;
}

Referenced by generate_system_info_json().

Here is the caller graph for this function:

◆ parse_semver_from_ini()

static boost::optional< Semver > Slic3r::GUI::parse_semver_from_ini ( std::string path )

static

{
    std::ifstream stream(path);
    std::stringstream buffer;
    buffer << stream.rdbuf();
    std::string body = buffer.str();
    size_t start = body.find("PrusaSlicer ");
    if (start == std::string::npos)
        return boost::none;
    body = body.substr(start + 12);
    size_t end = body.find_first_of(" \n");
    if (end < body.size())
        body.resize(end);
    return Semver::parse(body);
}

References Slic3r::Semver::parse().

Referenced by Slic3r::GUI::GUI_App::check_older_app_config().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_version_string()

static Semver Slic3r::GUI::parse_version_string ( const std::string & version )

static

{
    if (version == "N/A")
        return Semver::invalid();
 
    std::vector<std::string> tokens;
    boost::split(tokens, version, boost::is_any_of(" "), boost::token_compress_on);
 
    if (tokens.empty())
        return Semver::invalid();
 
#if ENABLE_OPENGL_ES
    const std::string version_container = (tokens.size() > 1 && boost::istarts_with(tokens[1], "ES")) ? tokens[2] : tokens[0];
#endif // ENABLE_OPENGL_ES
 
    std::vector<std::string> numbers;
#if ENABLE_OPENGL_ES
    boost::split(numbers, version_container, boost::is_any_of("."), boost::token_compress_on);
#else
    boost::split(numbers, tokens[0], boost::is_any_of("."), boost::token_compress_on);
#endif // ENABLE_OPENGL_ES
 
    unsigned int gl_major = 0;
    unsigned int gl_minor = 0;
 
    if (numbers.size() > 0)
        gl_major = ::atoi(numbers[0].c_str());
 
    if (numbers.size() > 1)
        gl_minor = ::atoi(numbers[1].c_str());
 
    return Semver(gl_major, gl_minor, 0);
}

References Slic3r::Semver::invalid(), and version.

Referenced by Slic3r::GUI::OpenGLManager::GLInfo::detect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ plater()

static Plater * Slic3r::GUI::plater ( )

static

{
    return wxGetApp().plater();
}

◆ point_on_feature_type_as_string()

static std::string Slic3r::GUI::point_on_feature_type_as_string	(	Measure::SurfaceFeatureType	type,
		int	hover_id
	)

static

{
    std::string ret;
    switch (type) {
    case Measure::SurfaceFeatureType::Point:  { ret = _u8L("Vertex"); break; }
    case Measure::SurfaceFeatureType::Edge:   { ret = _u8L("Point on edge"); break; }
    case Measure::SurfaceFeatureType::Circle: { ret = _u8L("Point on circle"); break; }
    case Measure::SurfaceFeatureType::Plane:  { ret = _u8L("Point on plane"); break; }
    default:                                  { assert(false); break; }
    }
    return ret;
}

References _u8L, Slic3r::Measure::Circle, Slic3r::Measure::Edge, Slic3r::Measure::Plane, and Slic3r::Measure::Point.

Referenced by Slic3r::GUI::GLGizmoMeasure::on_render_input_window().

Here is the caller graph for this function:

◆ printer_config()

static DynamicPrintConfig & Slic3r::GUI::printer_config ( )

static

{
    return wxGetApp().preset_bundle->printers.get_edited_preset().config;
}

Referenced by Slic3r::GUI::ObjectList::split().

Here is the caller graph for this function:

◆ printer_technology() [1/2]

static PrinterTechnology Slic3r::GUI::printer_technology ( )

static

{
    return wxGetApp().preset_bundle->printers.get_selected_preset().printer_technology();
}

Here is the caller graph for this function:

◆ printer_technology() [2/2]

static PrinterTechnology Slic3r::GUI::printer_technology ( )

static

{
    return wxGetApp().preset_bundle->printers.get_selected_preset().printer_technology();
}

◆ process_key_down()

static void Slic3r::GUI::process_key_down	(	ImGuiKey	imgui_key,
		std::function< void()>	f
	)

static

{
    if (ImGui::IsKeyDown(ImGui::GetKeyIndex(imgui_key)))
    {
        f();
        // set KeysDown to false to avoid redundant key down processing
        ImGuiContext& g = *GImGui;
        g.IO.KeysDown[ImGui::GetKeyIndex(imgui_key)] = false;
    }
}

References Slic3r::f(), ImGui::GetKeyIndex(), GImGui, ImGuiContext::IO, ImGui::IsKeyDown(), and ImGuiIO::KeysDown.

Referenced by Slic3r::GUI::ImGuiWrapper::search_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_mouse_wheel()

static void Slic3r::GUI::process_mouse_wheel ( int & mouse_wheel )

static

{
    if (mouse_wheel > 0)
        scroll_up();
    else if (mouse_wheel < 0)
        scroll_down();
    mouse_wheel = 0;
}

References scroll_down(), and scroll_up().

Referenced by Slic3r::GUI::GLCanvas3D::on_mouse_wheel(), Slic3r::GUI::ImGuiWrapper::search_list(), and Slic3r::GUI::ImGuiWrapper::undo_redo_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ processed_objects_idxs()

static std::vector< int > Slic3r::GUI::processed_objects_idxs	(	const Model &	model,
		const SLAPrint &	sla_print,
		const GLVolumePtrs &	volumes
	)

static

{
    std::vector<int> ret;
    GLVolumePtrs matching_volumes;
    std::copy_if(volumes.begin(), volumes.end(), std::back_inserter(matching_volumes), [](GLVolume* v) {
        return v->volume_idx() == -(int)slaposDrillHoles; });
    for (const GLVolume* v : matching_volumes) {
        const int mo_idx = v->object_idx();
        const ModelObject* model_object = (mo_idx < (int)model.objects.size()) ? model.objects[mo_idx] : nullptr;
        if (model_object != nullptr && model_object->instances[v->instance_idx()]->is_printable()) {
            const SLAPrintObject* print_object = sla_print.get_print_object_by_model_object_id(model_object->id());
            if (print_object != nullptr && print_object->get_parts_to_slice().size() > 1)
                ret.push_back(mo_idx);
        }
    }
    std::sort(ret.begin(), ret.end());
    ret.erase(std::unique(ret.begin(), ret.end()), ret.end());
    return ret;
};

References Slic3r::SLAPrintObject::get_parts_to_slice(), Slic3r::SLAPrint::get_print_object_by_model_object_id(), Slic3r::ObjectBase::id(), Slic3r::GLVolume::instance_idx(), Slic3r::ModelObject::instances, Slic3r::GLVolume::object_idx(), Slic3r::Model::objects, and Slic3r::GUI::GLCanvas3D::sla_print().

Referenced by Slic3r::GUI::GLCanvas3D::SLAView::render_switch_button(), and Slic3r::GUI::GLCanvas3D::SLAView::update_volumes_visibility().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ queue_job() [1/3]

template<class ProcessFn , class = std::enable_if_t<IsProcessFn<ProcessFn>>>

bool Slic3r::GUI::queue_job	(	Worker &	w,
		ProcessFn	fn
	)

{
    return queue_job(w, std::move(fn), [](bool, std::exception_ptr &) {});
}

References queue_job().

Here is the call graph for this function:

◆ queue_job() [2/3]

template<class ProcessFn , class FinishFn , class = std::enable_if_t<IsProcessFn<ProcessFn>>, class = std::enable_if_t<IsFinishFn<FinishFn>>>

bool Slic3r::GUI::queue_job	(	Worker &	w,
		ProcessFn	fn,
		FinishFn	finishfn
	)

{
    struct LambdaJob: Job {
        ProcessFn fn;
        FinishFn  finishfn;
 
        LambdaJob(ProcessFn pfn, FinishFn ffn)
            : fn{std::move(pfn)}, finishfn{std::move(ffn)}
        {}
 
        void process(Ctl &ctl) override { fn(ctl); }
        void finalize(bool canceled, std::exception_ptr &eptr) override
        {
            finishfn(canceled, eptr);
        }
    };
 
    auto j = std::make_unique<LambdaJob>(std::move(fn), std::move(finishfn));
    return w.push(std::move(j));
}

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_font_preview(), Slic3r::GUI::Emboss::StyleManager::init_style_images(), Slic3r::GUI::GLGizmoEmboss::process(), queue_job(), replace_job(), priv::start_create_object_job(), and priv::start_create_volume_job().

Here is the caller graph for this function:

◆ queue_job() [3/3]

bool Slic3r::GUI::queue_job	(	Worker &	w,
		std::unique_ptr< Job >	j
	)

inline

{
    return w.push(std::move(j));
}

References Slic3r::GUI::Worker::push().

Here is the call graph for this function:

◆ ray_from_camera()

std::optional< RaycastManager::Hit > Slic3r::GUI::ray_from_camera	(	const RaycastManager &	raycaster,
		const Vec2d &	mouse_pos,
		const Camera &	camera,
		const RaycastManager::ISkip *	skip
	)

Unproject on mesh by Mesh raycasters.

Parameters

mouse_pos	Position of mouse on screen
camera	Projection params
skip	Define which caster will be skipped, null mean no skip

Returns

Position on surface, normal direction in world coorinate

key, to know hitted instance and volume

{
    Vec3d point;
    Vec3d direction;
    CameraUtils::ray_from_screen_pos(camera, mouse_pos, point, direction);
    return raycaster.first_hit(point, direction, skip);
}

References Slic3r::GUI::RaycastManager::first_hit(), and Slic3r::GUI::CameraUtils::ray_from_screen_pos().

Referenced by on_mouse_surface_drag(), and priv::start_create_volume_on_surface_job().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reloadable_volumes()

static std::vector< std::pair< int, int > > Slic3r::GUI::reloadable_volumes	(	const Model &	model,
		const Selection &	selection
	)

static

{
    std::vector<std::pair<int, int>> ret;
    const std::set<unsigned int>& selected_volumes_idxs = selection.get_volume_idxs();
    for (unsigned int idx : selected_volumes_idxs) {
        const GLVolume& v = *selection.get_volume(idx);
        const int o_idx = v.object_idx();
        if (0 <= o_idx && o_idx < int(model.objects.size())) {
            const ModelObject* obj = model.objects[o_idx];
            const int v_idx = v.volume_idx();
            if (0 <= v_idx && v_idx < int(obj->volumes.size())) {
                const ModelVolume* vol = obj->volumes[v_idx];
                if (!vol->source.is_from_builtin_objects && !vol->source.input_file.empty() &&
                    !fs::path(vol->source.input_file).extension().string().empty())
                    ret.push_back({ o_idx, v_idx });
            }
        }
    }
    return ret;
}

References Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::ModelVolume::Source::input_file, Slic3r::ModelVolume::Source::is_from_builtin_objects, Slic3r::GUI::Plater::model(), Slic3r::GLVolume::object_idx(), Slic3r::Model::objects, Slic3r::ModelVolume::source, Slic3r::GLVolume::volume_idx(), and Slic3r::ModelObject::volumes.

Referenced by Slic3r::GUI::Plater::priv::can_reload_from_disk(), and Slic3r::GUI::Plater::priv::reload_from_disk().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_extruders_combo()

static void Slic3r::GUI::render_extruders_combo	(	const std::string &	label,
		const std::vector< std::string > &	extruders,
		const std::vector< ColorRGBA > &	extruders_colors,
		size_t &	selection_idx
	)

static

{
    assert(!extruders_colors.empty());
    assert(extruders_colors.size() == extruders_colors.size());
 
    size_t selection_out = selection_idx;
    // It is necessary to use BeginGroup(). Otherwise, when using SameLine() is called, then other items will be drawn inside the combobox.
    ImGui::BeginGroup();
    ImVec2 combo_pos = ImGui::GetCursorScreenPos();
    if (ImGui::BeginCombo(label.c_str(), "")) {
        for (size_t extruder_idx = 0; extruder_idx < std::min(extruders.size(), GLGizmoMmuSegmentation::EXTRUDERS_LIMIT); ++extruder_idx) {
            ImGui::PushID(int(extruder_idx));
            ImVec2 start_position = ImGui::GetCursorScreenPos();
 
            if (ImGui::Selectable("", extruder_idx == selection_idx))
                selection_out = extruder_idx;
 
            ImGui::SameLine();
            ImGuiStyle &style  = ImGui::GetStyle();
            float       height = ImGui::GetTextLineHeight();
            ImGui::GetWindowDrawList()->AddRectFilled(start_position, ImVec2(start_position.x + height + height / 2, start_position.y + height), ImGuiWrapper::to_ImU32(extruders_colors[extruder_idx]));
            ImGui::GetWindowDrawList()->AddRect(start_position, ImVec2(start_position.x + height + height / 2, start_position.y + height), IM_COL32_BLACK);
 
            ImGui::SetCursorScreenPos(ImVec2(start_position.x + height + height / 2 + style.FramePadding.x, start_position.y));
            ImGui::Text("%s", extruders[extruder_idx].c_str());
            ImGui::PopID();
        }
 
        ImGui::EndCombo();
    }
 
    ImVec2      backup_pos = ImGui::GetCursorScreenPos();
    ImGuiStyle &style      = ImGui::GetStyle();
 
    ImGui::SetCursorScreenPos(ImVec2(combo_pos.x + style.FramePadding.x, combo_pos.y + style.FramePadding.y));
    ImVec2 p      = ImGui::GetCursorScreenPos();
    float  height = ImGui::GetTextLineHeight();
 
    ImGui::GetWindowDrawList()->AddRectFilled(p, ImVec2(p.x + height + height / 2, p.y + height), ImGuiWrapper::to_ImU32(extruders_colors[selection_idx]));
    ImGui::GetWindowDrawList()->AddRect(p, ImVec2(p.x + height + height / 2, p.y + height), IM_COL32_BLACK);
 
    ImGui::SetCursorScreenPos(ImVec2(p.x + height + height / 2 + style.FramePadding.x, p.y));
    ImGui::Text("%s", extruders[selection_out].c_str());
    ImGui::SetCursorScreenPos(backup_pos);
    ImGui::EndGroup();
 
    selection_idx = selection_out;
}

References ImDrawList::AddRect(), ImDrawList::AddRectFilled(), ImGui::BeginCombo(), ImGui::BeginGroup(), ImGui::EndCombo(), ImGui::EndGroup(), Slic3r::GUI::GLGizmoMmuSegmentation::EXTRUDERS_LIMIT, ImGui::GetCursorScreenPos(), ImGui::GetStyle(), ImGui::GetTextLineHeight(), ImGui::GetWindowDrawList(), IM_COL32_BLACK, ImGui::PopID(), ImGui::PushID(), ImGui::SameLine(), ImGui::Selectable(), ImGui::SetCursorScreenPos(), style, ImGui::Text(), Slic3r::GUI::ImGuiWrapper::to_ImU32(), ImVec2::x, and ImVec2::y.

Referenced by Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ replace_job()

template<class... Args>

bool Slic3r::GUI::replace_job	(	Worker &	w,
		Args &&...	args
	)

{
    w.cancel_all();
    return queue_job(w, std::forward<Args>(args)...);
}

References Slic3r::GUI::Worker::cancel_all(), and queue_job().

Referenced by Slic3r::GUI::GLGizmoRotate3D::RotoptimzeWindow::RotoptimzeWindow(), Slic3r::GUI::Plater::arrange(), Slic3r::GUI::Plater::cut(), Slic3r::GUI::Plater::fill_bed_with_instances(), and Slic3r::GUI::Plater::import_sl1_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rescale_children()

static void Slic3r::GUI::rescale_children ( ModelNode * parent )

static

{
    if (parent->IsContainer()) {
        for (std::unique_ptr<ModelNode> &child : parent->GetChildren()) {
            child->UpdateIcons();
            rescale_children(child.get());
        }
    }
}

References Slic3r::GUI::ModelNode::GetChildren(), Slic3r::GUI::ModelNode::IsContainer(), and rescale_children().

Referenced by Slic3r::GUI::DiffModel::Rescale(), and rescale_children().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ round_to_bin()

static float Slic3r::GUI::round_to_bin ( const float value )

static

{
//    assert(value >= 0);
    constexpr float const scale    [5] = { 100.f,  1000.f,  10000.f,  100000.f,  1000000.f };
    constexpr float const invscale [5] = { 0.01f,  0.001f,  0.0001f,  0.00001f,  0.000001f };
    constexpr float const threshold[5] = { 0.095f, 0.0095f, 0.00095f, 0.000095f, 0.0000095f };
    // Scaling factor, pointer to the tables above.
    int                   i            = 0;
    // While the scaling factor is not yet large enough to get two integer digits after scaling and rounding:
    for (; value < threshold[i] && i < 4; ++ i) ;
    // At least on MSVC std::round() calls a complex function, which is pretty expensive.
    // our fast_round_up is much cheaper and it could be inlined.
//    return std::round(value * scale[i]) * invscale[i];
    double a = value * scale[i];
    assert(std::abs(a) < double(std::numeric_limits<int64_t>::max()));
    return fast_round_up<int64_t>(a) * invscale[i];
}

References scale().

Referenced by Slic3r::GUI::GCodeViewer::TBuffer::add_path(), Slic3r::GUI::GCodeViewer::Path::matches(), and Slic3r::GUI::GCodeViewer::refresh().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ run_wizard()

static void Slic3r::GUI::run_wizard ( ConfigWizard::StartPage sp )

static

{
    wxGetApp().run_wizard(ConfigWizard::RR_USER, sp);
}

References Slic3r::GUI::ConfigWizard::RR_USER.

Referenced by Slic3r::GUI::PlaterPresetComboBox::OnSelect(), Slic3r::GUI::TabPresetComboBox::OnSelect(), Slic3r::GUI::PlaterPresetComboBox::show_add_menu(), and Slic3r::GUI::PlaterPresetComboBox::show_edit_menu().

Here is the caller graph for this function:

◆ save_version()

static void Slic3r::GUI::save_version ( )

static

{
    wxGetApp().app_config->set("version_system_info_sent", std::string(SLIC3R_VERSION));
}

Referenced by Slic3r::GUI::SendSystemInfoDialog::SendSystemInfoDialog().

Here is the caller graph for this function:

◆ scene_selection()

static const Selection & Slic3r::GUI::scene_selection ( )

static

{
    return wxGetApp().plater()->canvas3D()->get_selection();
}

Referenced by Slic3r::GUI::ObjectList::can_split_instances(), Slic3r::GUI::ObjectList::is_instance_or_object_selected(), Slic3r::GUI::ObjectList::is_selected_object_cut(), Slic3r::GUI::ObjectList::layers_editing(), Slic3r::GUI::ObjectList::load_generic_subobject(), Slic3r::GUI::ObjectList::load_modifier(), Slic3r::GUI::ObjectList::part_selection_changed(), Slic3r::GUI::ObjectList::selection_changed(), Slic3r::GUI::ObjectList::split_instances(), and Slic3r::GUI::ObjectList::update_selections().

Here is the caller graph for this function:

◆ scroll_down()

static void Slic3r::GUI::scroll_down ( )

static

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    float item_size_y = window->DC.PrevLineSize.y + g.Style.ItemSpacing.y;
    float win_top = window->Scroll.y;
 
    ImGui::SetScrollY(win_top + item_size_y);
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, ImGuiStyle::ItemSpacing, ImGuiWindowTempData::PrevLineSize, ImGuiWindow::Scroll, ImGui::SetScrollY(), ImGuiContext::Style, and ImVec2::y.

Referenced by process_mouse_wheel(), and Slic3r::GUI::ImGuiWrapper::search_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scroll_up()

static void Slic3r::GUI::scroll_up ( )

static

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    float item_size_y = window->DC.PrevLineSize.y + g.Style.ItemSpacing.y;
    float win_top = window->Scroll.y;
 
    ImGui::SetScrollY(win_top - item_size_y);
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, ImGuiStyle::ItemSpacing, ImGuiWindowTempData::PrevLineSize, ImGuiWindow::Scroll, ImGui::SetScrollY(), ImGuiContext::Style, and ImVec2::y.

Referenced by process_mouse_wheel(), and Slic3r::GUI::ImGuiWrapper::search_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scroll_y()

static void Slic3r::GUI::scroll_y ( int hover_id )

static

{
    if (hover_id < 0)
        return;
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
 
    float item_size_y = window->DC.PrevLineSize.y + g.Style.ItemSpacing.y;
    float item_delta = 0.5 * item_size_y;
 
    float item_top = item_size_y * hover_id;
    float item_bottom = item_top + item_size_y;
 
    float win_top = window->Scroll.y;
    float win_bottom = window->Scroll.y + window->Size.y;
 
    if (item_bottom + item_delta >= win_bottom)
        ImGui::SetScrollY(win_top + item_size_y);
    else if (item_top - item_delta <= win_top)
        ImGui::SetScrollY(win_top - item_size_y);
}

References ImGuiContext::CurrentWindow, ImGuiWindow::DC, GImGui, ImGuiStyle::ItemSpacing, ImGuiWindowTempData::PrevLineSize, ImGuiWindow::Scroll, ImGui::SetScrollY(), ImGuiWindow::Size, ImGuiContext::Style, and ImVec2::y.

Here is the call graph for this function:

◆ search_string_getter()

static bool Slic3r::GUI::search_string_getter	(	int	idx,
		const char **	label,
		const char **	tooltip
	)

static

{
    return wxGetApp().plater()->search_string_getter(idx, label, tooltip);
}

Referenced by Slic3r::GUI::GLCanvas3D::_render_search_list().

Here is the caller graph for this function:

◆ selectable()

static bool Slic3r::GUI::selectable	(	const char *	label,
		bool	selected,
		ImGuiSelectableFlags	flags = `0`,
		const ImVec2 &	size_arg = `ImVec2(0, 0)`
	)

static

{
    ImGuiWindow* window = ImGui::GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
 
    // Submit label or explicit size to ItemSize(), whereas ItemAdd() will submit a larger/spanning rectangle.
    ImGuiID id = window->GetID(label);
    ImVec2 label_size = ImGui::CalcTextSize(label, NULL, true);
    ImVec2 size(size_arg.x != 0.0f ? size_arg.x : label_size.x, size_arg.y != 0.0f ? size_arg.y : label_size.y);
    ImVec2 pos = window->DC.CursorPos;
    pos.y += window->DC.CurrLineTextBaseOffset;
    ImGui::ItemSize(size, 0.0f);
 
    // Fill horizontal space
    // We don't support (size < 0.0f) in Selectable() because the ItemSpacing extension would make explicitly right-aligned sizes not visibly match other widgets.
    const bool span_all_columns = (flags & ImGuiSelectableFlags_SpanAllColumns) != 0;
    const float min_x = span_all_columns ? window->ParentWorkRect.Min.x : pos.x;
    const float max_x = span_all_columns ? window->ParentWorkRect.Max.x : window->WorkRect.Max.x;
    if (size_arg.x == 0.0f || (flags & ImGuiSelectableFlags_SpanAvailWidth))
        size.x = ImMax(label_size.x, max_x - min_x);
 
    // Text stays at the submission position, but bounding box may be extended on both sides
    const ImVec2 text_min = pos;
    const ImVec2 text_max(min_x + size.x, pos.y + size.y);
 
    // Selectables are meant to be tightly packed together with no click-gap, so we extend their box to cover spacing between selectable.
    ImRect bb(min_x, pos.y, text_max.x, text_max.y);
    if ((flags & ImGuiSelectableFlags_NoPadWithHalfSpacing) == 0)
    {
        const float spacing_x = span_all_columns ? 0.0f : style.ItemSpacing.x;
        const float spacing_y = style.ItemSpacing.y;
        const float spacing_L = IM_FLOOR(spacing_x * 0.50f);
        const float spacing_U = IM_FLOOR(spacing_y * 0.50f);
        bb.Min.x -= spacing_L;
        bb.Min.y -= spacing_U;
        bb.Max.x += (spacing_x - spacing_L);
        bb.Max.y += (spacing_y - spacing_U);
    }
    //if (g.IO.KeyCtrl) { GetForegroundDrawList()->AddRect(bb.Min, bb.Max, IM_COL32(0, 255, 0, 255)); }
 
    // Modify ClipRect for the ItemAdd(), faster than doing a PushColumnsBackground/PushTableBackground for every Selectable..
    const float backup_clip_rect_min_x = window->ClipRect.Min.x;
    const float backup_clip_rect_max_x = window->ClipRect.Max.x;
    if (span_all_columns)
    {
        window->ClipRect.Min.x = window->ParentWorkRect.Min.x;
        window->ClipRect.Max.x = window->ParentWorkRect.Max.x;
    }
 
    bool item_add;
    if (flags & ImGuiSelectableFlags_Disabled)
    {
        ImGuiItemFlags backup_item_flags = g.CurrentItemFlags;
        g.CurrentItemFlags |= ImGuiItemFlags_Disabled | ImGuiItemFlags_NoNavDefaultFocus;
        item_add = ImGui::ItemAdd(bb, id);
        g.CurrentItemFlags = backup_item_flags;
    }
    else
    {
        item_add = ImGui::ItemAdd(bb, id);
    }
 
    if (span_all_columns)
    {
        window->ClipRect.Min.x = backup_clip_rect_min_x;
        window->ClipRect.Max.x = backup_clip_rect_max_x;
    }
 
    if (!item_add)
        return false;
 
    // FIXME: We can standardize the behavior of those two, we could also keep the fast path of override ClipRect + full push on render only,
    // which would be advantageous since most selectable are not selected.
    if (span_all_columns && window->DC.CurrentColumns)
        ImGui::PushColumnsBackground();
    else if (span_all_columns && g.CurrentTable)
        ImGui::TablePushBackgroundChannel();
 
    // We use NoHoldingActiveID on menus so user can click and _hold_ on a menu then drag to browse child entries
    ImGuiButtonFlags button_flags = 0;
    if (flags & ImGuiSelectableFlags_NoHoldingActiveID) { button_flags |= ImGuiButtonFlags_NoHoldingActiveId; }
    if (flags & ImGuiSelectableFlags_SelectOnClick)     { button_flags |= ImGuiButtonFlags_PressedOnClick; }
    if (flags & ImGuiSelectableFlags_SelectOnRelease)   { button_flags |= ImGuiButtonFlags_PressedOnRelease; }
    if (flags & ImGuiSelectableFlags_Disabled)          { button_flags |= ImGuiButtonFlags_Disabled; }
    if (flags & ImGuiSelectableFlags_AllowDoubleClick)  { button_flags |= ImGuiButtonFlags_PressedOnClickRelease | ImGuiButtonFlags_PressedOnDoubleClick; }
    if (flags & ImGuiSelectableFlags_AllowItemOverlap)  { button_flags |= ImGuiButtonFlags_AllowItemOverlap; }
 
    if (flags & ImGuiSelectableFlags_Disabled)
        selected = false;
 
    const bool was_selected = selected;
    bool hovered, held;
    bool pressed = ImGui::ButtonBehavior(bb, id, &hovered, &held, button_flags);
 
    // Update NavId when clicking or when Hovering (this doesn't happen on most widgets), so navigation can be resumed with gamepad/keyboard
    if (pressed || (hovered && (flags & ImGuiSelectableFlags_SetNavIdOnHover)))
    {
        if (!g.NavDisableMouseHover && g.NavWindow == window && g.NavLayer == window->DC.NavLayerCurrent)
        {
            ImGui::SetNavID(id, window->DC.NavLayerCurrent, window->DC.NavFocusScopeIdCurrent, ImRect(bb.Min - window->Pos, bb.Max - window->Pos));
            g.NavDisableHighlight = true;
        }
    }
    if (pressed)
        ImGui::MarkItemEdited(id);
 
    if (flags & ImGuiSelectableFlags_AllowItemOverlap)
        ImGui::SetItemAllowOverlap();
 
    // In this branch, Selectable() cannot toggle the selection so this will never trigger.
    if (selected != was_selected) //-V547
        window->DC.LastItemStatusFlags |= ImGuiItemStatusFlags_ToggledSelection;
 
    // Render
    if (held && (flags & ImGuiSelectableFlags_DrawHoveredWhenHeld))
        hovered = true;
    if (hovered || selected)
    {
        const ImU32 col = ImGui::GetColorU32((held && hovered) ? ImGuiCol_HeaderActive : hovered ? ImGuiCol_HeaderHovered : ImGuiCol_Header);
        ImGui::RenderFrame(bb.Min, bb.Max, col, false, 0.0f);
        ImGui::RenderNavHighlight(bb, id, ImGuiNavHighlightFlags_TypeThin | ImGuiNavHighlightFlags_NoRounding);
    }
 
    if (span_all_columns && window->DC.CurrentColumns)
        ImGui::PopColumnsBackground();
    else if (span_all_columns && g.CurrentTable)
        ImGui::TablePopBackgroundChannel();
 
    // mark a label with a ColorMarkerHovered, if item is hovered
    char marked_label[512]; //255 symbols is not enough for translated string (e.t. to Russian)
    if (hovered)
        sprintf(marked_label, "%c%s", ImGui::ColorMarkerHovered, label);
    else
        strcpy(marked_label, label);
 
    if (flags & ImGuiSelectableFlags_Disabled) ImGui::PushStyleColor(ImGuiCol_Text, style.Colors[ImGuiCol_TextDisabled]);
    ImGui::RenderTextClipped(text_min, text_max, marked_label, NULL, &label_size, style.SelectableTextAlign, &bb);
    if (flags & ImGuiSelectableFlags_Disabled) ImGui::PopStyleColor();
 
    // Automatically close popups
    if (pressed && (window->Flags & ImGuiWindowFlags_Popup) && !(flags & ImGuiSelectableFlags_DontClosePopups) && !(g.CurrentItemFlags & ImGuiItemFlags_SelectableDontClosePopup))
        ImGui::CloseCurrentPopup();
 
    IMGUI_TEST_ENGINE_ITEM_INFO(id, label, window->DC.LastItemStatusFlags);
    return pressed;
}

Referenced by Slic3r::GUI::GLGizmosManager::get_gizmo_from_mouse(), and Slic3r::GUI::ImGuiWrapper::search_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_font_and_background_style()

static void Slic3r::GUI::set_font_and_background_style	(	wxWindow *	win,
		const wxFont &	font
	)

static

{
    win->SetFont(font);
    win->SetBackgroundStyle(wxBG_STYLE_PAINT);
}

Referenced by Slic3r::GUI::ManipulationEditor::ManipulationEditor(), Slic3r::GUI::ObjectManipulation::ObjectManipulation(), Slic3r::GUI::ObjectManipulation::update_if_dirty(), and Slic3r::GUI::ObjectManipulation::update_ui_from_settings().

Here is the caller graph for this function:

◆ shortkey_alt_prefix()

const std::string & Slic3r::GUI::shortkey_alt_prefix ( )

{
  static const std::string str =
#ifdef __APPLE__
    "⌥"
#else
    "Alt+"
#endif
    ;
  return str;
}

Referenced by Slic3r::GUI::SlaGizmoHelpDialog::SlaGizmoHelpDialog(), Slic3r::GUI::KBShortcutsDialog::fill_shortcuts(), and Slic3r::GUI::GLGizmoCut3D::on_init().

Here is the caller graph for this function:

◆ shortkey_ctrl_prefix()

const std::string & Slic3r::GUI::shortkey_ctrl_prefix ( )

{
  static const std::string str =
#ifdef __APPLE__
    "⌘"
#else
    "Ctrl+"
#endif
    ;
  return str;
}

Referenced by Slic3r::GUI::Sidebar::Sidebar(), Slic3r::GUI::SlaGizmoHelpDialog::SlaGizmoHelpDialog(), Slic3r::GUI::GLCanvas3D::_init_main_toolbar(), Slic3r::GUI::GLCanvas3D::_init_undoredo_toolbar(), Slic3r::GUI::GLCanvas3D::_render_arrange_menu(), Slic3r::GUI::KBShortcutsDialog::fill_shortcuts(), Slic3r::GUI::MainFrame::init_menubar_as_editor(), Slic3r::GUI::Plater::priv::init_view_toolbar(), Slic3r::GUI::GLGizmoCut3D::on_init(), Slic3r::GUI::NotificationManager::PrintHostUploadNotification::render_cancel_button(), Slic3r::GUI::NotificationManager::ExportFinishedNotification::render_eject_button(), Slic3r::GUI::Sidebar::update_reslice_btn_tooltip(), and Slic3r::GUI::GLCanvas3D::update_tooltip_for_settings_item_in_main_toolbar().

Here is the caller graph for this function:

◆ should_dialog_be_shown()

static bool Slic3r::GUI::should_dialog_be_shown ( )

static

{
    std::string last_sent_version = wxGetApp().app_config->get("version_system_info_sent");
    Semver semver_current(SLIC3R_VERSION);
    Semver semver_last_sent;
    if (! last_sent_version.empty())
        semver_last_sent = Semver(last_sent_version);
 
    // set whether to show in alpha builds, or only betas/rcs/finals:
    const bool show_in_alphas = true;
 
    if (! show_in_alphas && semver_current.prerelease()
       && std::string(semver_current.prerelease()).find("alpha") != std::string::npos)
            return false;
 
    // New version means current > last, but they must differ in more than just patch.
    bool new_version = ((semver_current.maj() > semver_last_sent.maj())
        || (semver_current.maj() == semver_last_sent.maj() && semver_current.min() > semver_last_sent.min() ));
 
    if (! new_version)
        return false;
 
    // We might want to check that the internet connection is ready so we don't open the dialog
    // if it cannot really send any data. Using a dummy HTTP GET request led to
    // https://forum.prusaprinters.org/forum/prusaslicer/prusaslicer-2-4-0-beta1-is-out/#post-518488.
    // It might also trigger security softwares, which would look bad and would lead to questions
    // about what PS is doing. We better use some less intrusive way of checking the connection.
 
    // As of now, this is only implemented on Win. The other platforms do not check beforehand.
 
#ifdef _WIN32
    return check_internet_connection_win();
#else
    return true;
#endif
}

References Slic3r::Semver::maj(), Slic3r::Semver::min(), and Slic3r::Semver::prerelease().

Referenced by show_send_system_info_dialog_if_needed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ show_error() [1/3]

void Slic3r::GUI::show_error	(	wxWindow *	parent,
		const char *	message,
		bool	monospaced_font
	)

{
  assert(message);
  show_error(parent, wxString::FromUTF8(message), monospaced_font);
}

References show_error().

Here is the call graph for this function:

◆ show_error() [2/3]

void Slic3r::GUI::show_error	(	wxWindow *	parent,
		const std::string &	message,
		bool	monospaced_font = `false`
	)

inline

47{ show_error(parent, message.c_str(), monospaced_font); }

References show_error().

Here is the call graph for this function:

◆ show_error() [3/3]

void Slic3r::GUI::show_error	(	wxWindow *	parent,
		const wxString &	message,
		bool	monospaced_font
	)

{
  ErrorDialog msg(parent, message, monospaced_font);
  msg.ShowModal();
}

Here is the caller graph for this function:

◆ show_error_id()

void Slic3r::GUI::show_error_id	(	int	id,
		const std::string &	message
	)

{
  auto *parent = id != 0 ? wxWindow::FindWindowById(id) : nullptr;
  show_error(parent, message);
}

References show_error().

Here is the call graph for this function:

◆ show_info() [1/3]

void Slic3r::GUI::show_info	(	wxWindow *	parent,
		const char *	message,
		const char *	title
	)

{
  assert(message);
  show_info(parent, wxString::FromUTF8(message), title ? wxString::FromUTF8(title) : wxString());
}

References show_info().

Here is the call graph for this function:

◆ show_info() [2/3]

void Slic3r::GUI::show_info	(	wxWindow *	parent,
		const std::string &	message,
		const std::string &	title = `std::string()`
	)

inline

51{ show_info(parent, message.c_str(), title.c_str()); }

References show_info().

Here is the call graph for this function:

◆ show_info() [3/3]

void Slic3r::GUI::show_info	(	wxWindow *	parent,
		const wxString &	message,
		const wxString &	title
	)

{
  //wxMessageDialog msg_wingow(parent, message, wxString(SLIC3R_APP_NAME " - ") + (title.empty() ? _L("Notice") : title), wxOK | wxICON_INFORMATION);
  MessageDialog msg_wingow(parent, message, wxString(SLIC3R_APP_NAME " - ") + (title.empty() ? _L("Notice") : title), wxOK | wxICON_INFORMATION);
  msg_wingow.ShowModal();
}

References _L.

Referenced by Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings(), Slic3r::GUI::ObjectList::check_last_selection(), Slic3r::GUI::SLAImportJob::finalize(), Slic3r::GUI::ObjectList::fix_multiselection_conflicts(), Slic3r::GUI::MainFrame::load_configbundle(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::Plater::priv::load_model_objects(), Slic3r::GUI::GUI_App::may_switch_to_SLA_preset(), Slic3r::GUI::MainFrame::repair_stl(), Slic3r::GUI::GUI_App::save_mode(), show_info(), and show_info().

Here is the caller graph for this function:

◆ show_notification_extruders_limit_exceeded()

static void Slic3r::GUI::show_notification_extruders_limit_exceeded ( )

inlinestatic

{
    wxGetApp()
        .plater()
        ->get_notification_manager()
        ->push_notification(NotificationType::MmSegmentationExceededExtrudersLimit, NotificationManager::NotificationLevel::PrintInfoNotificationLevel,
                            GUI::format(_L("Your printer has more extruders than the multi-material painting gizmo supports. For this reason, only the "
                                           "first %1% extruders will be able to be used for painting."), GLGizmoMmuSegmentation::EXTRUDERS_LIMIT));
}

References _L, Slic3r::GUI::GLGizmoMmuSegmentation::EXTRUDERS_LIMIT, format(), MmSegmentationExceededExtrudersLimit, and Slic3r::GUI::NotificationManager::PrintInfoNotificationLevel.

Referenced by Slic3r::GUI::GLGizmoMmuSegmentation::data_changed(), and Slic3r::GUI::GLGizmoMmuSegmentation::on_opening().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ show_send_system_info_dialog_if_needed()

void Slic3r::GUI::show_send_system_info_dialog_if_needed ( )

{
    if (wxGetApp().is_gcode_viewer() || ! should_dialog_be_shown())
        return;
 
    SendSystemInfoDialog dlg(wxGetApp().mainframe);
    dlg.ShowModal();
}

References should_dialog_be_shown().

Referenced by Slic3r::GUI::GUI_App::post_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ show_substitutions_info() [1/2]

void Slic3r::GUI::show_substitutions_info	(	const ConfigSubstitutions &	config_substitutions,
		const std::string &	filename
	)

{
  wxString changes = "\n";
  add_config_substitutions(config_substitutions, changes);
 
  InfoDialog msg(nullptr, 
    format_wxstr(_L("Configuration file \"%1%\" was loaded, however some configuration values were not recognized."), from_u8(filename)), 
    substitution_message(changes), true);
  msg.ShowModal();
}

References _L, add_config_substitutions(), format_wxstr(), from_u8(), and substitution_message().

Here is the call graph for this function:

◆ show_substitutions_info() [2/2]

void Slic3r::GUI::show_substitutions_info ( const PresetsConfigSubstitutions & presets_config_substitutions )

{
  wxString changes;
 
  auto preset_type_name = [](Preset::Type type) {
    switch (type) {
      case Preset::TYPE_PRINT:      return _L("Print settings");
      case Preset::TYPE_SLA_PRINT:    return _L("SLA print settings");
      case Preset::TYPE_FILAMENT:     return _L("Filament");
      case Preset::TYPE_SLA_MATERIAL:   return _L("SLA material");
      case Preset::TYPE_PRINTER:      return _L("Printer");
      case Preset::TYPE_PHYSICAL_PRINTER: return _L("Physical Printer");
      default: assert(false);       return wxString();
    }
  };
 
  for (const PresetConfigSubstitutions& substitution : presets_config_substitutions) {
    changes += "\n\n" + format_wxstr("%1% : %2%", preset_type_name(substitution.preset_type), bold_string(substitution.preset_name));
    if (!substitution.preset_file.empty())
      changes += format_wxstr(" (%1%)", substitution.preset_file);
 
    add_config_substitutions(substitution.substitutions, changes);
  }
 
  InfoDialog msg(nullptr, _L("Configuration bundle was loaded, however some configuration values were not recognized."), substitution_message(changes), true);
  msg.ShowModal();
}

References _L, add_config_substitutions(), bold_string(), format_wxstr(), substitution_message(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PHYSICAL_PRINTER, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, Slic3r::Preset::TYPE_SLA_MATERIAL, and Slic3r::Preset::TYPE_SLA_PRINT.

Referenced by Slic3r::GUI::GUI_App::add_config_menu(), Slic3r::GUI::SLAImportJob::finalize(), Slic3r::GUI::MainFrame::load_config_file(), Slic3r::GUI::MainFrame::load_configbundle(), Slic3r::GUI::Plater::priv::load_files(), and Slic3r::GUI::GUI_App::post_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ show_warning()

static void Slic3r::GUI::show_warning	(	const wxString &	title,
		const std::string &	error_file_type
	)

static

{
    const wxString msg_text = format_wxstr(_L("It looks like selected %1%-file has an error or is destructed.\n"
        "We can't load this file"), error_file_type);
    MessageDialog dialog(nullptr, msg_text, title, wxICON_WARNING | wxOK);
    dialog.ShowModal();
}

References _L, format_wxstr(), and show_warning().

Referenced by Slic3r::GUI::GalleryDialog::change_thumbnail(), Slic3r::GUI::GalleryDialog::load_files(), and show_warning().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sla_wildcards()

wxString Slic3r::GUI::sla_wildcards ( const char * formatid )

{
    const ArchiveEntry *entry = get_archive_entry(formatid);
    wxString ret;
 
    if (entry) {
        FileWildcards wc;
        std::string tr_title = I18N::translate_utf8(entry->desc);
        // TRN %s = type of file
        tr_title = GUI::format(_u8L("%s files"), tr_title);
        wc.title = tr_title;
 
        std::vector<std::string> exts = get_extensions(*entry);
 
        wc.file_extensions.reserve(exts.size());
        for (std::string &ext : exts) {
            ext.insert(ext.begin(), '.');
            wc.file_extensions.emplace_back(ext);
        }
 
        ret = file_wildcards(wc);
    }
 
    if (ret.empty())
        ret = file_wildcards(FT_SL1);
 
    return ret;
}

References _u8L, Slic3r::ArchiveEntry::desc, Slic3r::GUI::FileWildcards::file_extensions, file_wildcards(), format(), FT_SL1, Slic3r::get_archive_entry(), Slic3r::get_extensions(), Slic3r::GUI::FileWildcards::title, and Slic3r::GUI::I18N::translate_utf8().

Referenced by Slic3r::GUI::Plater::export_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smooth_cylinder()

GLModel::Geometry Slic3r::GUI::smooth_cylinder	(	unsigned int	resolution,
		float	radius,
		float	height
	)

{
    resolution = std::max<unsigned int>(4, resolution);
 
    const unsigned int sectorCount = resolution;
    const float sectorStep = 2.0f * float(M_PI) / float(sectorCount);
 
    GLModel::Geometry data;
    data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3N3 };
    data.reserve_vertices(sectorCount * 4 + 2);
    data.reserve_indices(sectorCount * 4 * 3);
 
    auto generate_vertices_on_circle = [sectorCount, sectorStep](float radius) {
        std::vector<Vec3f> ret;
        ret.reserve(sectorCount);
        for (unsigned int i = 0; i < sectorCount; ++i) {
            // from 0 to 2pi
            const float sectorAngle = sectorStep * i;
            ret.emplace_back(radius * std::cos(sectorAngle), radius * std::sin(sectorAngle), 0.0f);
        }
        return ret;
    };
 
    const std::vector<Vec3f> base_vertices = generate_vertices_on_circle(radius);
    const Vec3f h = height * Vec3f::UnitZ();
 
    // stem vertices
    for (unsigned int i = 0; i < sectorCount; ++i) {
        const Vec3f& v = base_vertices[i];
        const Vec3f n = v.normalized();
        data.add_vertex(v, n);
        data.add_vertex(v + h, n);
    }
 
    // stem triangles
    for (unsigned int i = 0; i < sectorCount; ++i) {
        unsigned int v1 = i * 2;
        unsigned int v2 = (i < sectorCount - 1) ? v1 + 2 : 0;
        unsigned int v3 = v2 + 1;
        unsigned int v4 = v1 + 1;
        data.add_triangle(v1, v2, v3);
        data.add_triangle(v1, v3, v4);
    }
 
    // bottom cap vertices
    Vec3f cap_center = Vec3f::Zero();
    unsigned int cap_center_id = data.vertices_count();
    Vec3f normal = -Vec3f::UnitZ();
 
    data.add_vertex(cap_center, normal);
    for (unsigned int i = 0; i < sectorCount; ++i) {
        data.add_vertex(base_vertices[i], normal);
    }
 
    // bottom cap triangles
    for (unsigned int i = 0; i < sectorCount; ++i) {
        data.add_triangle(cap_center_id, (i < sectorCount - 1) ? cap_center_id + i + 2 : cap_center_id + 1, cap_center_id + i + 1);
    }
 
    // top cap vertices
    cap_center += h;
    cap_center_id = data.vertices_count();
    normal = -normal;
 
    data.add_vertex(cap_center, normal);
    for (unsigned int i = 0; i < sectorCount; ++i) {
        data.add_vertex(base_vertices[i] + h, normal);
    }
 
    // top cap triangles
    for (unsigned int i = 0; i < sectorCount; ++i) {
        data.add_triangle(cap_center_id, cap_center_id + i + 1, (i < sectorCount - 1) ? cap_center_id + i + 2 : cap_center_id + 1);
    }
 
    return data;
}

References M_PI, Slic3r::GUI::GLModel::Geometry::P3N3, and Slic3r::GUI::GLModel::Geometry::Triangles.

Referenced by Slic3r::GUI::GLGizmoMeasure::GLGizmoMeasure().

Here is the caller graph for this function:

◆ smooth_sphere()

GLModel::Geometry Slic3r::GUI::smooth_sphere	(	unsigned int	resolution,
		float	radius
	)

{
    resolution = std::max<unsigned int>(4, resolution);
 
    const unsigned int sectorCount = resolution;
    const unsigned int stackCount  = resolution;
 
    const float sectorStep = float(2.0 * M_PI / sectorCount);
    const float stackStep = float(M_PI / stackCount);
 
    GLModel::Geometry data;
    data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3N3 };
    data.reserve_vertices((stackCount - 1) * sectorCount + 2);
    data.reserve_indices((2 * (stackCount - 1) * sectorCount) * 3);
 
    // vertices
    for (unsigned int i = 0; i <= stackCount; ++i) {
        // from pi/2 to -pi/2
        const double stackAngle = 0.5 * M_PI - stackStep * i;
        const double xy = double(radius) * ::cos(stackAngle);
        const double z = double(radius) * ::sin(stackAngle);
        if (i == 0 || i == stackCount) {
            const Vec3f v(float(xy), 0.0f, float(z));
            data.add_vertex(v, (Vec3f)v.normalized());
        }
        else {
            for (unsigned int j = 0; j < sectorCount; ++j) {
                // from 0 to 2pi
                const double sectorAngle = sectorStep * j;
                const Vec3f v(float(xy * std::cos(sectorAngle)), float(xy * std::sin(sectorAngle)), float(z));
                data.add_vertex(v, (Vec3f)v.normalized());
            }
        }
    }
 
    // triangles
    for (unsigned int i = 0; i < stackCount; ++i) {
        // Beginning of current stack.
        unsigned int k1 = (i == 0) ? 0 : (1 + (i - 1) * sectorCount);
        const unsigned int k1_first = k1;
        // Beginning of next stack.
        unsigned int k2 = (i == 0) ? 1 : (k1 + sectorCount);
        const unsigned int k2_first = k2;
        for (unsigned int j = 0; j < sectorCount; ++j) {
            // 2 triangles per sector excluding first and last stacks
            unsigned int k1_next = k1;
            unsigned int k2_next = k2;
            if (i != 0) {
                k1_next = (j + 1 == sectorCount) ? k1_first : (k1 + 1);
                data.add_triangle(k1, k2, k1_next);
            }
            if (i + 1 != stackCount) {
                k2_next = (j + 1 == sectorCount) ? k2_first : (k2 + 1);
                data.add_triangle(k1_next, k2, k2_next);
            }
            k1 = k1_next;
            k2 = k2_next;
        }
    }
 
    return data;
}

References cos(), M_PI, Slic3r::GUI::GLModel::Geometry::P3N3, sin(), and Slic3r::GUI::GLModel::Geometry::Triangles.

Referenced by Slic3r::GUI::GLGizmoMeasure::GLGizmoMeasure(), and Slic3r::GUI::GCodeViewer::COG::init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smooth_torus()

GLModel::Geometry Slic3r::GUI::smooth_torus	(	unsigned int	primary_resolution,
		unsigned int	secondary_resolution,
		float	radius,
		float	thickness
	)

{
    const unsigned int torus_sector_count = std::max<unsigned int>(4, primary_resolution);
    const float torus_sector_step = 2.0f * float(M_PI) / float(torus_sector_count);
    const unsigned int section_sector_count = std::max<unsigned int>(4, secondary_resolution);
    const float section_sector_step = 2.0f * float(M_PI) / float(section_sector_count);
 
    GLModel::Geometry data;
    data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3N3 };
    data.reserve_vertices(torus_sector_count * section_sector_count);
    data.reserve_indices(torus_sector_count * section_sector_count * 2 * 3);
 
    // vertices
    for (unsigned int i = 0; i < torus_sector_count; ++i) {
        const float section_angle = torus_sector_step * i;
        const float csa = std::cos(section_angle);
        const float ssa = std::sin(section_angle);
        const Vec3f section_center(radius * csa, radius * ssa, 0.0f);
        for (unsigned int j = 0; j < section_sector_count; ++j) {
            const float circle_angle = section_sector_step * j;
            const float thickness_xy = thickness * std::cos(circle_angle);
            const float thickness_z  = thickness * std::sin(circle_angle);
            const Vec3f v(thickness_xy * csa, thickness_xy * ssa, thickness_z);
            data.add_vertex(section_center + v, (Vec3f)v.normalized());
        }
    }
 
    // triangles
    for (unsigned int i = 0; i < torus_sector_count; ++i) {
        const unsigned int ii = i * section_sector_count;
        const unsigned int ii_next = ((i + 1) % torus_sector_count) * section_sector_count;
        for (unsigned int j = 0; j < section_sector_count; ++j) {
            const unsigned int j_next = (j + 1) % section_sector_count;
            const unsigned int i0 = ii + j;
            const unsigned int i1 = ii_next + j;
            const unsigned int i2 = ii_next + j_next;
            const unsigned int i3 = ii + j_next;
            data.add_triangle(i0, i1, i2);
            data.add_triangle(i0, i2, i3);
        }
    }
 
    return data;
}

References M_PI, Slic3r::GUI::GLModel::Geometry::P3N3, and Slic3r::GUI::GLModel::Geometry::Triangles.

◆ start_new_gcodeviewer()

void Slic3r::GUI::start_new_gcodeviewer ( const wxString * path_to_open )

{
  start_new_slicer_or_gcodeviewer(NewSlicerInstanceType::GCodeViewer, path_to_open, false, false);
}

References GCodeViewer, and start_new_slicer_or_gcodeviewer().

Referenced by Slic3r::GUI::Plater::load_files(), and start_new_gcodeviewer_open_file().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ start_new_gcodeviewer_open_file()

void Slic3r::GUI::start_new_gcodeviewer_open_file ( wxWindow * parent )

{
    wxFileDialog dialog(parent ? parent : wxGetApp().GetTopWindow(),
        _L("Open G-code file:"),
        from_u8(wxGetApp().app_config->get_last_dir()), wxString(),
        file_wildcards(FT_GCODE), wxFD_OPEN | wxFD_FILE_MUST_EXIST);
    if (dialog.ShowModal() == wxID_OK) {
        wxString path = dialog.GetPath();
    start_new_gcodeviewer(&path);
    }
}

References _L, file_wildcards(), from_u8(), FT_GCODE, and start_new_gcodeviewer().

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ start_new_slicer() [1/2]

void Slic3r::GUI::start_new_slicer	(	const std::vector< wxString > &	files,
		bool	single_instance,
		bool	delete_after_load
	)

{
  start_new_slicer_or_gcodeviewer(NewSlicerInstanceType::Slicer, files, single_instance, delete_after_load);
}

References Slicer, and start_new_slicer_or_gcodeviewer().

Here is the call graph for this function:

◆ start_new_slicer() [2/2]

void Slic3r::GUI::start_new_slicer	(	const wxString *	path_to_open,
		bool	single_instance,
		bool	delete_after_load
	)

{
  start_new_slicer_or_gcodeviewer(NewSlicerInstanceType::Slicer, path_to_open, single_instance, delete_after_load);
}

References Slicer, and start_new_slicer_or_gcodeviewer().

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor(), Slic3r::GUI::MainFrame::init_menubar_as_gcodeviewer(), Slic3r::GUI::Plater::load_files(), and Slic3r::GUI::Plater::preview_zip_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ start_new_slicer_or_gcodeviewer() [1/2]

static void Slic3r::GUI::start_new_slicer_or_gcodeviewer	(	const NewSlicerInstanceType	instance_type,
		const std::vector< wxString >	paths_to_open,
		bool	single_instance,
		bool	delete_after_load
	)

static

{
#ifdef _WIN32
  wxString path;
  wxFileName::SplitPath(wxStandardPaths::Get().GetExecutablePath(), &path, nullptr, nullptr, wxPATH_NATIVE);
  path += "\\";
  path += (instance_type == NewSlicerInstanceType::Slicer) ? "prusa-slicer.exe" : "prusa-gcodeviewer.exe";
  std::vector<const wchar_t*> args;
  args.reserve(4);
  args.emplace_back(path.wc_str());
  if (!paths_to_open.empty()) {
    for (const auto& file : paths_to_open)
      args.emplace_back(file);
  }
  if (instance_type == NewSlicerInstanceType::Slicer && single_instance)
    args.emplace_back(L"--single-instance");
  if(delete_after_load && !paths_to_open.empty())
    args.emplace_back(L"--delete-after-load=1");
 
  args.emplace_back(nullptr);
  BOOST_LOG_TRIVIAL(info) << "Trying to spawn a new slicer \"" << into_u8(path) << "\"";
  // Don't call with wxEXEC_HIDE_CONSOLE, PrusaSlicer in GUI mode would just show the splash screen. It would not open the main window though, it would
  // just hang in the background.
  if (wxExecute(const_cast<wchar_t**>(args.data()), wxEXEC_ASYNC) <= 0)
    BOOST_LOG_TRIVIAL(error) << "Failed to spawn a new slicer \"" << into_u8(path);
#else 
  // Own executable path.
  boost::filesystem::path bin_path = into_path(wxStandardPaths::Get().GetExecutablePath());
#if defined(__APPLE__)
  {
    // Maybe one day we will be able to run PrusaGCodeViewer, but for now the Apple notarization 
    // process refuses Apps with multiple binaries and Vojtech does not know any workaround.
    // ((instance_type == NewSlicerInstanceType::Slicer) ? "PrusaSlicer" : "PrusaGCodeViewer");
    // Just run PrusaSlicer and give it a --gcodeviewer parameter.
    bin_path = bin_path.parent_path() / "PrusaSlicer";
    // On Apple the wxExecute fails, thus we use boost::process instead.
    BOOST_LOG_TRIVIAL(info) << "Trying to spawn a new slicer \"" << bin_path.string() << "\"";
    try {
      std::vector<std::string> args;
      if (instance_type == NewSlicerInstanceType::GCodeViewer)
        args.emplace_back("--gcodeviewer");
      if (!paths_to_open.empty()) {
        for (const auto& file : paths_to_open)
          args.emplace_back(into_u8(file));
      }
      if (instance_type == NewSlicerInstanceType::Slicer && single_instance)
        args.emplace_back("--single-instance");
      if (delete_after_load && !paths_to_open.empty())
        args.emplace_back("--delete-after-load=1");
      boost::process::spawn(bin_path, args);
        // boost::process::spawn() sets SIGCHLD to SIGIGN for the child process, thus if a child PrusaSlicer spawns another
        // subprocess and the subrocess dies, the child PrusaSlicer will not receive information on end of subprocess
        // (posix waitpid() call will always fail).
        // https://jmmv.dev/2008/10/boostprocess-and-sigchld.html
        // The child instance of PrusaSlicer has to reset SIGCHLD to its default, so that posix waitpid() and similar continue to work.
        // See GH issue #5507
    }
    catch (const std::exception& ex) {
      BOOST_LOG_TRIVIAL(error) << "Failed to spawn a new slicer \"" << bin_path.string() << "\": " << ex.what();
    }
  }
#else // Linux or Unix
  {
    std::vector<const char*> args;
    args.reserve(3);
#ifdef __linux__
    static const char* gcodeviewer_param = "--gcodeviewer";
    {
      // If executed by an AppImage, start the AppImage, not the main process.
      // see https://docs.appimage.org/packaging-guide/environment-variables.html#id2
      const char* appimage_binary = std::getenv("APPIMAGE");
      if (appimage_binary) {
        args.emplace_back(appimage_binary);
        if (instance_type == NewSlicerInstanceType::GCodeViewer)
          args.emplace_back(gcodeviewer_param);
      }
    }
#endif // __linux__
    std::string my_path;
    if (args.empty()) {
      // Binary path was not set to the AppImage in the Linux specific block above, call the application directly.
      my_path = (bin_path.parent_path() / ((instance_type == NewSlicerInstanceType::Slicer) ? "prusa-slicer" : "prusa-gcodeviewer")).string();
      args.emplace_back(my_path.c_str());
    }
    std::string to_open;
    if (!paths_to_open.empty()) {
      for (const auto& file : paths_to_open) {
        to_open = into_u8(file);
        args.emplace_back(to_open.c_str());
      }
    }
    if (instance_type == NewSlicerInstanceType::Slicer && single_instance)
      args.emplace_back("--single-instance");
    if (delete_after_load && !paths_to_open.empty())
      args.emplace_back("--delete-after-load=1");
    args.emplace_back(nullptr);
    BOOST_LOG_TRIVIAL(info) << "Trying to spawn a new slicer \"" << args[0] << "\"";
    if (wxExecute(const_cast<char**>(args.data()), wxEXEC_ASYNC | wxEXEC_MAKE_GROUP_LEADER) <= 0)
      BOOST_LOG_TRIVIAL(error) << "Failed to spawn a new slicer \"" << args[0];
  }
#endif // Linux or Unix
#endif // Win32
}

References error, GCodeViewer, into_path(), into_u8(), L, and Slicer.

Referenced by start_new_gcodeviewer(), start_new_slicer(), start_new_slicer(), and start_new_slicer_or_gcodeviewer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ start_new_slicer_or_gcodeviewer() [2/2]

static void Slic3r::GUI::start_new_slicer_or_gcodeviewer	(	const NewSlicerInstanceType	instance_type,
		const wxString *	path_to_open,
		bool	single_instance,
		bool	delete_after_load
	)

static

{
  std::vector<wxString> paths;
  if (path_to_open != nullptr)
    paths.emplace_back(path_to_open->wc_str());
  start_new_slicer_or_gcodeviewer(instance_type, paths, single_instance, delete_after_load);
}

References start_new_slicer_or_gcodeviewer().

Here is the call graph for this function:

◆ stilized_arrow()

GLModel::Geometry Slic3r::GUI::stilized_arrow	(	unsigned int	resolution,
		float	tip_radius,
		float	tip_height,
		float	stem_radius,
		float	stem_height
	)

{
    resolution = std::max<unsigned int>(4, resolution);
 
    GLModel::Geometry data;
    data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3N3 };
    data.reserve_vertices(6 * resolution + 2);
    data.reserve_indices(6 * resolution * 3);
 
    const float angle_step = 2.0f * float(PI) / float(resolution);
    std::vector<float> cosines(resolution);
    std::vector<float> sines(resolution);
 
    for (unsigned int i = 0; i < resolution; ++i) {
        const float angle = angle_step * float(i);
        cosines[i] = ::cos(angle);
        sines[i] = -::sin(angle);
    }
 
    const float total_height = tip_height + stem_height;
 
    // tip vertices/normals
    data.add_vertex(Vec3f(0.0f, 0.0f, total_height), (Vec3f)Vec3f::UnitZ());
    for (unsigned int i = 0; i < resolution; ++i) {
        data.add_vertex(Vec3f(tip_radius * sines[i], tip_radius * cosines[i], stem_height), Vec3f(sines[i], cosines[i], 0.0f));
    }
 
    // tip triangles
    for (unsigned int i = 0; i < resolution; ++i) {
        const unsigned int v3 = (i < resolution - 1) ? i + 2 : 1;
        data.add_triangle(0, i + 1, v3);
    }
 
    // tip cap outer perimeter vertices
    for (unsigned int i = 0; i < resolution; ++i) {
        data.add_vertex(Vec3f(tip_radius * sines[i], tip_radius * cosines[i], stem_height), (Vec3f)(-Vec3f::UnitZ()));
    }
 
    // tip cap inner perimeter vertices
    for (unsigned int i = 0; i < resolution; ++i) {
        data.add_vertex(Vec3f(stem_radius * sines[i], stem_radius * cosines[i], stem_height), (Vec3f)(-Vec3f::UnitZ()));
    }
 
    // tip cap triangles
    for (unsigned int i = 0; i < resolution; ++i) {
        const unsigned int v2 = (i < resolution - 1) ? i + resolution + 2 : resolution + 1;
        const unsigned int v3 = (i < resolution - 1) ? i + 2 * resolution + 2 : 2 * resolution + 1;
        data.add_triangle(i + resolution + 1, v3, v2);
        data.add_triangle(i + resolution + 1, i + 2 * resolution + 1, v3);
    }
 
    // stem bottom vertices
    for (unsigned int i = 0; i < resolution; ++i) {
        data.add_vertex(Vec3f(stem_radius * sines[i], stem_radius * cosines[i], stem_height), Vec3f(sines[i], cosines[i], 0.0f));
    }
 
    // stem top vertices
    for (unsigned int i = 0; i < resolution; ++i) {
        data.add_vertex(Vec3f(stem_radius * sines[i], stem_radius * cosines[i], 0.0f), Vec3f(sines[i], cosines[i], 0.0f));
    }
 
    // stem triangles
    for (unsigned int i = 0; i < resolution; ++i) {
        const unsigned int v2 = (i < resolution - 1) ? i + 3 * resolution + 2 : 3 * resolution + 1;
        const unsigned int v3 = (i < resolution - 1) ? i + 4 * resolution + 2 : 4 * resolution + 1;
        data.add_triangle(i + 3 * resolution + 1, v3, v2);
        data.add_triangle(i + 3 * resolution + 1, i + 4 * resolution + 1, v3);
    }
 
    // stem cap vertices
    data.add_vertex((Vec3f)Vec3f::Zero(), (Vec3f)(-Vec3f::UnitZ()));
    for (unsigned int i = 0; i < resolution; ++i) {
        data.add_vertex(Vec3f(stem_radius * sines[i], stem_radius * cosines[i], 0.0f), (Vec3f)(-Vec3f::UnitZ()));
    }
 
    // stem cap triangles
    for (unsigned int i = 0; i < resolution; ++i) {
        const unsigned int v3 = (i < resolution - 1) ? i + 5 * resolution + 3 : 5 * resolution + 2;
        data.add_triangle(5 * resolution + 1, v3, i + 5 * resolution + 2);
    }
 
    return data;
}

References Slic3r::angle(), cos(), Slic3r::GUI::GLModel::Geometry::P3N3, PI, sin(), and Slic3r::GUI::GLModel::Geometry::Triangles.

Referenced by Slic3r::GUI::GCodeViewer::SequentialView::Marker::init(), and Slic3r::GUI::CoordAxes::render().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stop_current_job()

bool Slic3r::GUI::stop_current_job	(	Worker &	w,
		unsigned	timeout_ms = `0`
	)

inline

{
    w.cancel();
    return w.wait_for_current_job(timeout_ms);
}

References Slic3r::GUI::Worker::cancel(), and Slic3r::GUI::Worker::wait_for_current_job().

Here is the call graph for this function:

◆ stop_queue()

bool Slic3r::GUI::stop_queue	(	Worker &	w,
		unsigned	timeout_ms = `0`
	)

inline

{
    w.cancel_all();
    return w.wait_for_idle(timeout_ms);
}

References Slic3r::GUI::Worker::cancel_all(), and Slic3r::GUI::Worker::wait_for_idle().

Referenced by Slic3r::GUI::Plater::reslice().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ straight_arrow()

GLModel::Geometry Slic3r::GUI::straight_arrow	(	float	tip_width,
		float	tip_height,
		float	stem_width,
		float	stem_height,
		float	thickness
	)

{
    GLModel::Geometry data;
    data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3N3 };
    data.reserve_vertices(42);
    data.reserve_indices(72);
 
    const float half_thickness = 0.5f * thickness;
    const float half_stem_width = 0.5f * stem_width;
    const float half_tip_width = 0.5f * tip_width;
    const float total_height = tip_height + stem_height;
 
    // top face vertices
    data.add_vertex(Vec3f(half_stem_width, 0.0f, half_thickness), (Vec3f)Vec3f::UnitZ());
    data.add_vertex(Vec3f(half_stem_width, stem_height, half_thickness), (Vec3f)Vec3f::UnitZ());
    data.add_vertex(Vec3f(half_tip_width, stem_height, half_thickness), (Vec3f)Vec3f::UnitZ());
    data.add_vertex(Vec3f(0.0f, total_height, half_thickness), (Vec3f)Vec3f::UnitZ());
    data.add_vertex(Vec3f(-half_tip_width, stem_height, half_thickness), (Vec3f)Vec3f::UnitZ());
    data.add_vertex(Vec3f(-half_stem_width, stem_height, half_thickness), (Vec3f)Vec3f::UnitZ());
    data.add_vertex(Vec3f(-half_stem_width, 0.0f, half_thickness), (Vec3f)Vec3f::UnitZ());
 
    // top face triangles
    data.add_triangle(0, 1, 6);
    data.add_triangle(6, 1, 5);
    data.add_triangle(4, 5, 3);
    data.add_triangle(5, 1, 3);
    data.add_triangle(1, 2, 3);
 
    // bottom face vertices
    data.add_vertex(Vec3f(half_stem_width, 0.0f, -half_thickness), (Vec3f)(-Vec3f::UnitZ()));
    data.add_vertex(Vec3f(half_stem_width, stem_height, -half_thickness), (Vec3f)(-Vec3f::UnitZ()));
    data.add_vertex(Vec3f(half_tip_width, stem_height, -half_thickness), (Vec3f)(-Vec3f::UnitZ()));
    data.add_vertex(Vec3f(0.0f, total_height, -half_thickness), (Vec3f)(-Vec3f::UnitZ()));
    data.add_vertex(Vec3f(-half_tip_width, stem_height, -half_thickness), (Vec3f)(-Vec3f::UnitZ()));
    data.add_vertex(Vec3f(-half_stem_width, stem_height, -half_thickness), (Vec3f)(-Vec3f::UnitZ()));
    data.add_vertex(Vec3f(-half_stem_width, 0.0f, -half_thickness), (Vec3f)(-Vec3f::UnitZ()));
 
    // bottom face triangles
    data.add_triangle(7, 13, 8);
    data.add_triangle(13, 12, 8);
    data.add_triangle(12, 11, 10);
    data.add_triangle(8, 12, 10);
    data.add_triangle(9, 8, 10);
 
    // side faces vertices
    data.add_vertex(Vec3f(half_stem_width, 0.0f, -half_thickness), (Vec3f)Vec3f::UnitX());
    data.add_vertex(Vec3f(half_stem_width, stem_height, -half_thickness), (Vec3f)Vec3f::UnitX());
    data.add_vertex(Vec3f(half_stem_width, 0.0f, half_thickness), (Vec3f)Vec3f::UnitX());
    data.add_vertex(Vec3f(half_stem_width, stem_height, half_thickness), (Vec3f)Vec3f::UnitX());
 
    data.add_vertex(Vec3f(half_stem_width, stem_height, -half_thickness), (Vec3f)(-Vec3f::UnitY()));
    data.add_vertex(Vec3f(half_tip_width, stem_height, -half_thickness), (Vec3f)(-Vec3f::UnitY()));
    data.add_vertex(Vec3f(half_stem_width, stem_height, half_thickness), (Vec3f)(-Vec3f::UnitY()));
    data.add_vertex(Vec3f(half_tip_width, stem_height, half_thickness), (Vec3f)(-Vec3f::UnitY()));
 
    Vec3f normal(tip_height, half_tip_width, 0.0f);
    normal.normalize();
    data.add_vertex(Vec3f(half_tip_width, stem_height, -half_thickness), normal);
    data.add_vertex(Vec3f(0.0f, total_height, -half_thickness), normal);
    data.add_vertex(Vec3f(half_tip_width, stem_height, half_thickness), normal);
    data.add_vertex(Vec3f(0.0f, total_height, half_thickness), normal);
 
    normal = { -tip_height, half_tip_width, 0.0f };
    normal.normalize();
    data.add_vertex(Vec3f(0.0f, total_height, -half_thickness), normal);
    data.add_vertex(Vec3f(-half_tip_width, stem_height, -half_thickness), normal);
    data.add_vertex(Vec3f(0.0f, total_height, half_thickness), normal);
    data.add_vertex(Vec3f(-half_tip_width, stem_height, half_thickness), normal);
 
    data.add_vertex(Vec3f(-half_tip_width, stem_height, -half_thickness), (Vec3f)(-Vec3f::UnitY()));
    data.add_vertex(Vec3f(-half_stem_width, stem_height, -half_thickness), (Vec3f)(-Vec3f::UnitY()));
    data.add_vertex(Vec3f(-half_tip_width, stem_height, half_thickness), (Vec3f)(-Vec3f::UnitY()));
    data.add_vertex(Vec3f(-half_stem_width, stem_height, half_thickness), (Vec3f)(-Vec3f::UnitY()));
 
    data.add_vertex(Vec3f(-half_stem_width, stem_height, -half_thickness), (Vec3f)(-Vec3f::UnitX()));
    data.add_vertex(Vec3f(-half_stem_width, 0.0f, -half_thickness), (Vec3f)(-Vec3f::UnitX()));
    data.add_vertex(Vec3f(-half_stem_width, stem_height, half_thickness), (Vec3f)(-Vec3f::UnitX()));
    data.add_vertex(Vec3f(-half_stem_width, 0.0f, half_thickness), (Vec3f)(-Vec3f::UnitX()));
 
    data.add_vertex(Vec3f(-half_stem_width, 0.0f, -half_thickness), (Vec3f)(-Vec3f::UnitY()));
    data.add_vertex(Vec3f(half_stem_width, 0.0f, -half_thickness), (Vec3f)(-Vec3f::UnitY()));
    data.add_vertex(Vec3f(-half_stem_width, 0.0f, half_thickness), (Vec3f)(-Vec3f::UnitY()));
    data.add_vertex(Vec3f(half_stem_width, 0.0f, half_thickness), (Vec3f)(-Vec3f::UnitY()));
 
    // side face triangles
    for (unsigned int i = 0; i < 7; ++i) {
        const unsigned int ii = i * 4;
        data.add_triangle(14 + ii, 15 + ii, 17 + ii);
        data.add_triangle(14 + ii, 17 + ii, 16 + ii);
    }
 
    return data;
}

References Slic3r::GUI::GLModel::Geometry::P3N3, and Slic3r::GUI::GLModel::Geometry::Triangles.

Referenced by Slic3r::GUI::Selection::init().

Here is the caller graph for this function:

◆ string_getter()

static bool Slic3r::GUI::string_getter	(	const bool	is_undo,
		int	idx,
		const char **	out_text
	)

static

{
    return wxGetApp().plater()->undo_redo_string_getter(is_undo, idx, out_text);
}

Referenced by Slic3r::GUI::GLCanvas3D::_render_undo_redo_stack().

Here is the caller graph for this function:

◆ substitution_message()

static wxString Slic3r::GUI::substitution_message ( const wxString & changes )

static

{
  return
    _L("Most likely the configuration was produced by a newer version of PrusaSlicer or by some PrusaSlicer fork.") + " " +
    _L("The following values were substituted:") + "\n" + changes + "\n\n" +
    _L("Review the substitutions and adjust them if needed.");
}

References _L.

Referenced by show_substitutions_info(), and show_substitutions_info().

Here is the caller graph for this function:

◆ suffix() [1/2]

static std::string Slic3r::GUI::suffix ( const Preset & preset )

static

{
    return (preset.is_dirty ? Preset::suffix_modified() : "");
}

References Slic3r::Preset::is_dirty, and Slic3r::Preset::suffix_modified().

Referenced by Slic3r::GUI::SavePresetDialog::Item::Item(), Slic3r::GUI::SavePresetDialog::SavePresetDialog(), Slic3r::GUI::SavePresetDialog::AddItem(), Slic3r::GUI::SavePresetDialog::build(), Slic3r::GUI::SavePresetDialog::Item::get_init_preset_name(), Slic3r::GUI::PlaterPresetComboBox::get_preset_name(), Slic3r::GUI::TabPresetComboBox::get_preset_name(), Slic3r::GUI::Emboss::StyleManager::make_unique_name(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane_input_window(), Slic3r::GUI::PlaterPresetComboBox::update(), Slic3r::GUI::TabPresetComboBox::update(), and Slic3r::GUI::TabPresetComboBox::update_dirty().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ suffix() [2/2]

static std::string Slic3r::GUI::suffix ( Preset * preset )

static

{
    return (preset->is_dirty ? Preset::suffix_modified() : "");
}

References Slic3r::Preset::is_dirty, and Slic3r::Preset::suffix_modified().

Here is the call graph for this function:

◆ support_combo_value_for_config()

static wxString Slic3r::GUI::support_combo_value_for_config	(	const DynamicPrintConfig &	config,
		bool	is_fff
	)

static

{
    std::string slatree = is_fff ? "" : get_sla_suptree_prefix(config);
 
    const std::string support         = is_fff ? "support_material"                 : "supports_enable";
    const std::string buildplate_only = is_fff ? "support_material_buildplate_only" : slatree + "support_buildplate_only";
 
    return
        ! config.opt_bool(support) ?
            _("None") :
               ((is_fff && !config.opt_bool("support_material_auto")) || (!is_fff && config.opt_bool("support_enforcers_only"))) ?
                _("For support enforcers only") :
                (config.opt_bool(buildplate_only) ? _("Support on build plate only") :
                                                    _("Everywhere"));
}

References _, Slic3r::get_sla_suptree_prefix(), Slic3r::ConfigBase::opt_bool(), and support_combo_value_for_config().

Referenced by Slic3r::GUI::Tab::on_value_change(), support_combo_value_for_config(), and Slic3r::GUI::Tab::update_frequently_changed_parameters().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ surface_feature_type_as_string()

static std::string Slic3r::GUI::surface_feature_type_as_string ( Measure::SurfaceFeatureType type )

static

{
    switch (type)
    {
    default:
    case Measure::SurfaceFeatureType::Undef:  { return ("No feature"); }
    case Measure::SurfaceFeatureType::Point:  { return _u8L("Vertex"); }
    case Measure::SurfaceFeatureType::Edge:   { return _u8L("Edge"); }
    case Measure::SurfaceFeatureType::Circle: { return _u8L("Circle"); }
    case Measure::SurfaceFeatureType::Plane:  { return _u8L("Plane"); }
    }
}

References _u8L, Slic3r::Measure::Circle, Slic3r::Measure::Edge, Slic3r::Measure::Plane, Slic3r::Measure::Point, and Slic3r::Measure::Undef.

Referenced by Slic3r::GUI::GLGizmoMeasure::on_render_input_window().

Here is the caller graph for this function:

◆ synchronize_model_after_cut()

void Slic3r::GUI::synchronize_model_after_cut	(	Model &	model,
		const CutObjectBase &	cut_id
	)

{
    for (ModelObject* obj : model.objects)
        if (obj->is_cut() && obj->cut_id.has_same_id(cut_id) && !obj->cut_id.is_equal(cut_id))
            obj->cut_id.copy(cut_id);
}

References Slic3r::Model::objects.

Referenced by Slic3r::GUI::GLGizmoCut3D::perform_cut().

Here is the caller graph for this function:

◆ take_snapshot()

static void Slic3r::GUI::take_snapshot ( const wxString & snapshot_name )

static

{
    Plater* plater = wxGetApp().plater();
    if (plater)
        plater->take_snapshot(snapshot_name);
}

References plater(), and Slic3r::GUI::Plater::take_snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ to_squared_power_of_two()

static bool Slic3r::GUI::to_squared_power_of_two	(	const std::string &	filename,
		int	max_size_px,
		int &	w,
		int &	h
	)

static

{
    auto is_power_of_two = [](int v) { return v != 0 && (v & (v - 1)) == 0; };
    auto upper_power_of_two = [](int v) { v--; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; v++; return v; };
 
    int new_w = std::max(w, h);
    if (!is_power_of_two(new_w))
        new_w = upper_power_of_two(new_w);
 
    while (new_w > max_size_px) {
        new_w /= 2;
    }
 
    const int new_h = new_w;
    const bool ret = (new_w != w || new_h != h);
    w = new_w;
    h = new_h;
    return ret;
}

Referenced by Slic3r::GUI::GLTexture::load_from_png(), and Slic3r::GUI::GLTexture::load_from_svg().

Here is the caller graph for this function:

◆ update_arrangepoly_slaprint()

static void Slic3r::GUI::update_arrangepoly_slaprint	(	arrangement::ArrangePolygon &	ret,
		const SLAPrintObject &	po,
		const ModelInstance &	inst
	)

static

{
    // The 1.1 multiplier is a safety gap, as the offset might be bigger
    // in sharp edges of a polygon, depending on clipper's offset algorithm
    coord_t pad_infl = 0;
    {
        double infl = po.config().pad_enable.getBool() * (
                        po.config().pad_brim_size.getFloat() +
                        po.config().pad_around_object.getBool() *
                          po.config().pad_object_gap.getFloat() );
 
        pad_infl = scaled(1.1 * infl);
    }
 
    auto laststep = po.last_completed_step();
 
    if (laststep < slaposCount && laststep > slaposSupportTree) {
        auto omesh = po.get_mesh_to_print();
        auto &smesh = po.support_mesh();
 
        Transform3f trafo_instance = inst.get_matrix().cast<float>();
        trafo_instance = trafo_instance * po.trafo().cast<float>().inverse();
 
        Polygons polys;
        polys.reserve(3);
        auto zlvl = -po.get_elevation();
 
        if (omesh) {
            polys.emplace_back(its_convex_hull_2d_above(*omesh, trafo_instance, zlvl));
        }
 
        polys.emplace_back(its_convex_hull_2d_above(smesh.its, trafo_instance, zlvl));
        ret.poly.contour = Geometry::convex_hull(polys);
        ret.poly.holes = {};
    }
 
    ret.inflation = pad_infl;
}

References Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::cast(), Slic3r::SLAPrintObject::config(), Slic3r::ExPolygon::contour, Slic3r::Geometry::convex_hull(), Slic3r::SLAPrintObject::get_elevation(), Slic3r::ModelInstance::get_matrix(), Slic3r::SLAPrintObject::get_mesh_to_print(), Slic3r::ExPolygon::holes, Slic3r::arrangement::ArrangePolygon::inflation, inverse(), Slic3r::its_convex_hull_2d_above(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::last_completed_step(), Slic3r::arrangement::ArrangePolygon::poly, Slic3r::scaled(), Slic3r::slaposSupportTree, Slic3r::SLAPrintObject::support_mesh(), and Slic3r::SLAPrintObject::trafo().

Referenced by get_arrange_poly().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_children()

static void Slic3r::GUI::update_children ( ModelNode * parent )

static

{
    if (parent->IsContainer()) {
        bool toggle = parent->IsToggled();
        for (std::unique_ptr<ModelNode> &child : parent->GetChildren()) {
            child->Toggle(toggle);
            child->UpdateEnabling();
            update_children(child.get());
        }
    }
}

References Slic3r::GUI::ModelNode::GetChildren(), Slic3r::GUI::ModelNode::IsContainer(), Slic3r::GUI::ModelNode::IsToggled(), and update_children().

Referenced by update_children(), and Slic3r::GUI::DiffModel::UpdateItemEnabling().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_color()

static void Slic3r::GUI::update_color	(	wxColourPickerCtrl *	color_pckr,
		const wxColour &	color
	)

static

{
  if (color_pckr->GetColour() != color) {
    color_pckr->SetColour(color);
    wxPostEvent(color_pckr, wxCommandEvent(wxEVT_COLOURPICKER_CHANGED));
  }
}

Referenced by Slic3r::GUI::PreferencesDialog::show().

Here is the caller graph for this function:

◆ update_object_cut_id()

void Slic3r::GUI::update_object_cut_id	(	CutObjectBase &	cut_id,
		ModelObjectCutAttributes	attributes,
		const int	dowels_count
	)

{
    // we don't save cut information, if result will not contains all parts of initial object
    if (!attributes.has(ModelObjectCutAttribute::KeepUpper) ||
        !attributes.has(ModelObjectCutAttribute::KeepLower) ||
        attributes.has(ModelObjectCutAttribute::InvalidateCutInfo))
        return;
 
    if (cut_id.id().invalid())
        cut_id.init();
    // increase check sum, if it's needed
    {
        int cut_obj_cnt = -1;
        if (attributes.has(ModelObjectCutAttribute::KeepUpper))    cut_obj_cnt++;
        if (attributes.has(ModelObjectCutAttribute::KeepLower))    cut_obj_cnt++;
        if (attributes.has(ModelObjectCutAttribute::CreateDowels)) cut_obj_cnt+= dowels_count;
        if (cut_obj_cnt > 0)
            cut_id.increase_check_sum(size_t(cut_obj_cnt));
    }
}

References Slic3r::CreateDowels, Slic3r::enum_bitmask< option_type, typename >::has(), Slic3r::ObjectBase::id(), Slic3r::CutObjectBase::increase_check_sum(), Slic3r::CutObjectBase::init(), Slic3r::ObjectID::invalid(), Slic3r::InvalidateCutInfo, Slic3r::KeepLower, and Slic3r::KeepUpper.

Referenced by Slic3r::GUI::GLGizmoCut3D::perform_cut().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_parents()

static void Slic3r::GUI::update_parents ( ModelNode * node )

static

{
    ModelNode* parent = node->GetParent();
    if (parent) {
        bool toggle = false;
        for (std::unique_ptr<ModelNode> &child : parent->GetChildren()) {
            if (child->IsToggled()) {
                toggle = true;
                break;
            }
        }
        parent->Toggle(toggle);
        parent->UpdateEnabling();
        update_parents(parent);
    }
}

References Slic3r::GUI::ModelNode::GetChildren(), Slic3r::GUI::ModelNode::GetParent(), Slic3r::GUI::ModelNode::Toggle(), update_parents(), and Slic3r::GUI::ModelNode::UpdateEnabling().

Referenced by update_parents(), and Slic3r::GUI::DiffModel::UpdateItemEnabling().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_selection()

static void Slic3r::GUI::update_selection	(	wxDataViewItemArray &	sels,
		ObjectList::SELECTION_MODE	mode,
		ObjectDataViewModel *	model
	)

static

{
    if (mode == ObjectList::smInstance)
    {
        for (auto& item : sels)
        {
            ItemType type = model->GetItemType(item);
            if (type == itObject)
                continue;
            if (type == itInstanceRoot) {
                wxDataViewItem obj_item = model->GetParent(item);
                sels.Remove(item);
                sels.Add(obj_item);
                update_selection(sels, mode, model);
                return;
            }
            if (type == itInstance)
            {
                wxDataViewItemArray instances;
                model->GetChildren(model->GetParent(item), instances);
                assert(instances.Count() > 0);
                size_t selected_instances_cnt = 0;
                for (auto& inst : instances) {
                    if (sels.Index(inst) == wxNOT_FOUND)
                        break;
                    selected_instances_cnt++;
                }
 
                if (selected_instances_cnt == instances.Count()) 
                {
                    wxDataViewItem obj_item = model->GetTopParent(item);
                    for (auto& inst : instances)
                        sels.Remove(inst);
                    sels.Add(obj_item);
                    update_selection(sels, mode, model);
                    return;
                }
            }
            else
                return;
        }
    }
}

References Slic3r::GUI::ObjectDataViewModel::GetChildren(), Slic3r::GUI::ObjectDataViewModel::GetItemType(), Slic3r::GUI::ObjectDataViewModel::GetParent(), Slic3r::GUI::ObjectDataViewModel::GetTopParent(), itInstance, itInstanceRoot, itObject, Slic3r::GUI::ObjectList::smInstance, and update_selection().

Referenced by Slic3r::GUI::ObjectList::remove(), and update_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_custom_gcode_cb()

static void Slic3r::GUI::validate_custom_gcode_cb	(	Tab *	tab,
		const wxString &	title,
		const t_config_option_key &	opt_key,
		const boost::any &	value
	)

static

                                                                                                                                 {
    tab->validate_custom_gcodes_was_shown = !Tab::validate_custom_gcode(title, boost::any_cast<std::string>(value));
    tab->update_dirty();
    tab->on_value_change(opt_key, value);
}

References Slic3r::GUI::Tab::on_value_change(), Slic3r::GUI::Tab::update_dirty(), validate_custom_gcode_cb(), and Slic3r::GUI::Tab::validate_custom_gcodes_was_shown.

Referenced by Slic3r::GUI::TabPrinter::build_fff(), and validate_custom_gcode_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ verify_instances_rotation_synchronized()

static void Slic3r::GUI::verify_instances_rotation_synchronized	(	const Model &	model,
		const GLVolumePtrs &	volumes
	)

static

{
    for (int idx_object = 0; idx_object < int(model.objects.size()); ++idx_object) {
        int idx_volume_first = -1;
        for (int i = 0; i < (int)volumes.size(); ++i) {
            if (volumes[i]->object_idx() == idx_object) {
                idx_volume_first = i;
                break;
            }
        }
        assert(idx_volume_first != -1); // object without instances?
        if (idx_volume_first == -1)
            continue;
        const Transform3d::ConstLinearPart& rotation0 = volumes[idx_volume_first]->get_instance_transformation().get_matrix().linear();
        for (int i = idx_volume_first + 1; i < (int)volumes.size(); ++i)
            if (volumes[i]->object_idx() == idx_object && volumes[i]->volume_idx() >= 0) {
                const Transform3d::ConstLinearPart& rotation = volumes[i]->get_instance_transformation().get_matrix().linear();
                assert(is_rotation_xy_synchronized(rotation, rotation0));
            }
    }
}

References is_rotation_xy_synchronized(), and Slic3r::Model::objects.

Referenced by Slic3r::GUI::Selection::synchronize_unselected_instances().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ warning_catcher()

void Slic3r::GUI::warning_catcher	(	wxWindow *	parent,
		const wxString &	message
	)

{
  //wxMessageDialog msg(parent, message, _L("Warning"), wxOK | wxICON_WARNING);
  MessageDialog msg(parent, message, _L("Warning"), wxOK | wxICON_WARNING);
  msg.ShowModal();
}

References _L.

Referenced by Slic3r::GUI::PhysicalPrinterDialog::OnOK(), and Slic3r::GUI::Plater::priv::split_object().

Here is the caller graph for this function:

◆ world_matrix_fixed() [1/2]

Transform3d Slic3r::GUI::world_matrix_fixed	(	const GLVolume &	gl_volume,
		const ModelObjectPtrs &	objects
	)

Get transformation to world.

use fix after store to 3mf when exists

Parameters

gl_volume	Scene volume
objects	To identify Model volume with fix transformation

Returns: Fixed Transformation of gl_volume

{
    Transform3d res = gl_volume.world_matrix();
 
    const ModelVolume *mv = get_model_volume(gl_volume, objects);
    if (!mv)
        return res;
 
    const std::optional<TextConfiguration> &tc = mv->text_configuration;
    if (!tc.has_value())
        return res;
 
    const std::optional<Transform3d> &fix = tc->fix_3mf_tr;
    if (!fix.has_value())
        return res;
 
    return res * fix->inverse();
}

References get_model_volume(), Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::inverse(), Slic3r::ModelVolume::text_configuration, and Slic3r::GLVolume::world_matrix().

Referenced by priv::apply_camera_dir(), calc_surface_offset(), on_mouse_surface_drag(), and world_matrix_fixed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ world_matrix_fixed() [2/2]

Transform3d Slic3r::GUI::world_matrix_fixed ( const Selection & selection )

Get transformation to world.

use fix after store to 3mf when exists NOTE: when not one volume selected return identity

Parameters

selection Selected volume

Returns: Fixed Transformation of selected volume in selection

{
    const GLVolume *gl_volume = get_selected_gl_volume(selection);
    assert(gl_volume != nullptr);
    if (gl_volume == nullptr)
        return Transform3d::Identity();
 
    return world_matrix_fixed(*gl_volume, selection.get_model()->objects);
}

References Slic3r::GUI::Selection::get_model(), get_selected_gl_volume(), Eigen::Transform< double, 3, Eigen::Affine, Eigen::DontAlign >::Identity(), Slic3r::Model::objects, and world_matrix_fixed().

Here is the call graph for this function:

◆ WX_DEFINE_ARRAY_PTR()

Slic3r::GUI::WX_DEFINE_ARRAY_PTR	(	ObjectDataViewModelNode *	,
		MyObjectTreeModelNodePtrArray
	)

◆ wxDECLARE_EVENT() [1/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DIFF_DIALOG_TRANSFER	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [2/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DIFF_DIALOG_UPDATE_PRESETS	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [3/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DPI_CHANGED_SLICER	,
		DpiChangedEvent
	)

◆ wxDECLARE_EVENT() [4/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DWNLDR_FILE_CANCELED	,
		wxCommandEvent
	)

◆ wxDECLARE_EVENT() [5/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DWNLDR_FILE_COMPLETE	,
		wxCommandEvent
	)

◆ wxDECLARE_EVENT() [6/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DWNLDR_FILE_ERROR	,
		wxCommandEvent
	)

◆ wxDECLARE_EVENT() [7/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DWNLDR_FILE_NAME_CHANGE	,
		wxCommandEvent
	)

◆ wxDECLARE_EVENT() [8/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DWNLDR_FILE_PAUSED	,
		wxCommandEvent
	)

◆ wxDECLARE_EVENT() [9/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DWNLDR_FILE_PROGRESS	,
		wxCommandEvent
	)

◆ wxDECLARE_EVENT() [10/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_EJECT_DRIVE_NOTIFICAION_CLICKED	,
		EjectDriveNotificationClickedEvent
	)

◆ wxDECLARE_EVENT() [11/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_EXPORT_GCODE_NOTIFICAION_CLICKED	,
		ExportGcodeNotificationClickedEvent
	)

◆ wxDECLARE_EVENT() [12/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_ADAPTIVE_LAYER_HEIGHT_PROFILE	,
		Event< float >
	)

◆ wxDECLARE_EVENT() [13/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_ARRANGE	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [14/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_COLLAPSE_SIDEBAR	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [15/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_EDIT_COLOR_CHANGE	,
		wxKeyEvent
	)

◆ wxDECLARE_EVENT() [16/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_ENABLE_ACTION_BUTTONS	,
		Event< bool >
	)

◆ wxDECLARE_EVENT() [17/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_FORCE_UPDATE	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [18/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_GIZMO_HIGHLIGHTER_TIMER	,
		wxTimerEvent
	)

◆ wxDECLARE_EVENT() [19/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_INCREASE_INSTANCES	,
		Event< int >
	)

◆ wxDECLARE_EVENT() [20/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_INSTANCE_MOVED	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [21/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_INSTANCE_ROTATED	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [22/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_INSTANCE_SCALED	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [23/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_JUMP_TO	,
		wxKeyEvent
	)

◆ wxDECLARE_EVENT() [24/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [25/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_MOUSE_DRAGGING_STARTED	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [26/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_MOVE_SLIDERS	,
		wxKeyEvent
	)

◆ wxDECLARE_EVENT() [27/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_OBJECT_SELECT	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [28/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_QUESTION_MARK	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [29/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_REDO	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [30/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_RELOAD_FROM_DISK	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [31/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_REMOVE_OBJECT	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [32/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_RENDER_TIMER	,
		wxTimerEvent
	)

◆ wxDECLARE_EVENT() [33/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_RESET_LAYER_HEIGHT_PROFILE	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [34/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_RESET_SKEW	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [35/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_RESETGIZMOS	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [36/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_RIGHT_CLICK	,
		RBtnEvent
	)

◆ wxDECLARE_EVENT() [37/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [38/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_SELECT_ALL	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [39/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_SMOOTH_LAYER_HEIGHT_PROFILE	,
		HeightProfileSmoothEvent
	)

◆ wxDECLARE_EVENT() [40/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_TAB	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [41/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_TOOLBAR_HIGHLIGHTER_TIMER	,
		wxTimerEvent
	)

◆ wxDECLARE_EVENT() [42/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_UNDO	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [43/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_UPDATE_BED_SHAPE	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [44/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_UPDATE_GEOMETRY	,
		Vec3dsEvent< 2 >
	)

◆ wxDECLARE_EVENT() [45/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_WIPETOWER_MOVED	,
		Vec3dEvent
	)

◆ wxDECLARE_EVENT() [46/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_WIPETOWER_ROTATED	,
		Vec3dEvent
	)

◆ wxDECLARE_EVENT() [47/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_ADD	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [48/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_ARRANGE	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [49/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_COPY	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [50/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_DELETE	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [51/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_DELETE_ALL	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [52/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_FEWER	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [53/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_LAYERSEDITING	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [54/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_MORE	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [55/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_PASTE	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [56/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_SPLIT_OBJECTS	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [57/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_SPLIT_VOLUMES	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [58/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLVIEWTOOLBAR_3D	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [59/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLVIEWTOOLBAR_PREVIEW	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [60/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_INDEX_PAGE	,
		wxCommandEvent
	)

◆ wxDECLARE_EVENT() [61/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_INSTANCE_GO_TO_FRONT	,
		InstanceGoToFrontEvent
	)

◆ wxDECLARE_EVENT() [62/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_LOAD_MODEL_OTHER_INSTANCE	,
		LoadFromOtherInstanceEvent
	)

◆ wxDECLARE_EVENT() [63/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_OBJ_LIST_OBJECT_SELECT	,
		SimpleEvent
	)

◆ wxDECLARE_EVENT() [64/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_PRESET_UPDATE_AVAILABLE_CLICKED	,
		PresetUpdateAvailableClickedEvent
	)

◆ wxDECLARE_EVENT() [65/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_PRINTHOST_CANCEL	,
		PrintHostQueueDialog::Event
	)

◆ wxDECLARE_EVENT() [66/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_PRINTHOST_ERROR	,
		PrintHostQueueDialog::Event
	)

◆ wxDECLARE_EVENT() [67/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_PRINTHOST_INFO	,
		PrintHostQueueDialog::Event
	)

◆ wxDECLARE_EVENT() [68/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_PRINTHOST_PROGRESS	,
		PrintHostQueueDialog::Event
	)

◆ wxDECLARE_EVENT() [69/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_REMOVABLE_DRIVE_EJECTED	,
		RemovableDriveEjectEvent
	)

◆ wxDECLARE_EVENT() [70/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_REMOVABLE_DRIVES_CHANGED	,
		RemovableDrivesChangedEvent
	)

◆ wxDECLARE_EVENT() [71/72]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_START_DOWNLOAD_OTHER_INSTANCE	,
		StartDownloadOtherInstanceEvent
	)

◆ wxDECLARE_EVENT() [72/72]

Slic3r::GUI::wxDECLARE_EVENT	(	wxCUSTOMEVT_LAST_VOLUME_IS_DELETED	,
		wxCommandEvent
	)

◆ wxDEFINE_EVENT() [1/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DIFF_DIALOG_TRANSFER	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [2/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DIFF_DIALOG_UPDATE_PRESETS	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [3/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DPI_CHANGED_SLICER	,
		DpiChangedEvent
	)

◆ wxDEFINE_EVENT() [4/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DWNLDR_FILE_CANCELED	,
		wxCommandEvent
	)

◆ wxDEFINE_EVENT() [5/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DWNLDR_FILE_COMPLETE	,
		wxCommandEvent
	)

◆ wxDEFINE_EVENT() [6/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DWNLDR_FILE_ERROR	,
		wxCommandEvent
	)

◆ wxDEFINE_EVENT() [7/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DWNLDR_FILE_NAME_CHANGE	,
		wxCommandEvent
	)

◆ wxDEFINE_EVENT() [8/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DWNLDR_FILE_PAUSED	,
		wxCommandEvent
	)

◆ wxDEFINE_EVENT() [9/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DWNLDR_FILE_PROGRESS	,
		wxCommandEvent
	)

◆ wxDEFINE_EVENT() [10/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_EJECT_DRIVE_NOTIFICAION_CLICKED	,
		EjectDriveNotificationClickedEvent
	)

◆ wxDEFINE_EVENT() [11/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_EXPORT_BEGAN	,
		wxCommandEvent
	)

◆ wxDEFINE_EVENT() [12/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_EXPORT_GCODE_NOTIFICAION_CLICKED	,
		ExportGcodeNotificationClickedEvent
	)

◆ wxDEFINE_EVENT() [13/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_ADAPTIVE_LAYER_HEIGHT_PROFILE	,
		Event< float >
	)

◆ wxDEFINE_EVENT() [14/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_ARRANGE	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [15/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_COLLAPSE_SIDEBAR	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [16/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_EDIT_COLOR_CHANGE	,
		wxKeyEvent
	)

◆ wxDEFINE_EVENT() [17/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_ENABLE_ACTION_BUTTONS	,
		Event< bool >
	)

◆ wxDEFINE_EVENT() [18/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_FORCE_UPDATE	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [19/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_GIZMO_HIGHLIGHTER_TIMER	,
		wxTimerEvent
	)

◆ wxDEFINE_EVENT() [20/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_INCREASE_INSTANCES	,
		Event< int >
	)

◆ wxDEFINE_EVENT() [21/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_INSTANCE_MOVED	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [22/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_INSTANCE_ROTATED	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [23/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_INSTANCE_SCALED	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [24/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_JUMP_TO	,
		wxKeyEvent
	)

◆ wxDEFINE_EVENT() [25/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [26/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_MOUSE_DRAGGING_STARTED	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [27/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_MOVE_SLIDERS	,
		wxKeyEvent
	)

◆ wxDEFINE_EVENT() [28/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_OBJECT_SELECT	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [29/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_QUESTION_MARK	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [30/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_REDO	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [31/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_RELOAD_FROM_DISK	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [32/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_REMOVE_OBJECT	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [33/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_RENDER_TIMER	,
		wxTimerEvent
	)

◆ wxDEFINE_EVENT() [34/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_RESET_LAYER_HEIGHT_PROFILE	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [35/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_RESET_SKEW	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [36/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_RESETGIZMOS	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [37/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_RIGHT_CLICK	,
		RBtnEvent
	)

◆ wxDEFINE_EVENT() [38/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [39/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_SELECT_ALL	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [40/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_SMOOTH_LAYER_HEIGHT_PROFILE	,
		HeightProfileSmoothEvent
	)

◆ wxDEFINE_EVENT() [41/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_TAB	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [42/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_TOOLBAR_HIGHLIGHTER_TIMER	,
		wxTimerEvent
	)

◆ wxDEFINE_EVENT() [43/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_UNDO	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [44/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_UPDATE_BED_SHAPE	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [45/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_UPDATE_GEOMETRY	,
		Vec3dsEvent< 2 >
	)

◆ wxDEFINE_EVENT() [46/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_WIPETOWER_MOVED	,
		Vec3dEvent
	)

◆ wxDEFINE_EVENT() [47/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_WIPETOWER_ROTATED	,
		Vec3dEvent
	)

◆ wxDEFINE_EVENT() [48/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_ADD	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [49/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_ARRANGE	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [50/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_COPY	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [51/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_DELETE	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [52/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_DELETE_ALL	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [53/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_FEWER	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [54/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_LAYERSEDITING	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [55/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_MORE	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [56/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_PASTE	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [57/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_SPLIT_OBJECTS	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [58/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_SPLIT_VOLUMES	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [59/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLVIEWTOOLBAR_3D	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [60/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLVIEWTOOLBAR_PREVIEW	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [61/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_INDEX_PAGE	,
		wxCommandEvent
	)

◆ wxDEFINE_EVENT() [62/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_INSTANCE_GO_TO_FRONT	,
		InstanceGoToFrontEvent
	)

◆ wxDEFINE_EVENT() [63/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_LOAD_MODEL_OTHER_INSTANCE	,
		LoadFromOtherInstanceEvent
	)

◆ wxDEFINE_EVENT() [64/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_OBJ_LIST_OBJECT_SELECT	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [65/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PRESET_UPDATE_AVAILABLE_CLICKED	,
		PresetUpdateAvailableClickedEvent
	)

◆ wxDEFINE_EVENT() [66/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PRINTER_PICK	,
		PrinterPickerEvent
	)

◆ wxDEFINE_EVENT() [67/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PRINTHOST_CANCEL	,
		PrintHostQueueDialog::Event
	)

◆ wxDEFINE_EVENT() [68/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PRINTHOST_ERROR	,
		PrintHostQueueDialog::Event
	)

◆ wxDEFINE_EVENT() [69/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PRINTHOST_INFO	,
		PrintHostQueueDialog::Event
	)

◆ wxDEFINE_EVENT() [70/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PRINTHOST_PROGRESS	,
		PrintHostQueueDialog::Event
	)

◆ wxDEFINE_EVENT() [71/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PROCESS_COMPLETED	,
		SlicingProcessCompletedEvent
	)

◆ wxDEFINE_EVENT() [72/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_REMOVABLE_DRIVE_EJECTED	,
		RemovableDriveEjectEvent
	)

◆ wxDEFINE_EVENT() [73/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_REMOVABLE_DRIVES_CHANGED	,
		RemovableDrivesChangedEvent
	)

◆ wxDEFINE_EVENT() [74/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SCHEDULE_BACKGROUND_PROCESS	,
		SimpleEvent
	)

◆ wxDEFINE_EVENT() [75/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SLICING_COMPLETED	,
		wxCommandEvent
	)

◆ wxDEFINE_EVENT() [76/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SLICING_UPDATE	,
		SlicingStatusEvent
	)

◆ wxDEFINE_EVENT() [77/78]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_START_DOWNLOAD_OTHER_INSTANCE	,
		StartDownloadOtherInstanceEvent
	)

◆ wxDEFINE_EVENT() [78/78]

Slic3r::GUI::wxDEFINE_EVENT	(	wxCUSTOMEVT_LAST_VOLUME_IS_DELETED	,
		wxCommandEvent
	)

◆ wxImage_to_wxBitmap_with_alpha()

static wxBitmap Slic3r::GUI::wxImage_to_wxBitmap_with_alpha	(	wxImage &&	image,
		float	scale = `1.0f`
	)

static

{
#ifdef __WXGTK2__
    // Broken alpha workaround
    wxMemoryOutputStream stream;
    image.SaveFile(stream, wxBITMAP_TYPE_PNG);
    wxStreamBuffer *buf = stream.GetOutputStreamBuffer();
    return wxBitmap::NewFromPNGData(buf->GetBufferStart(), buf->GetBufferSize());
#else
#ifdef __APPLE__
    // This is a c-tor native to Mac OS. We need to let the Mac OS wxBitmap implementation
    // know that the image may already be scaled appropriately for Retina,
    // and thereby that it's not supposed to upscale it.
    // Contrary to intuition, the `scale` argument isn't "please scale this to such and such"
    // but rather "the wxImage is sized for backing scale such and such".
    return wxBitmap(std::move(image), -1, scale);
#else
    return wxBitmap(std::move(image));
#endif
#endif
}

References scale().

Referenced by Slic3r::GUI::BitmapCache::from_png(), Slic3r::GUI::BitmapCache::insert_bndl(), Slic3r::GUI::BitmapCache::insert_raw_rgba(), Slic3r::GUI::BitmapCache::load_png(), and Slic3r::GUI::BitmapCache::mksolid().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ ABORT_WAIT_MAX_MS

constexpr int Slic3r::GUI::ABORT_WAIT_MAX_MS = 10000

constexpr

Referenced by Slic3r::GUI::BoostThreadWorker::~BoostThreadWorker().

◆ ADD_VOLUME_MENU_ITEMS

const constexpr std::array<std::pair<const char *, const char *>, 5> Slic3r::GUI::ADD_VOLUME_MENU_ITEMS

staticconstexpr

Initial value:

= {{
    
    {L("Add part"),              "add_part" },           
    {L("Add negative volume"),   "add_negative" },       
    {L("Add modifier"),          "add_modifier"},        
    {L("Add support blocker"),   "support_blocker"},     
    {L("Add support enforcer"),  "support_enforcer"},    
}}

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_add_text(), Slic3r::GUI::MenuFactory::append_menu_items_add_volume(), and Slic3r::GUI::MenuFactory::get_volume_bitmaps().

◆ AngleResolution

const unsigned int Slic3r::GUI::AngleResolution = 64

Referenced by init_from_angle_arc().

◆ axes

const char Slic3r::GUI::axes[] = { 'x', 'y', 'z' }

static

Referenced by Slic3r::GUI::ManipulationEditor::ManipulationEditor(), Slic3r::GUI::ObjectManipulation::ObjectManipulation(), and Slic3r::GUI::Selection::get_bounding_box_in_reference_system().

◆ AXES_COLOR

const std::array<ColorRGBA, 3> Slic3r::GUI::AXES_COLOR = {{ ColorRGBA::X(), ColorRGBA::Y(), ColorRGBA::Z() }}

static

Referenced by get_color(), Slic3r::GUI::GLGizmoRotate3D::on_init(), Slic3r::GUI::GLGizmoMove3D::on_render(), and Slic3r::GUI::GLGizmoScale3D::update_render_data().

◆ axes_color_back

const wxString Slic3r::GUI::axes_color_back[] = { "#f5dcdc", "#dcf5dc", "#dcdcf5" }

static

Referenced by Slic3r::GUI::ManipulationEditor::ManipulationEditor(), and Slic3r::GUI::ObjectManipulation::update_ui_from_settings().

◆ axes_color_text

const wxString Slic3r::GUI::axes_color_text[] = { "#990000", "#009900", "#000099" }

static

◆ BOLD_MARKER_END

const std::string Slic3r::GUI::BOLD_MARKER_END = "</b>"

Referenced by Slic3r::GUI::HintDatabase::load_hints_from_file().

◆ BOLD_MARKER_START

const std::string Slic3r::GUI::BOLD_MARKER_START = "<b>"

Referenced by Slic3r::GUI::HintDatabase::load_hints_from_file().

◆ BORDER_W

constexpr auto Slic3r::GUI::BORDER_W = 10

constexpr

Referenced by Slic3r::GUI::GalleryDialog::GalleryDialog(), Slic3r::GUI::SavePresetDialog::Item::Item(), Slic3r::GUI::SavePresetDialog::Item::Item(), Slic3r::GUI::PhysicalPrinterDialog::PhysicalPrinterDialog(), Slic3r::GUI::PresetForPrinter::PresetForPrinter(), Slic3r::GUI::SavePresetDialog::add_info_for_edit_ph_printer(), Slic3r::GUI::PhysicalPrinterDialog::AddPreset(), Slic3r::GUI::SavePresetDialog::build(), and Slic3r::GUI::SavePresetDialog::Item::init_input_name_ctrl().

◆ CIRCLE_ID

const int Slic3r::GUI::CIRCLE_ID = 300

static

Referenced by Slic3r::GUI::GLGizmoMeasure::on_render().

◆ CONFIG_KEY_GROUP

const char* Slic3r::GUI::CONFIG_KEY_GROUP = "printhost_group"

static

Referenced by Slic3r::GUI::PrintHostSendDialog::PrintHostSendDialog(), and Slic3r::GUI::PrintHostSendDialog::EndModal().

◆ CONFIG_KEY_PATH

const char* Slic3r::GUI::CONFIG_KEY_PATH = "printhost_path"

static

Referenced by Slic3r::GUI::PrintHostSendDialog::PrintHostSendDialog(), and Slic3r::GUI::PrintHostSendDialog::EndModal().

◆ CONFIG_KEY_STORAGE

const char* Slic3r::GUI::CONFIG_KEY_STORAGE = "printhost_storage"

static

Referenced by Slic3r::GUI::PrintHostSendDialog::PrintHostSendDialog(), and Slic3r::GUI::PrintHostSendDialog::EndModal().

◆ CONNECTOR_DEF_COLOR

const ColorRGBA Slic3r::GUI::CONNECTOR_DEF_COLOR = ColorRGBA(1.0f, 1.0f, 1.0f, 0.5f)

static

Referenced by Slic3r::GUI::GLGizmoCut3D::render_connectors().

◆ CONNECTOR_ERR_COLOR

const ColorRGBA Slic3r::GUI::CONNECTOR_ERR_COLOR = ColorRGBA(1.0f, 0.3f, 0.3f, 0.5f)

static

Referenced by Slic3r::GUI::GLGizmoCut3D::render_connectors().

◆ CONSTRAINED_COLOR

const ColorRGBA Slic3r::GUI::CONSTRAINED_COLOR = ColorRGBA::GRAY()

static

Referenced by Slic3r::GUI::GLGizmoScale3D::update_render_data().

◆ CTRL_STR

const std::string Slic3r::GUI::CTRL_STR

static

Initial value:

=
 
"Ctrl"

◆ DEFAULT_BASE_COLOR

const ColorRGBA Slic3r::GUI::DEFAULT_BASE_COLOR = { 0.625f, 0.625f, 0.625f, 1.0f }

static

◆ DEFAULT_DRAG_COLOR

const ColorRGBA Slic3r::GUI::DEFAULT_DRAG_COLOR = ColorRGBA::WHITE()

static

◆ DEFAULT_HIGHLIGHT_COLOR

const ColorRGBA Slic3r::GUI::DEFAULT_HIGHLIGHT_COLOR = ColorRGBA::ORANGE()

static

◆ DEFAULT_HOVER_PLANE_COLOR

const Slic3r::ColorRGBA Slic3r::GUI::DEFAULT_HOVER_PLANE_COLOR = { 0.9f, 0.9f, 0.9f, 0.75f }

static

Referenced by Slic3r::GUI::GLGizmoFlatten::on_render().

◆ DEFAULT_PLANE_COLOR

const Slic3r::ColorRGBA Slic3r::GUI::DEFAULT_PLANE_COLOR = { 0.9f, 0.9f, 0.9f, 0.5f }

static

Referenced by Slic3r::GUI::GLGizmoFlatten::on_render().

◆ DISABLED_COLOR

const ColorRGBA Slic3r::GUI::DISABLED_COLOR = ColorRGBA::DARK_GRAY()

static

Referenced by Slic3r::GUI::GLGizmoSlaBase::update_volumes().

◆ DOWEL_COLOR

const ColorRGBA Slic3r::GUI::DOWEL_COLOR = ColorRGBA::DARK_YELLOW()

static

Referenced by Slic3r::GUI::GLGizmoCut3D::render_connectors().

◆ DOWNLOAD_MAX_CHUNK_SIZE

const size_t Slic3r::GUI::DOWNLOAD_MAX_CHUNK_SIZE = 10 * 1024 * 1024

Referenced by Slic3r::GUI::FileGet::priv::get_perform().

◆ DOWNLOAD_SIZE_LIMIT

const size_t Slic3r::GUI::DOWNLOAD_SIZE_LIMIT = 1024 * 1024 * 1024

Referenced by Slic3r::GUI::FileGet::priv::get_perform().

◆ EDGE_ID

const int Slic3r::GUI::EDGE_ID = 200

static

Referenced by Slic3r::GUI::GLGizmoMeasure::on_render().

◆ extruder_options

const std::vector<std::string> Slic3r::GUI::extruder_options

Initial value:

= {
    "min_layer_height", "max_layer_height", "extruder_offset",
    "retract_length", "retract_lift", "retract_lift_above", "retract_lift_below",
    "retract_speed", "deretract_speed", "retract_restart_extra", "retract_before_travel",
    "retract_layer_change", "wipe", "retract_before_wipe",
    "retract_length_toolchange", "retract_restart_extra_toolchange",
}

Referenced by Slic3r::GUI::TabPrinter::build_extruder_pages().

◆ file_wildcards_by_type

const FileWildcards Slic3r::GUI::file_wildcards_by_type[FT_SIZE]

static

Initial value:

= {
         { "STL files"sv,       { ".stl"sv } },
         { "OBJ files"sv,       { ".obj"sv } },
      { "Object files"sv,    { ".stl"sv, ".obj"sv } },
        { "STEP files"sv,      { ".stp"sv, ".step"sv } },    
         { "AMF files"sv,       { ".amf"sv, ".zip.amf"sv, ".xml"sv } },
         { "3MF files"sv,       { ".3mf"sv } },
       { "G-code files"sv,    { ".gcode"sv, ".gco"sv, ".g"sv, ".ngc"sv } },
       { "Known files"sv,     { ".stl"sv, ".obj"sv, ".3mf"sv, ".amf"sv, ".zip.amf"sv, ".xml"sv, ".step"sv, ".stp"sv } },
     { "Project files"sv,   { ".3mf"sv, ".amf"sv, ".zip.amf"sv } },
       { "Font files"sv,      { ".ttc"sv, ".ttf"sv } },
     { "Known files"sv,     { ".stl"sv, ".obj"sv } },
 
         { "INI files"sv,       { ".ini"sv } },
         { "SVG files"sv,       { ".svg"sv } },
 
         { "Texture"sv,         { ".png"sv, ".svg"sv } },
 
         { "Masked SLA files"sv, { ".sl1"sv, ".sl1s"sv, ".pwmx"sv } },
 
         { "Zip files"sv, { ".zip"sv } },
}

Referenced by file_wildcards().

◆ font_icons

const std::map<const wchar_t, std::string> Slic3r::GUI::font_icons

static

Initial value:

= {
    {ImGui::PrintIconMarker       , "cog"                           },
    {ImGui::PrinterIconMarker     , "printer"                       },
    {ImGui::PrinterSlaIconMarker  , "sla_printer"                   },
    {ImGui::FilamentIconMarker    , "spool"                         },
    {ImGui::MaterialIconMarker    , "resin"                         },
    {ImGui::MinimalizeButton      , "notification_minimalize"       },
    {ImGui::MinimalizeHoverButton , "notification_minimalize_hover" },
    {ImGui::RightArrowButton      , "notification_right"            },
    {ImGui::RightArrowHoverButton , "notification_right_hover"      },
    {ImGui::PreferencesButton     , "notification_preferences"      },
    {ImGui::PreferencesHoverButton, "notification_preferences_hover"},
    {ImGui::SliderFloatEditBtnIcon, "edit_button"                   },
    {ImGui::SliderFloatEditBtnPressedIcon, "edit_button_pressed"    },
    {ImGui::ClipboardBtnIcon      , "copy_menu"                     },
    {ImGui::ExpandBtn             , "expand_btn"                    },
    {ImGui::CollapseBtn           , "collapse_btn"                  },
    {ImGui::RevertButton          , "undo"                          },
    {ImGui::WarningMarkerSmall    , "notification_warning"          },
    {ImGui::InfoMarkerSmall       , "notification_info"             },
    {ImGui::PlugMarker            , "plug"                          },
    {ImGui::DowelMarker           , "dowel"                         },
}

Referenced by Slic3r::GUI::ImGuiWrapper::init_font().

◆ font_icons_extra_large

const std::map<const wchar_t, std::string> Slic3r::GUI::font_icons_extra_large

static

Initial value:

= {
    {ImGui::ClippyMarker            , "notification_clippy"             },
}

Referenced by Slic3r::GUI::ImGuiWrapper::init_font().

◆ font_icons_large

const std::map<const wchar_t, std::string> Slic3r::GUI::font_icons_large

static

Referenced by Slic3r::GUI::ImGuiWrapper::init_font().

◆ FREQ_SETTINGS_BUNDLE_FFF

SettingsFactory::Bundle Slic3r::GUI::FREQ_SETTINGS_BUNDLE_FFF

static

Initial value:

=
{
    { L("Layers and Perimeters"), { "layer_height" , "perimeters", "top_solid_layers", "bottom_solid_layers" } },
    { L("Infill")               , { "fill_density", "fill_pattern" } },
    { L("Support material")     , { "support_material", "support_material_auto", "support_material_threshold",
                                    "support_material_pattern", "support_material_interface_pattern", "support_material_buildplate_only",
                                    "support_material_spacing" } },
    { L("Wipe options")         , { "wipe_into_infill", "wipe_into_objects" } }
}

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_settings(), and create_freq_settings_popupmenu().

◆ FREQ_SETTINGS_BUNDLE_SLA

SettingsFactory::Bundle Slic3r::GUI::FREQ_SETTINGS_BUNDLE_SLA

static

Initial value:

=
{
    { L("Pad and Support")      , { "supports_enable", "pad_enable" } }
}

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_settings(), and create_freq_settings_popupmenu().

◆ GRABBER_COLOR

const ColorRGBA Slic3r::GUI::GRABBER_COLOR = ColorRGBA::YELLOW()

static

Referenced by Slic3r::GUI::GLGizmoCut3D::render_cut_line(), and Slic3r::GUI::GLGizmoCut3D::render_cut_plane_grabbers().

◆ grey

std::string Slic3r::GUI::grey = "#808080"

static

Referenced by Slic3r::GUI::ModelNode::UpdateEnabling().

◆ HOVERED_DOWEL_COLOR

const ColorRGBA Slic3r::GUI::HOVERED_DOWEL_COLOR = ColorRGBA(0.0f, 0.5f, 0.5f, 1.0f)

static

Referenced by Slic3r::GUI::GLGizmoCut3D::render_connectors().

◆ HOVERED_ERR_COLOR

const ColorRGBA Slic3r::GUI::HOVERED_ERR_COLOR = ColorRGBA(1.0f, 0.3f, 0.3f, 1.0f)

static

Referenced by Slic3r::GUI::GLGizmoCut3D::render_connectors().

◆ HOVERED_PLAG_COLOR

const ColorRGBA Slic3r::GUI::HOVERED_PLAG_COLOR = ColorRGBA::CYAN()

static

Referenced by Slic3r::GUI::GLGizmoCut3D::render_connectors().

◆ HYPERTEXT_MARKER_END

const std::string Slic3r::GUI::HYPERTEXT_MARKER_END = "</a>"

Referenced by Slic3r::GUI::HintDatabase::load_hints_from_file().

◆ HYPERTEXT_MARKER_START

const std::string Slic3r::GUI::HYPERTEXT_MARKER_START = "<a>"

Referenced by Slic3r::GUI::HintDatabase::load_hints_from_file().

◆ INFO_ITEMS

const std::map<InfoItemType, InfoItemAtributes> Slic3r::GUI::INFO_ITEMS

Initial value:

{
 
            { InfoItemType::CustomSupports,      {L("Paint-on supports"),       "fdm_supports_" },     },
            { InfoItemType::CustomSeam,          {L("Paint-on seam"),           "seam_" },             },
            { InfoItemType::CutConnectors,       {L("Cut connectors"),          "cut_connectors" },    },
            { InfoItemType::MmuSegmentation,     {L("Multimaterial painting"),  "mmu_segmentation_"},  },
            { InfoItemType::Sinking,             {L("Sinking"),                 "sinking"},            },
            { InfoItemType::VariableLayerHeight, {L("Variable layer height"),   "layers"},             },
}

Referenced by Slic3r::GUI::ObjectDataViewModel::ObjectDataViewModel(), and Slic3r::GUI::ObjectDataViewModel::UpdateBitmaps().

◆ IsFinishFn

template<class Fn >

constexpr bool Slic3r::GUI::IsFinishFn = std::is_invocable_v<Fn, bool, std::exception_ptr&>

constexpr

◆ IsProcessFn

template<class Fn >

constexpr bool Slic3r::GUI::IsProcessFn = std::is_invocable_v<Fn, Job::Ctl&>

constexpr

◆ LayerIcon

constexpr char Slic3r::GUI::LayerIcon[] = "edit_layers_some"

staticconstexpr

Referenced by Slic3r::GUI::ObjectDataViewModelNode::ObjectDataViewModelNode(), and Slic3r::GUI::ObjectDataViewModel::UpdateBitmaps().

◆ LayerRootIcon

constexpr char Slic3r::GUI::LayerRootIcon[] = "edit_layers_all"

staticconstexpr

Referenced by Slic3r::GUI::ObjectDataViewModelNode::ObjectDataViewModelNode(), and Slic3r::GUI::ObjectDataViewModel::UpdateBitmaps().

◆ legacy_preset_map

const std::unordered_map<std::string, std::pair<std::string, std::string> > Slic3r::GUI::legacy_preset_map

static

Initial value:

{{
    { "Original Prusa i3 MK2.ini",                           std::make_pair("MK2S", "0.4") },
    { "Original Prusa i3 MK2 MM Single Mode.ini",            std::make_pair("MK2SMM", "0.4") },
    { "Original Prusa i3 MK2 MM Single Mode 0.6 nozzle.ini", std::make_pair("MK2SMM", "0.6") },
    { "Original Prusa i3 MK2 MultiMaterial.ini",             std::make_pair("MK2SMM", "0.4") },
    { "Original Prusa i3 MK2 MultiMaterial 0.6 nozzle.ini",  std::make_pair("MK2SMM", "0.6") },
    { "Original Prusa i3 MK2 0.25 nozzle.ini",               std::make_pair("MK2S", "0.25") },
    { "Original Prusa i3 MK2 0.6 nozzle.ini",                std::make_pair("MK2S", "0.6") },
    { "Original Prusa i3 MK3.ini",                           std::make_pair("MK3",  "0.4") },
}}

Referenced by Slic3r::GUI::ConfigWizard::priv::load_vendors().

◆ LockIcon

constexpr char Slic3r::GUI::LockIcon[] = "cut_"

staticconstexpr

Referenced by Slic3r::GUI::ObjectDataViewModel::ObjectDataViewModel(), Slic3r::GUI::ObjectDataViewModel::UpdateBitmapForNode(), and Slic3r::GUI::ObjectDataViewModel::UpdateBitmaps().

◆ LOGICAL_BED_GAP

const constexpr double Slic3r::GUI::LOGICAL_BED_GAP = 1. / 5.

staticconstexpr

Referenced by bed_stride().

◆ LOWER_PART_COLOR

const ColorRGBA Slic3r::GUI::LOWER_PART_COLOR = ColorRGBA::MAGENTA()

static

Referenced by Slic3r::GUI::GLGizmoCut3D::on_set_state(), Slic3r::GUI::GLGizmoCut3D::PartSelection::render(), and Slic3r::GUI::GLGizmoCut3D::render_cut_plane_input_window().

◆ m_bitmap_cache

BitmapCache* Slic3r::GUI::m_bitmap_cache = nullptr

Referenced by Slic3r::GUI::ObjectDataViewModel::~ObjectDataViewModel(), find_bndl(), Slic3r::GUI::ObjectDataViewModelNode::update_settings_digest_bitmaps(), and Slic3r::GUI::ObjectDataViewModel::UpdateBitmapForNode().

◆ MODE_PALETTES

std::vector<std::pair<std::string, std::vector<std::string> > > Slic3r::GUI::MODE_PALETTES

static

Initial value:

=
{
  { L("Palette 1 (default)"), { "#00B000", "#FFDC00", "#E70000" } },
  { L("Palette 2"), { "#FC766A", "#B0B8B4", "#184A45" } },
  { L("Palette 3"), { "#567572", "#964F4C", "#696667" } },
  { L("Palette 4"), { "#DA291C", "#56A8CB", "#53A567" } },
  { L("Palette 5"), { "#F65058", "#FBDE44", "#28334A" } },
  { L("Palette 6"), { "#FF3EA5", "#EDFF00", "#00A4CC" } },
  { L("Palette 7"), { "#E95C20", "#006747", "#4F2C1D" } },
  { L("Palette 8"), { "#D9514E", "#2A2B2D", "#2DA8D8" } }
}

Referenced by Slic3r::GUI::ModePaletteComboBox::ModePaletteComboBox(), Slic3r::GUI::GUI_Descriptions::FillSizerWithModeColorDescriptions(), and Slic3r::GUI::ModePaletteComboBox::UpdateSelection().

◆ MODIFIER_COLOR

const ColorRGBA Slic3r::GUI::MODIFIER_COLOR = ColorRGBA(0.75f, 0.75f, 0.75f, 0.5f)

static

Referenced by Slic3r::GUI::GLGizmoCut3D::PartSelection::render().

◆ NEUTRAL_COLOR

const Slic3r::ColorRGBA Slic3r::GUI::NEUTRAL_COLOR = { 0.5f, 0.5f, 0.5f, 1.0f }

static

Referenced by Slic3r::GUI::GLGizmoMeasure::on_render().

◆ none

std::string Slic3r::GUI::none {"none"}

static

Referenced by Slic3r::GUI::UnsavedChangesDialog::UnsavedChangesDialog(), Slic3r::GUI::UnsavedChangesDialog::UnsavedChangesDialog(), and Slic3r::GUI::UnsavedChangesDialog::build().

◆ options_without_field

const std::set<std::string> Slic3r::GUI::options_without_field

static

Initial value:

= {
    "compatible_printers",
    "compatible_prints",
    "bed_shape",
    "filament_ramming_parameters",
    "gcode_substitutions",
}

Referenced by Slic3r::GUI::OptionsGroup::is_option_without_field().

◆ orange

std::string Slic3r::GUI::orange = "#ed6b21"

static

Referenced by Slic3r::GUI::FullCompareDialog::FullCompareDialog(), Slic3r::GUI::ModelNode::ModelNode(), and Slic3r::GUI::ModelNode::UpdateEnabling().

◆ PLAG_COLOR

const ColorRGBA Slic3r::GUI::PLAG_COLOR = ColorRGBA::YELLOW()

static

Referenced by Slic3r::GUI::GLGizmoCut3D::render_connectors().

◆ PLANE_ID

const int Slic3r::GUI::PLANE_ID = 400

static

Referenced by Slic3r::GUI::GLGizmoMeasure::on_render().

◆ POINT_ID

const int Slic3r::GUI::POINT_ID = 100

static

Referenced by Slic3r::GUI::GLGizmoMeasure::on_mouse(), and Slic3r::GUI::GLGizmoMeasure::on_render().

◆ ScaleLongEvery

const unsigned int Slic3r::GUI::ScaleLongEvery = 2

Referenced by init_from_scale().

◆ ScaleLongTooth

const float Slic3r::GUI::ScaleLongTooth = 0.1f

Referenced by init_from_scale().

◆ ScaleStepRad

const float Slic3r::GUI::ScaleStepRad = 2.0f * float(PI) / ScaleStepsCount

Referenced by init_from_circle(), and init_from_scale().

◆ ScaleStepsCount

const unsigned int Slic3r::GUI::ScaleStepsCount = 72

Referenced by Slic3r::GUI::GLGizmoCut3D::dragging_grabber_xy(), init_from_circle(), init_from_scale(), and init_from_snap_radii().

◆ SEL_SPHERE_1_ID

const int Slic3r::GUI::SEL_SPHERE_1_ID = 501

static

Referenced by Slic3r::GUI::GLGizmoMeasure::gizmo_event(), Slic3r::GUI::GLGizmoMeasure::on_mouse(), Slic3r::GUI::GLGizmoMeasure::on_render(), and Slic3r::GUI::GLGizmoMeasure::on_render_input_window().

◆ SEL_SPHERE_2_ID

const int Slic3r::GUI::SEL_SPHERE_2_ID = 502

static

Referenced by Slic3r::GUI::GLGizmoMeasure::gizmo_event(), Slic3r::GUI::GLGizmoMeasure::on_mouse(), Slic3r::GUI::GLGizmoMeasure::on_render(), and Slic3r::GUI::GLGizmoMeasure::on_render_input_window().

◆ SELECTED_1ST_COLOR

const Slic3r::ColorRGBA Slic3r::GUI::SELECTED_1ST_COLOR = { 0.25f, 0.75f, 0.75f, 1.0f }

static

Referenced by Slic3r::GUI::GLGizmoMeasure::on_render(), and Slic3r::GUI::GLGizmoMeasure::on_render_input_window().

◆ SELECTED_2ND_COLOR

const Slic3r::ColorRGBA Slic3r::GUI::SELECTED_2ND_COLOR = { 0.75f, 0.25f, 0.75f, 1.0f }

static

Referenced by Slic3r::GUI::GLGizmoMeasure::on_render(), and Slic3r::GUI::GLGizmoMeasure::on_render_input_window().

◆ SELECTED_DOWEL_COLOR

const ColorRGBA Slic3r::GUI::SELECTED_DOWEL_COLOR = ColorRGBA::DARK_GRAY()

static

Referenced by Slic3r::GUI::GLGizmoCut3D::render_connectors().

◆ SELECTED_PLAG_COLOR

const ColorRGBA Slic3r::GUI::SELECTED_PLAG_COLOR = ColorRGBA::GRAY()

static

Referenced by Slic3r::GUI::GLGizmoCut3D::render_connectors().

◆ SEND_SYSTEM_INFO_DOMAIN

const std::string Slic3r::GUI::SEND_SYSTEM_INFO_DOMAIN = "prusa3d.com"

static

◆ SEND_SYSTEM_INFO_URL

const std::string Slic3r::GUI::SEND_SYSTEM_INFO_URL = "https://files." + SEND_SYSTEM_INFO_DOMAIN + "/wp-json/v1/ps"

static

Referenced by Slic3r::GUI::SendSystemInfoDialog::send_info().

◆ sep

const wxString Slic3r::GUI::sep = " - "

static

Referenced by add_common_view_menu_items(), generate_help_menu(), Slic3r::GUI::MainFrame::init_menubar_as_editor(), and Slic3r::GUI::MainFrame::init_menubar_as_gcodeviewer().

◆ sep_space

const wxString Slic3r::GUI::sep_space = ""

static

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

◆ SnapRegionsCount

const unsigned int Slic3r::GUI::SnapRegionsCount = 8

Referenced by Slic3r::GUI::GLGizmoCut3D::dragging_grabber_xy(), and init_from_snap_radii().

◆ TEXT_VOLUME_ICONS

const constexpr std::array<std::pair<const char *, const char *>, 3> Slic3r::GUI::TEXT_VOLUME_ICONS

staticconstexpr

Initial value:

{{
 
        {L("Add text"),             "add_text_part"},        
        {L("Add negative text"),    "add_text_negative" },   
        {L("Add text modifier"),    "add_text_modifier"},    
}}

Referenced by Slic3r::GUI::MenuFactory::get_text_volume_bitmaps().

◆ TOP_LABELS

std::map<Preset::Type, std::string> Slic3r::GUI::TOP_LABELS

static

Initial value:

=
{
    
    { Preset::Type::TYPE_PRINT,         L("Save print settings as")   },
    { Preset::Type::TYPE_SLA_PRINT,     L("Save print settings as")   },
    { Preset::Type::TYPE_FILAMENT,      L("Save filament settings as")},
    { Preset::Type::TYPE_SLA_MATERIAL,  L("Save material settings as")},
    { Preset::Type::TYPE_PRINTER,       L("Save printer settings as") },
}

Referenced by Slic3r::GUI::SavePresetDialog::Item::Item().

◆ TRIANGLE_BASE

const float Slic3r::GUI::TRIANGLE_BASE = 10.0f

static

Referenced by Slic3r::GUI::GLGizmoMeasure::render_dimensioning().

◆ TRIANGLE_HEIGHT

const float Slic3r::GUI::TRIANGLE_HEIGHT = TRIANGLE_BASE * 1.618033f

static

Referenced by Slic3r::GUI::GLGizmoMeasure::render_dimensioning().

◆ type_icon_names

const std::map<Preset::Type, std::string> Slic3r::GUI::type_icon_names

static

Initial value:

= {
    {Preset::TYPE_PRINT,        "cog"           },
    {Preset::TYPE_SLA_PRINT,    "cog"           },
    {Preset::TYPE_FILAMENT,     "spool"         },
    {Preset::TYPE_SLA_MATERIAL, "resin"         },
    {Preset::TYPE_PRINTER,      "printer"       },
}

Referenced by get_icon_name().

◆ UndefFloat

const float Slic3r::GUI::UndefFloat = -999.f

Referenced by Slic3r::GUI::GLGizmoCut3D::init_input_window_data().

◆ UndefLabel

const std::string Slic3r::GUI::UndefLabel = " "

Referenced by Slic3r::GUI::GLGizmoCut3D::render_slider_double_input().

◆ UPPER_PART_COLOR

const ColorRGBA Slic3r::GUI::UPPER_PART_COLOR = ColorRGBA::CYAN()

static

Referenced by Slic3r::GUI::GLGizmoCut3D::on_set_state(), Slic3r::GUI::GLGizmoCut3D::PartSelection::render(), and Slic3r::GUI::GLGizmoCut3D::render_cut_plane_input_window().

◆ URL_CHANGELOG

const char* Slic3r::GUI::URL_CHANGELOG = "https://files.prusa3d.com/?latest=slicer-stable&lng=%1%"

static

Referenced by Slic3r::GUI::MsgUpdateSlic3r::MsgUpdateSlic3r().

◆ URL_DEV

const char* Slic3r::GUI::URL_DEV = "https://github.com/prusa3d/PrusaSlicer/releases/tag/version_%1%"

static

Referenced by Slic3r::GUI::MsgUpdateSlic3r::MsgUpdateSlic3r().

◆ URL_DOWNLOAD

const char* Slic3r::GUI::URL_DOWNLOAD = "https://www.prusa3d.com/slicerweb&lng=%1%"

static

Referenced by Slic3r::GUI::MsgUpdateSlic3r::MsgUpdateSlic3r().

◆ VOLUME_RAYCASTERS_BASE_ID

const int Slic3r::GUI::VOLUME_RAYCASTERS_BASE_ID = (int)SceneRaycaster::EIdBase::Gizmo

static

Referenced by Slic3r::GUI::GLGizmoSlaBase::register_volume_raycasters_for_picking(), and Slic3r::GUI::GLGizmoSlaBase::unregister_volume_raycasters_for_picking().

◆ WarningIcon

constexpr char Slic3r::GUI::WarningIcon[] = "exclamation"

staticconstexpr

Referenced by Slic3r::GUI::ObjectDataViewModel::ObjectDataViewModel(), Slic3r::GUI::ObjectDataViewModel::UpdateBitmapForNode(), and Slic3r::GUI::ObjectDataViewModel::UpdateBitmaps().

◆ WarningManifoldIcon

constexpr char Slic3r::GUI::WarningManifoldIcon[] = "exclamation_manifold"

staticconstexpr

Referenced by Slic3r::GUI::ObjectDataViewModel::ObjectDataViewModel(), Slic3r::GUI::ObjectDataViewModel::AddVolumeChild(), and Slic3r::GUI::ObjectDataViewModel::UpdateBitmaps().

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Class Documentation

◆ Slic3r::GUI::BackgroundTexture

◆ Slic3r::GUI::BlockingWait

◆ Slic3r::GUI::FileWildcards

◆ Slic3r::GUI::FontImageData

◆ Slic3r::GUI::GUI_InitParams

◆ Slic3r::GUI::HintData

◆ Slic3r::GUI::InfoItemAtributes

◆ Slic3r::GUI::MeshErrorsInfo

◆ Slic3r::GUI::PresetTab

◆ Slic3r::GUI::SurfaceDrag

Typedef Documentation

◆ CancelFn

◆ choice_ctrl

◆ column_t

◆ ConfigOptionsGroupShp

◆ ConfigOptionsGroupWkp

◆ coordf_t

◆ DPIDialog

◆ DPIFrame

◆ EjectDriveNotificationClickedEvent

◆ ExportGcodeNotificationClickedEvent

◆ FullSettingsHierarchy

◆ HeightProfileSmoothEvent

◆ InstanceGoToFrontEvent

◆ LoadFromOtherInstanceEvent

◆ ModelFilter

◆ ModelNodePtrArray

◆ Pages3rdparty

◆ PageShp

◆ PresetAliases

◆ PresetList

◆ PresetUpdateAvailableClickedEvent

◆ RBtnEvent

◆ RemovableDriveEjectEvent

◆ RemovableDrivesChangedEvent

◆ StartDownloadOtherInstanceEvent

◆ StringList

◆ t_back_to_init

◆ t_change

◆ t_field

◆ t_kill_focus

◆ t_layer_height_range

◆ t_opt_map

◆ t_optgroups

◆ t_option

◆ t_optionfield_map

◆ Vec2dEvent

◆ Vec2dsEvent

◆ Vec3dEvent

◆ Vec3dsEvent

◆ widget_t

Enumeration Type Documentation

◆ anonymous enum

◆ anonymous enum

◆ Action

◆ ActionButtons

◆ ActionButtonType

◆ BundleLocation

◆ ColumnNumber

◆ CommonGizmosDataID

◆ ConfigMenuIDs

◆ DownloaderUserAction

◆ DownloadState

◆ ECoordinatesType

◆ EditorType

◆ ERescaleTarget

◆ ExportingStatus

◆ FileType

◆ InfoItemType

◆ ItemType

◆ NewSlicerInstanceType

◆ NotificationType

◆ PainterGizmoType