Slic3r::GUI Namespace Reference

Namespaces
namespace	Config
namespace	anonymous_namespace{ActionRegistry.cpp}
namespace	anonymous_namespace{AnimatedTexture.cpp}
namespace	anonymous_namespace{AuiMgr.cpp}
namespace	anonymous_namespace{DesignSketchTool.cpp}
namespace	anonymous_namespace{McpControl.cpp}
namespace	anonymous_namespace{SketchInlineEditor.cpp}
namespace	anonymous_namespace{calib_dlg.cpp}
namespace	anonymous_namespace{ColorPickerDialog.cpp}
namespace	anonymous_namespace{ConfigManipulation.cpp}
namespace	anonymous_namespace{Downloader.cpp}
namespace	anonymous_namespace{Field.cpp}
namespace	anonymous_namespace{FilamentBitmapUtils.cpp}
namespace	anonymous_namespace{GLGizmoAlignment.cpp}
namespace	CommonGizmosDataObjects
namespace	anonymous_namespace{GLGizmoTextureDisplacement.cpp}
namespace	GLGizmoUtils
namespace	anonymous_namespace{GradientCurveEditor.cpp}
namespace	anonymous_namespace{GUI_App.cpp}
namespace	anonymous_namespace{HintNotification.cpp}
namespace	I18N
namespace	anonymous_namespace{IdleScheduler.cpp}
namespace	MessageHandlerInternal
namespace	Emboss
namespace	anonymous_namespace{KBShortcutsDialog.cpp}
namespace	anonymous_namespace{KeyChord.cpp}
namespace	anonymous_namespace{MainFrame.cpp}
namespace	anonymous_namespace{NativeCommands.cpp}
namespace	NativeCommands
namespace	anonymous_namespace{NotificationManager.cpp}
namespace	anonymous_namespace{ParamsPanel.cpp}
namespace	anonymous_namespace{Plater.cpp}
namespace	anonymous_namespace{PluginsConfigDialog.cpp}
namespace	anonymous_namespace{PluginsDialog.cpp}
namespace	detail
namespace	anonymous_namespace{PrinterWebViewHandler.cpp}
namespace	anonymous_namespace{PrintHostDialogs.cpp}
namespace	anonymous_namespace{PublishSettingsDialog.cpp}
namespace	search_for_drives_internal
namespace	anonymous_namespace{SceneBenchmark.cpp}
namespace	anonymous_namespace{Shortcuts.cpp}
namespace	anonymous_namespace{SlicingProgressNotification.cpp}
namespace	anonymous_namespace{SpeedDialDialog.cpp}
namespace	anonymous_namespace{Tab.cpp}
namespace	anonymous_namespace{TerminalDialog.cpp}
namespace	anonymous_namespace{TextureLibrary.cpp}
namespace	anonymous_namespace{UVEditorCanvas.cpp}
namespace	anonymous_namespace{WebMediaController.cpp}
namespace	anonymous_namespace{WebUserLoginDialog.cpp}
namespace	web_hosting
namespace	anonymous_namespace{WebViewHostDialog.cpp}

Classes
class	Bed_2D
class	Bed3D
class	AboutDialogLogo
class	CopyrightsDialog
class	AboutDialog
struct	AppActionRunResult
struct	AppActionId
struct	AppAction
class	ActionRegistry
struct	DryingPreset
class	FilamentItemPanel
class	AMSFilamentPanel
class	AMSDryCtrWin
struct	TrayData
class	MaterialItem
class	MaterialSyncItem
class	MappingItem
class	MappingContainer
class	DevIconLabel
class	AmsMapingPopup
class	AmsMapingTipPopup
class	AmsHumidityLevelList
class	AmsHumidityTipPopup
class	AmsTutorialPopup
class	AmsIntroducePopup
class	AmsRMGroup
class	AmsReplaceMaterialDialog
class	ColorPicker
class	ColorPickerPopup
class	AMSMaterialsSetting
class	AMSSetting
class	AMSSettingTypePanel
class	TrayListModel
class	AnimatedTexture
class	AnimatedTextureCache
class	AuiMgr
class	AuFile
class	AuFiles
class	AuFolderPanel
class	DesignerPanel
class	AuxiliaryPanel
class	AuxiliaryDialog
class	BaseTransparentDPIFrame
struct	BedShape
class	BedShapePanel
class	BedShapeDialog
struct	BeltPurgeSignature
struct	MemoryStruct
class	PingCodeBindDialog
class	BindMachineDialog
class	UnBindMachineDialog
class	BitmapCache
class	BitmapComboBox
class	DesignCanvas
struct	CadInteractionState
struct	OfferVerb
struct	DpToken
class	DesignVariableDialog
class	DesignPanel
class	DesignRowList
struct	PlanePiece
class	DesignSketchTool
class	DesignTextDialog
class	SketchInlineEditor
class	PA_Calibration_Dlg
class	Temp_Calibration_Dlg
class	MaxVolumetricSpeed_Test_Dlg
class	VFA_Test_Dlg
class	Retraction_Test_Dlg
class	Input_Shaping_Freq_Test_Dlg
class	Input_Shaping_Damp_Test_Dlg
class	Cornering_Test_Dlg
class	FlowRateCalibrationDialog
class	CalibrationDialog
class	MObjectPanel
class	MPanel
class	SelectMObjectPopup
class	CalibrationPanel
struct	TrayInfo
class	CalibrationWizardPageStep
struct	ConfigIndexValue
class	CalibrationWizard
class	PressureAdvanceWizard
class	FlowRateWizard
class	MaxVolumetricSpeedWizard
class	CalibrationCaliPage
class	FilamentComboBox
class	CaliPageCaption
class	CaliPageStepGuide
class	CaliPagePicture
class	PAPageHelpPanel
class	CaliPageButton
class	CaliPageSendingPanel
class	CaliPageActionPanel
class	CalibrationWizardPage
class	CaliPresetCaliStagePanel
class	CaliComboBox
class	CaliPresetWarningPanel
class	CaliPresetTipsPanel
class	CaliPresetCustomRangePanel
class	CalibrationPresetPage
class	MaxVolumetricSpeedPresetPage
class	GridTextInput
class	GridComboBox
class	CalibrationCommonSavePage
class	PAColumnDataPanel
class	CaliSavePresetValuePanel
class	CaliPASaveAutoPanel
class	CaliPASaveManualPanel
class	CaliPASaveP1PPanel
class	CalibrationPASavePage
class	CalibrationFlowX1SavePage
class	CalibrationFlowCoarseSavePage
class	CalibrationFlowFineSavePage
class	CalibrationMaxVolumetricSpeedSavePage
class	CalibrationStartPage
class	CalibrationPAStartPage
class	CalibrationFlowRateStartPage
class	CalibrationMaxVolumetricSpeedStartPage
class	HistoryWindow
class	EditCalibrationHistoryDialog
class	NewCalibrationHistoryDialog
struct	Camera
class	CameraPopup
class	CameraItem
class	CameraUtils
	Help divide camera data and camera functions This utility work with camera data by static funtions. More...
class	CapsuleButton
class	CloneDialog
struct	DecomposeComponent
struct	ColorDecomposeResult
class	ColorDecomposeDialog
struct	DecomposeOfficialComponent
struct	DecomposeMissingComponent
struct	ColorPickerOptions
struct	FilamentColorPickerValue
class	ColorPickerDialog
class	ConfigManipulation
struct	PrinterPickerEvent
class	DiamTextCtrl
class	SpinCtrlDouble
class	ConfigWizard
struct	Bundle
struct	BundleMap
struct	Materials
struct	PrinterPicker
struct	ConfigWizardPage
struct	PageWelcome
struct	PagePrinters
struct	DataList
struct	ProfilePrintData
struct	PageMaterials
struct	PageCustom
struct	PageFirmware
struct	PageBedShape
struct	PageDiameters
struct	PageTemperatures
class	ConfigWizardIndex
class	ConnectPrinterDialog
class	CrealityDiscoveryDialog
class	CreateFilamentPresetDialog
class	CreatePrinterPresetDialog
class	CreatePresetSuccessfulDialog
class	ExportConfigsDialog
class	CreatePresetForPrinterDialog
class	PresetTree
class	EditFilamentPresetDialog
struct	DailyTipsData
class	DailyTipsDataRenderer
class	DailyTipsPanel
class	DailyTipsWindow
class	DeviceErrorDialog
class	UiStyledAMSPanel
class	UiStyledSwitchPanel
class	UiAMSSlot
struct	DataAmsSlotInfo
class	UiAMS
struct	DataStatusParam
class	ReselectMachineDialog
struct	uiAmsHumidityInfo
class	uiAmsPercentHumidityDryPopup
class	uiDeviceUpdateVersion
class	wgtDeviceNozzleRackTitle
class	wgtDeviceNozzleRack
class	wgtDeviceNozzleRackToolHead
class	wgtDeviceNozzleRackArea
class	wgtDeviceNozzleRackPos
class	wgtDeviceNozzleRackNozzleItem
class	wgtDeviceNozzleRackUpgradeDlg
class	wgtDeviceNozzleRackUprade
class	wgtDeviceNozzleRackHotendUpdate
class	wgtDeviceNozzleRackSelect
class	wgtMsgBox
class	wgtMsgPanelItem
class	wgtMsgPanel
class	DockPanel
class	Download
class	Downloader
class	FileGet
class	DownloadProgressDialog
class	DragShape
class	DragCanvas
struct	CustomData
class	ColorDataObject
class	ColorDropSource
class	ColorDropTarget
class	SeparatedColorDropTarget
class	DragDropPanel
class	ColorPanel
class	SeparatedDragDropPanel
class	EditGCodeDialog
class	ParamsNode
class	ParamsModel
class	ParamsViewCtrl
struct	SimpleEvent
struct	IntEvent
struct	ArrayEvent
struct	Event
class	LoadPrinterViewEvent
class	ExportPresetBundleDialog
class	ExtrusionCalibration
struct	Builder
struct	wxEventFunctorRef
struct	myEvtHandler
class	UndoValueUIManager
class	Field
class	TextCtrl
class	CheckBox
class	SpinCtrl
class	DynamicList
class	Choice
class	PrinterAgentChoice
class	PluginField
class	PluginConfigField
class	ColourPicker
class	PointCtrl
class	StaticText
class	SliderCtrl
struct	BitmapDC
struct	TriPoint
struct	MixedGradientCurve
struct	MixedGradientTheme
struct	MixedTriangleTheme
class	FilamentGroupPopup
class	SmartFilamentPanel
class	FilamentMapDialog
class	FilamentMapManualPanel
class	FilamentMapBtnPanel
class	FilamentMapAutoPanel
class	FilamentMapDefaultPanel
class	FilamentPickerDialog
class	ArchiveViewNode
class	ArchiveViewModel
class	ArchiveViewCtrl
class	FileArchiveDialog
class	FrameProfiler
class	ToolpathsObjExporter
class	GCodeViewer
class	GizmoObjectManipulation
class	GLGizmoAlignment
class	GLGizmoAssembly
class	GLGizmoBase
class	GLGizmoBrimEars
class	GLGizmoCut3D
class	GLGizmoEmboss
class	GLGizmoFdmSupports
class	GLGizmoFlatten
class	GLGizmoFuzzySkin
class	TransformHelper
class	GLGizmoMeasure
struct	VolumeInfo
class	GLGizmoMeshBoolean
class	GLMmSegmentationGizmo3DScene
class	GLGizmoMmuSegmentation
class	GLGizmoMove3D
class	TriangleSelectorGUI
struct	TrianglePatch
class	TriangleSelectorPatch
class	GLGizmoPainterBase
class	GLGizmoRotate
class	GLGizmoRotate3D
class	GLGizmoScale3D
class	CommonGizmosDataPool
class	CommonGizmosDataBase
class	GLGizmoSeam
class	GLGizmoSimplify
class	Rect
class	GLGizmosManager
struct	Texture
class	GLGizmoSVG
class	GLGizmoTextureDisplacement
class	Size
class	RenderTimerEvent
class	ToolbarHighlighterTimerEvent
class	GizmoHighlighterTimerEvent
class	GLCanvas3D
class	GLModel
class	GLSelectionRectangle
class	GLTexture
class	GLToolbarItem
struct	BackgroundTexture
class	GLToolbar
class	GradientCurveEditor
class	SplashScreen
struct	FileWildcards
class	wxBoostLog
class	VersionInfo
class	GUI_App
struct	SimpleSettingData
struct	SettingsFactory
class	MenuFactory
class	TransformationType
struct	OpenGLVersions
struct	GUI_InitParams
class	LayerRangeEditor
class	ObjectLayers
class	wxRenderer
struct	ObjectVolumeID
struct	ItemForDelete
struct	MeshErrorsInfo
class	ObjectList
class	OG_Settings
class	ObjectSettings
class	GridCellIconRenderer
class	GridCellTextEditor
class	GridCellFilamentsEditor
class	GridCellFilamentsRenderer
class	GridCellChoiceEditor
class	GridCellComboBoxRenderer
class	GridCellSupportEditor
class	GridCellSupportRenderer
class	ObjectGrid
class	ObjectGridTable
class	ObjectTablePanel
class	ObjectTableDialog
class	OTG_Settings
class	ObjectTableSettings
class	View3D
class	Preview
class	AssembleView
class	DPIAware
class	DPIDialog
class	EventGuard
class	CheckboxFileDialog
class	WindowMetrics
class	TaskTimer
class	KeyAutoRepeatFilter
struct	HintData
class	HintDatabase
class	HMSQuery
class	HMSNotifyItem
class	HMSPanel
class	http_headers
class	HttpServer
class	session
class	IconManager
	Keep texture with icons for UI Manage texture live -> create and destruct texture by live of icon shared pointers. More...
class	IdleScheduler
class	ImageDPIFrame
class	ImageGrid
class	IMediaController
class	IMEXFilamentPickerPopover
class	IMEXModesCtrl
class	ImGuiWrapper
class	IMTexture
class	IMSlider
class	IMToolbarItem
class	IMToolbar
class	IMReturnToolbar
class	OtherInstanceMessageHandler
class	WipeTower
class	ArrangeJob
class	BindJob
class	BoostThreadWorker
struct	CursorSetterRAII
class	BusyCursored
struct	FontImageData
	Keep data for rasterization of text by font face. More...
class	CreateFontImageJob
	Create image for face name. More...
class	FillBedJob
class	Job
class	NotificationProgressIndicator
struct	OAuthParams
struct	OAuthResult
struct	OAuthData
class	OAuthJob
class	OrientJob
class	PlaterWorker
class	PrintPrepareData
class	PlateListData
class	PrintJob
class	RotoptimizeJob
class	SendJob
class	SLAImportDialog
class	SLAImportJobView
class	SLAImportJob
struct	TextureDisplacementBakeVolume
struct	TextureDisplacementBakeInput
class	TextureDisplacementBakeJob
struct	TextureDisplacementDebugInput
class	TextureDisplacementDebugJob
struct	TextureDisplacementPrepareVolume
struct	TextureDisplacementPrepareInput
class	TextureDisplacementPrepareJob
struct	TextureDisplacementPreviewVolume
struct	TextureDisplacementPreviewInput
struct	TextureDisplacementPreviewResult
class	TextureDisplacementPreviewJob
struct	BlockingWait
class	ThreadSafeQueueSPSC
class	UpgradeNetworkJob
class	Worker
class	KBShortcutsDialog
class	ShortcutCaptureDialog
struct	KeyChord
struct	KeyChordHash
class	LazyInstance
class	LazyBase
class	Lazy
class	LazyPage
struct	ConfigsOverwriteConfirmDialog
struct	PresetTab
class	SettingsDialog
class	MainFrame
class	MarkdownTip
struct	MediaProgressDialog
class	MediaFilePanel
class	MediaFileFrame
class	MediaPlayCtrl
class	ClippingPlane
class	MeshClipper
class	MeshRaycaster
struct	PickingModel
class	RatioLabelPanel
struct	MixedFilamentResult
class	MixedFilamentDialog
class	ModelMallDialog
class	AddMachinePanel
class	MonitorPanel
class	MonitorBasePanel
	Class MonitorBasePanel. More...
class	VideoMonitoringBasePanel
	Class VideoMonitoringBasePanel. More...
class	TaskListBasePanel
	Class TaskListBasePanel. More...
class	MonitorPage
class	Mouse3DController
class	CodeExcerptTagHandler
struct	ButtonData
class	MsgButton
struct	MsgDialog
class	ErrorDialog
class	WarningDialog
class	MessageDialog
class	RichMessageDialog
class	InfoDialog
class	DownloadDialog
class	DeleteConfirmDialog
class	Newer3mfVersionDialog
class	NetworkErrorDialog
struct	FilamentWarningInfo
class	FilamentWarningDialog
class	MultiChoiceDialog
class	DeviceItem
struct	ObjState
struct	SortItem
class	MultiMachineItem
class	MultiMachineManagerPage
class	MultiMachinePage
class	DevicePickItem
class	MultiMachinePickPage
class	MultiSendMachineModel
class	MultiTaskItem
class	LocalTaskManagerPage
class	CloudTaskManagerPage
struct	NativeCommand
class	NetworkPluginDownloadDialog
class	NetworkPluginRestartDialog
class	NetworkTestDialog
struct	JumpTo
class	NotificationManager
class	OAuthDialog
struct	InfoItemAtributes
class	ObjectDataViewModelNode
class	ObjectDataViewModel
class	OG_CustomCtrl
class	OpenGLManager
class	UIBuildCanceled
struct	Option
	std::function<wxWindow*(wxWindow*)>; More...
class	Line
	Represents option lines. More...
class	OptionsGroup
class	ConfigOptionsGroup
class	ExtruderOptionsGroup
class	ogStaticText
class	Filamentinformation
class	ParamsDialog
class	TipsDialog
class	ParamsPanel
	Class ParamsPanel. More...
struct	ExclusionVolumePrismPreview
struct	WipeTowerRelocation
class	PartPlate
class	PartPlateList
class	PartSkipConfirmDialog
class	PartSkipDialog
class	PhysicalPrinterDialog
class	SlicedInfo
class	HoverLabel
struct	ExtruderGroup
struct	DynamicFilamentList
class	AMSCountPopupWindow
class	PlaterDropTarget
class	ProjectDropDialog
class	SidebarProps
class	Sidebar
class	Plater
class	SuppressBackgroundProcessingUpdate
struct	LayerSeqInfo
class	LayerNumberTextInput
class	OtherLayersSeqPanel
class	PlateSettingsDialog
class	PlateNameEditDialog
class	PluginPickerDialog
class	PluginProgressDialog
class	PluginsConfigDialog
class	PluginsDialog
class	PrebuildQueue
class	MyscrolledWindow
class	WikiLabel
class	PreferencesDialog
struct	prePrintInfo
class	PrePrintChecker
class	PrinterMsgPanel
class	PresetBundleDialog
class	PresetComboBox
class	PlaterPresetComboBox
class	TabPresetComboBox
class	CalibrateFilamentComboBox
class	PrinterCloudAuthDialog
class	PrinterWebView
class	PrinterWebViewHandler
class	PrintHostSendDialog
class	PrintHostQueueDialog
class	ElegooPrintHostSendDialog
class	CrealityPrintHostSendDialog
class	FlashforgePrintHostSendDialog
class	PrinterPartsDialog
class	PrintOptionsDialog
class	PrivacyUpdateDialog
class	ProcessRunner
struct	project_file
class	ProjectPanel
class	ProjectDirtyStateManager
class	MixedFilamentWarningDialog
struct	PublishMaterialIdentity
struct	MixedDependencyIssue
class	PublishSettingsDialog
class	PurgeModeBtnPanel
class	PurgeModeDialog
class	RecenterDialog
class	ReleaseNoteDialog
class	UpdatePluginDialog
class	UpdateVersionDialog
class	SecondaryCheckDialog
class	PrintErrorDialog
struct	ConfirmBeforeSendInfo
class	ConfirmBeforeSendDialog
class	InputIpAddressDialog
class	SendFailedConfirm
struct	DriveData
class	RemovableDriveManager
class	SafetyOptionsDialog
class	SavePresetDialog
struct	FrameTimeStats
class	SceneCache
class	SceneRaycasterItem
class	SceneRaycaster
class	Selection
class	Material
struct	POItem
class	PrintOptionItem
class	PrintOption
class	ThumbnailPanel
class	SendModeSwitchButton
class	SelectMachineDialog
class	PrinterInfoBox
class	MachineObjectPanel
class	MachinePanel
class	PinCodePanel
class	SelectMachinePopup
class	EditDevNameDialog
class	ScrolledWindow
class	AmsRadioSelector
class	SendDeviceItem
class	SendMultiMachinePage
class	SendSystemInfoDialog
class	SendSystemInfoProgressDialog
class	ShowJsonDialog
class	SendToPrinterDialog
struct	SequentialClearanceInstance
struct	ShortcutInfo
class	ShortcutRegistry
class	SingleChoiceDialog
struct	ObjectInfo
class	SkipPartCanvas
class	_BBS_3MF_Base
struct	PlateInfo
class	ModelSettingHelper
class	SliceInfoPopup
class	SliceInfoPanel
class	SpeedDialWebDialog
class	StagedBuild
struct	ScoreData
class	ExtruderImage
class	ExtruderSwithingStatus
class	ScoreDialog
class	PrintingTaskPanel
class	StatusBasePanel
class	StatusPanel
struct	SurfaceDrag
class	SyncAmsInfoDialog
class	SyncNozzleAndAmsDialog
class	FinishSyncAmsDialog
class	Page
class	Tab
class	TabPrint
class	TabPrintModel
class	TabPrintPlate
class	TabPrintObject
class	TabPrintPart
class	TabPrintLayer
class	TabFilament
class	TabPrinter
class	TabSLAMaterial
class	TabSLAPrint
class	TerminalDialog
class	TextLinesModel
class	FilamentSelectPopup
class	AutoMixSelectPopup
struct	TextureFilamentEntry
struct	TextureNewMixedFilament
struct	FilamentMappingRow
class	TexturePreviewCanvas
class	TextureImportDialog
struct	TextureLibraryEntry
class	TextureProjectorFrame
class	ThermalPreconditioningDialog
struct	TickCode
class	TickCodeInfo
class	TroubleshootDialog
class	CenteredMultiLinePanel
class	ModelNode
class	DiffModel
class	DiffViewCtrl
struct	PresetItem
class	UnsavedChangesDialog
class	FullCompareDialog
class	DiffPresetDialog
class	MsgUpdateSlic3r
class	MsgUpdateConfig
class	MsgUpdateForced
class	MsgDataIncompatible
class	MsgNoUpdates
class	ExtensionPanel
class	AmsPanel
class	ExtraAmsPanel
class	MachineInfoPanel
class	UpgradePanel
class	UVToolButton
class	UVEditorCanvas
class	UVEditorPanel
class	WebDialog
class	GuideFrame
class	WebMediaController
class	WebPanel
class	WebRtcMediaController
class	ZUserLogin
class	WebViewPanel
class	SourceViewDialog
class	AMSControl
struct	Caninfo
struct	AMSinfo
class	AMSExtText
class	AMSrefresh
class	AMSextruderImage
class	AMSExtImage
class	SwitcherImage
class	AMSextruder
class	AMSLib
class	AMSRoad
class	AMSRoadUpPart
class	AMSRoadDownPart
class	AMSPreview
class	AMSHumidity
class	AmsItem
class	DevExtruderImage
class	FeedDirectionDialog
class	DialogButtons
struct	RotateOffSet
class	Fan
class	FanOperate
class	FanControlNew
class	FanControlNewSwitchPanel
class	FanControlPopupNew
class	FilamentLoad
class	HyperLink
struct	NozzleOption
class	ManualNozzleCountDialog
class	ExtruderBadge
class	HotEndTable
class	NozzleListTable
class	MultiNozzleStatusTable
class	MultiNozzleSyncDialog
class	ProgressDialog
class	RadioBox
class	SideToolsPanel
class	SideTools
class	WebViewHostDialog
class	CalibInfo
class	CalibUtils
class	RaycastManager
	Cast rays from camera to scene Used for find hit point on model volume under mouse cursor. More...
class	RetinaHelper
class	WxFontUtils
class	Snapshot

Typedefs
using	ConfigOptionsGroupShp = std::shared_ptr<ConfigOptionsGroup>
using	ConfigOptionsGroupWkp = std::weak_ptr<ConfigOptionsGroup>
typedef std::vector< FilamentComboBox * >	FilamentComboBoxList
using	DecomposeMode = ColorDecomposeRecipeMode
using	ColorGradient = std::vector<ColorRGBA>
using	ColorSelection = std::variant<ColorRGBA, ColorGradient>
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	ParamsNodePtrArray = std::vector<std::unique_ptr<ParamsNode>>
using	choice_ctrl = ::ComboBox
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	RBtnEvent = Event<std::pair<Vec2d, bool>>
using	RBtnPlateEvent = Event<std::pair<Vec2d, int>>
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 Event< ObjectVolumeID >	ObjectSettingEvent
typedef DPIAware< wxFrame >	DPIFrame
using	LoadFromOtherInstanceEvent = Event<std::vector<boost::filesystem::path>>
using	StartDownloadOtherInstanceEvent = Event<std::vector<std::string>>
using	InstanceGoToFrontEvent = SimpleEvent
using	ArrangePolygon = arrangement::ArrangePolygon
typedef std::function< void(int status, int code, std::string msg)>	OnUpdateStatusFn
typedef std::function< bool()>	WasCancelledFn
typedef std::function< void(int status, int percent, bool &cancel)>	InstallProgressFn
using	EjectDriveNotificationClickedEvent = SimpleEvent
using	ExportGcodeNotificationClickedEvent = SimpleEvent
using	PresetUpdateAvailableClickedEvent = SimpleEvent
using	PrinterConfigUpdateAvailableClickedEvent = 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	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	GCodeResult = GCodeProcessorResult
typedef std::vector< std::pair< int, PartState > >	PartsInfo
using	ColorEvent = Event<wxColour>
using	RemovableDriveEjectEvent = Event<std::pair<DriveData, bool>>
using	RemovableDrivesChangedEvent = SimpleEvent
using	MaterialHash = std::map<int, Material *>
using	Coord = float
using	FloatPoint = std::array<Coord, 2>
typedef std::function< void(BBLModelTask *subtask)>	OnGetSubTaskFn
using	PageShp = std::shared_ptr<Page>
using	ModelNodePtrArray = std::vector<std::unique_ptr<ModelNode>>

Enumerations
enum class	ActionChange { Added , Removed }
enum class	AppActionKind { Plugin , Command }
enum class	DryCtrState { IDLE , DRY_WHEN_PRINT , UNKNOWN }
enum class	DryCtrDev { N3S , N3F , UNKNOWN }
enum	TrayType { NORMAL , THIRD , EMPTY }
enum	ShowType { LEFT , RIGHT , LEFT_AND_RIGHT , LEFT_AND_RIGHT_DYNAMIC }
enum class	CadLevel : int { Idle = 0 , Tool = 1 , Gesture = 2 , Transient = 3 }
enum class	OfferSel : int {   None = 0 , FacePlanar = 1 , FaceCyl = 2 , FaceOther = 3 ,   EdgeStr = 4 , EdgeCirc = 5 , Vertex = 6 , BodySolid = 7 ,   BodySheet = 8 , Bodies2 = 9 , DatumPlane = 10 , DatumAxis = 11 ,   CoordSys = 12 , Art = 13 , SkLoop = 14 , SkNone = 15 ,   SkLine = 16 , SkArc = 17 , SkPoint = 18 , Sk2Ent = 19 ,   Count = 20 }
enum	DpTok {   TokRibbonBg , TokRibbonHover , TokPanelBg , TokSecText ,   TokCtlText , TokItemText , TokItemDim , TokBorder ,   TokCount }
enum	RowAction {   RowEdit , RowMove , RowVisibility , RowDelete ,   RowZoom }
enum	FILAMENT_TYPE : int {   tPLA = 0 , tABS_ASA , tPETG , tPCTG ,   tTPU , tTPU_AMS , tPA_CF , tPET_CF ,   tCustom }
enum class	CalibrationStyle : int { CALI_STYLE_DEFAULT = 0 , CALI_STYLE_X1 , CALI_STYLE_P1P }
enum	CalibrationFilamentMode { CALI_MODEL_SINGLE = 0 , CALI_MODEL_MULITI }
enum	CalibrationMethod { CALI_METHOD_MANUAL = 0 , CALI_METHOD_AUTO , CALI_METHOD_NEW_AUTO , CALI_METHOD_NONE }
enum class	CaliPageType {   CALI_PAGE_START = 0 , CALI_PAGE_PRESET , CALI_PAGE_CALI , CALI_PAGE_COARSE_SAVE ,   CALI_PAGE_FINE_CALI , CALI_PAGE_FINE_SAVE , CALI_PAGE_PA_SAVE , CALI_PAGE_FLOW_SAVE ,   CALI_PAGE_COMMON_SAVE }
enum class	CaliPageActionType : int {   CALI_ACTION_MANAGE_RESULT = 0 , CALI_ACTION_MANUAL_CALI , CALI_ACTION_AUTO_CALI , CALI_ACTION_START ,   CALI_ACTION_CALI , CALI_ACTION_FLOW_CALI_STAGE_2 , CALI_ACTION_RECALI , CALI_ACTION_PREV ,   CALI_ACTION_NEXT , CALI_ACTION_CALI_NEXT , CALI_ACTION_PA_SAVE , CALI_ACTION_FLOW_SAVE ,   CALI_ACTION_FLOW_COARSE_SAVE , CALI_ACTION_FLOW_FINE_SAVE , CALI_ACTION_COMMON_SAVE , CALI_ACTION_GO_HOME ,   CALI_ACTION_COUNT }
enum	CaliPresetStage { CALI_MANULA_STAGE_NONE = 0 , CALI_MANUAL_STAGE_1 , CALI_MANUAL_STAGE_2 }
enum	FlowRatioCaliSource { FROM_PRESET_PAGE = 0 , FROM_COARSE_PAGE }
enum	CaliPresetPageStatus {   CaliPresetStatusInit = 0 , CaliPresetStatusNormal , CaliPresetStatusNoUserLogin , CaliPresetStatusInvalidPrinter ,   CaliPresetStatusConnectingServer , CaliPresetStatusInUpgrading , CaliPresetStatusInSystemPrinting , CaliPresetStatusInPrinting ,   CaliPresetStatusLanModeNoSdcard , CaliPresetStatusNoSdcard , CaliPresetStatusNeedForceUpgrading , CaliPresetStatusNeedConsistencyUpgrading ,   CaliPresetStatusUnsupportedPrinter , CaliPresetStatusInConnecting , CaliPresetStatusFilamentIncompatible , CaliPresetStatusLanModeSDcardNotAvailable ,   CaliPresetStatusDifferentNozzleDiameters , CaliPresetStatusOptionalPrinterModel }
enum class	GridTextInputType { K , N , FlowRatio , Name }
enum	CaliSaveStyle { CALI_SAVE_P1P_STYLE = 0 , CALI_SAVE_X1_STYLE }
enum	CaliColumnType : int {   Cali_Name = 0 , Cali_Filament , Cali_Nozzle_ID , Cali_Nozzle ,   Cali_K_Value , Cali_Delete , Cali_Edit , Cali_Type_Count }
enum class	DecomposeBaseColor {   None , Cyan , Magenta , Yellow ,   White , Red , Green , Blue }
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	SuccessType { PRINTER = 0 , FILAMENT }
enum class	DailyTipsLayout { Horizontal , Vertical }
enum	PrintFromType { FROM_NORMAL , FROM_SDCARD_VIEW }
enum	DataStatusType { ADJUST , OK , UNMATCHED }
enum	DownloadState {   DownloadPending = 0 , DownloadOngoing , DownloadStopped , DownloadDone ,   DownloadError , DownloadPaused , DownloadStateUnknown }
enum	DownloaderUserAction { DownloadUserCanceled , DownloadUserPaused , DownloadUserContinued , DownloadUserOpenedFolder }
enum class	DragMode { NONE , DRAGGING }
enum class	ParamType { Undef , Scalar , Vector , FilamentVector }
enum	ExportCase {   INITIALIZE_FAIL = 0 , ADD_FILE_FAIL , ADD_BUNDLE_STRUCTURE_FAIL , FINALIZE_FAIL ,   OPEN_ZIP_WRITTEN_FILE , EXPORT_CANCEL , EXPORT_SUCCESS , CASE_COUNT }
enum class	FilamentRenderMode {   Single , Dual , Triple , Quadruple ,   Gradient }
enum class	EMeasureMode : unsigned char { ONLY_MEASURE , ONLY_ASSEMBLY }
enum class	AssemblyMode : unsigned char { FACE_FACE , POINT_POINT }
enum class	MeshBooleanSelectingState { Undef , SelectSource , SelectTool }
enum class	MeshBooleanOperation { Undef , Union , Difference , Intersection }
enum class	PainterGizmoType {   FDM_SUPPORTS , SEAM , MM_SEGMENTATION , FUZZY_SKIN ,   TEXTURE_DISPLACEMENT }
enum class	SLAGizmoEventType : unsigned char {   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 }
enum class	CollapseSide { None , Left , Right }
enum	FileType {   FT_STEP , FT_STL , FT_OBJ , FT_AMF ,   FT_3MF , FT_GCODE_3MF , FT_GCODE , FT_MODEL ,   FT_ZIP , FT_PROJECT , FT_GALLERY , FT_INI ,   FT_SVG , FT_TEX , FT_SL1 , FT_DRC ,   FT_SIZE }
enum	ConfigMenuIDs { ConfigMenuPreferences , ConfigMenuPrinter , ConfigMenuCnt }
enum	OrcaSlicerMenuIDs { OrcaSlicerMenuAbout , OrcaSlicerMenuPreferences }
enum	CameraMenuIDs { wxID_CAMERA_PERSPECTIVE , wxID_CAMERA_ORTHOGONAL , wxID_CAMERA_COUNT }
enum class	ECoordinatesType : unsigned char { World = 0 , Instance , Local }
enum	EditorType { etUndef = 0 , etMinZ = 1 , etMaxZ = 2 , etLayerHeight = 4 }
enum	{ DPI_DEFAULT = 96 }
enum class	HintDataNavigation { Curr , Prev , Next , Random }
enum	SelectedSlider { ssUndef = 0 , ssLower = 1 , ssHigher = 2 }
enum	DrawMode { dmRegular , dmSlaPrint , dmSequentialFffPrint , dmSequentialGCodeView }
enum	LabelType { ltHeightWithLayer , ltHeight , ltEstimatedTime }
enum class	TextureDisplacementPrepareOutcome { Committed , Unchanged , PaintLost , Failed }
enum	PluginInstallStatus {   InstallStatusNormal = 0 , InstallStatusDownloadFailed = 1 , InstallStatusDownloadCompleted = 2 , InstallStatusUnzipFailed = 3 ,   InstallStatusInstallCompleted = 4 }
enum class	ERescaleTarget { Mainframe , SettingsDialog }
enum	QuickSlice {   qsUndef = 0 , qsReslice = 1 , qsSaveAs = 2 , qsExportSVG = 4 ,   qsExportPNG = 8 }
enum class	CalibKind : int {   Temperature , MaxVolumetric , PressureAdvance , FlowRatio ,   Retraction , Cornering , InputShapingFreq , InputShapingDamp ,   VFA }
enum	TestJob { TEST_BING_JOB = 0 , TEST_ORCA_JOB = 1 , TEST_PING_JOB , TEST_JOB_MAX }
enum class	NotificationType {   CustomNotification = 0 , ExportFinished , Mouse3dDisconnected , NewAppAvailable ,   NewAlphaAvailable , NewBetaAvailable , PresetUpdateAvailable , PresetUpdateFinished ,   ValidateError , ValidateWarning , SlicingError , SlicingSeriousWarning ,   SlicingWarning , BBLGeneralError , PlaterError , LeftExtruderUnprintableError ,   RightExtruderUnprintableError , PlaterWarning , ProgressBar , PrintHostUpload ,   SlicingProgress , EmptyColorChangeCode , CustomSupportsAndSeamRemovedAfterRepair , EmptyAutoColorChange ,   SignDetected , QuitSLAManualMode , DesktopIntegrationSuccess , DesktopIntegrationFail ,   UndoDesktopIntegrationSuccess , UndoDesktopIntegrationFail , MmSegmentationExceededExtrudersLimit , DidYouKnowHint ,   UpdatedItemsInfo , ProgressIndicator , SimplifySuggestion , UnknownFont ,   CgalFinished , ExportOngoing , URLDownload , ArrangeOngoing ,   BBLPlateInfo , BBL3MFInfo , BBLObjectInfo , BBLSliceEmptyLayer ,   BBLNeedSupportON , BBLGcodeOverlap , BBLSeqPrintInfo , BBLPluginInstallHint ,   BBLFlushingVolumeZero , BBLMixedFilamentBroken , BBLPluginUpdateAvailable , BBLPreviewOnlyMode ,   BBLPrinterConfigUpdateAvailable , BBLUserPresetExceedLimit , BBLFilamentPrintableError , BBLSliceLimitError ,   BBLSliceMultiExtruderHeightOutside , BBLBedFilamentIncompatible , BBLMixUsePLAAndPETG , BBLNozzleFilamentIncompatible ,   BBLSingleExtruderMixedFilamentRisk , OrcaSharedProfilesAvailable , OrcaCloudAPIError , OrcaSyncConflict ,   OrcaLocalPluginMissingError , OrcaCloudPluginMissingError , OrcaPluginInactiveError , OrcaPluginCapabilityUnavailableError ,   NotificationTypeCount }
enum	ItemType {   itUndef = 0 , itPlate = 1 , itObject = 2 , itVolume = 4 ,   itInstanceRoot = 8 , itInstance = 16 , itSettings = 32 , itLayerRoot = 64 ,   itLayer = 128 , itInfo = 256 }
enum	ColumnNumber {   colName = 0 , colHeight , colPrint , colFilament ,   colSupportPaint , colColorPaint , colSinking , colEditing ,   colCount }
enum	PrintIndicator { piUndef = 0 , piPrintable , piUnprintable }
enum	VaryHeightIndicator { hiUnVariable , hiVariable }
enum class	InfoItemType {   Undef , CustomSupports , MmSegmentation , FuzzySkin ,   CutConnectors }
enum	PartState { psUnCheck , psChecked , psSkipped }
enum	URL_STATE { URL_TCP , URL_TUTK }
enum	SlicedInfoIdx {   siFilament_m , siFilament_mm3 , siFilament_g , siMateril_unit ,   siCost , siEstimatedTime , siWTNumbetOfToolchanges , siCount }
enum class	LoadFilesType {   NoFile , Single3MF , SingleOther , Multiple3MF ,   MultipleOther , Multiple3MFOther }
enum class	LoadType : unsigned char { Unknown , OpenProject , LoadGeometry , LoadConfig }
enum class	ActionButtonType : int { abReslice , abExport , abSendGCode }
enum	ExportingStatus { NOT_EXPORTING , EXPORTING_TO_REMOVABLE , EXPORTING_TO_LOCAL }
enum class	PluginSortKey {   Status , Name , Source , Version ,   None }
enum class	PluginSortOrder { Asc , Desc }
enum class	PluginSource { Mine , Subscribed , Orphaned , Local }
enum class	PluginStatus {   Activated , Error , RuntimeError , Inactive ,   Loading }
enum class	PreferencesTab { General , Control , Graphics , Online }
enum	prePrintInfoLevel { Normal , Warning , Error }
enum	prePrintInfoType { Printer , Filament }
enum	PrintDialogStatus : unsigned int {   PrintStatusErrorBegin , PrintStatusPrinterErrorBegin , PrintStatusInit , PrintStatusNoUserLogin ,   PrintStatusInvalidPrinter , PrintStatusConnectingServer , PrintStatusReadingTimeout , PrintStatusReading ,   PrintStatusConnecting , PrintStatusReconnecting , PrintStatusInUpgrading , PrintStatusFirmwareNotSupportTpuAtLeft ,   PrintStatusModeNotFDM , PrintStatusInSystemPrinting , PrintStatusInPrinting , PrintStatusNozzleMatchInvalid ,   PrintStatusNozzleDataInvalid , PrintStatusNozzleTypeMismatch , PrintStatusNozzleNoMatchedHotends , PrintStatusNozzleRackMaximumInstalled ,   PrintStatusRefreshingMachineList , PrintStatusSending , PrintStatusLanModeNoSdcard , PrintStatusNoSdcard ,   PrintStatusLanModeSDcardNotAvailable , PrintStatusNeedForceUpgrading , PrintStatusNeedConsistencyUpgrading , PrintStatusNotSupportedPrintAll ,   PrintStatusBlankPlate , PrintStatusUnsupportedPrinter , PrintStatusRackNozzleMappingWaiting , PrintStatusRackNozzleMappingError ,   PrintStatusRackReading , PrintStatusFilaSwitcherError , PrintStatusPrinterErrorEnd , PrintStatusFilamentErrorBegin ,   PrintStatusAmsOnSettingup , PrintStatusAmsMappingInvalid , PrintStatusAmsMappingU0Invalid , PrintStatusAmsMappingMixInvalid ,   PrintStatusTPUUnsupportAutoCali , PrintStatusHasFilamentInBlackListError , PrintStatusColorQuantityExceed , PrintStatusFilamentErrorEnd ,   PrintStatusErrorEnd , PrintStatusWarningBegin , PrintStatusPrinterWarningBegin , PrintStatusTimelapseNoSdcard ,   PrintStatusTimelapseWarning , PrintStatusTimelapseStorageLow , PrintStatusMixAmsAndVtSlotWarning , PrintStatusToolHeadCoolingFanWarning ,   PrintStatusRackNozzleMappingWarning , PrintStatusFilaSwitcherSlicingNotMatch , PrintStatusRackNozzleNumUnmeetWarning , PrintStatusHasUnreliableNozzleWarning ,   PrintStatusNozzleDiameterMismatch , PrintStatusOptionalPrinterModel , PrintStatusPrinterWarningEnd , PrintStatusFilamentWarningBegin ,   PrintStatusWarningKvalueNotUsed , PrintStatusHasFilamentInBlackListWarning , PrintStatusFilamentWarningHighChamberTemp , PrintStatusFilamentWarningHighChamberTempCloseDoor ,   PrintStatusFilamentWarningHighChamberTempSoft , PrintStatusFilamentWarningUnknownHighChamberTempSoft , PrintStatusWarningExtFilamentNotMatch , PrintStatusFilamentWarningNozzleHRC ,   PrintStatusFilamentCrossExtruderWarning , PrintStatusTPUUnsupportCaliOn , PrintStatusTPUUnsuggestCali , PrintStatusSmartNozzleBlobNeedAuto ,   PrintStatusFilamentWarningRemainNotEnough , PrintStatusPrintTimeEstimateWarning , PrintStatusFilamentWarningEnd , PrintStatusWarningEnd ,   PrintStatusReadingFinished , PrintStatusSendingCanceled , PrintStatusReadyToGo , PrintStatusAmsMappingSuccess ,   PrintStatusNotOnTheSameLAN , PrintStatusNotSupportedSendToSDCard , PrintStatusPublicInitFailed , PrintStatusPublicUploadFiled }
enum class	PurgeModeDialogType { MultiNozzle , FastMode }
enum	PrintPageMode { PrintPageModePrepare = 0 , PrintPageModeSending , PrintPageModeFinish }
enum class	CloudTaskNozzleId : int { NOZZLE_RIGHT = 0 , NOZZLE_LEFT = 1 }
enum class	FilamentMapNozzleId : int { NOZZLE_LEFT = 1 , NOZZLE_RIGHT = 2 }
enum class	ConfigNozzleIdx : int { NOZZLE_LEFT = 0 , NOZZLE_RIGHT = 1 }
enum	PrinterState {   OFFLINE , IDLE , BUSY , LOCK ,   IN_LAN }
enum	PrinterBindState { NONE , ALLOW_BIND , ALLOW_UNBIND }
enum class	ShortcutContext : uint8_t {   Global , Plater , Preview , ObjectList ,   Painting , Count }
enum class	Shortcut : uint8_t {   NewProject , OpenProject , SaveProject , SaveProjectAs ,   ImportModel , Publish3mf , SlicePlate , ExportSlicedFile ,   PrintPlate , PrintHostQueue , SelectAll , SelectAllPlates ,   Undo , Redo , Cut , Copy ,   Paste , DeleteSelected , DeleteAll , CloneSelected ,   AddInstance , RemoveInstance , TogglePrintable , ToggleAutoDrop ,   Arrange , ArrangePlate , Orient , OrientPlate ,   MoveSelectionLeft , MoveSelectionRight , MoveSelectionUp , MoveSelectionDown ,   RotateSelectionLeft , RotateSelectionRight , GizmoMove , GizmoRotate ,   GizmoScale , GizmoFlatten , GizmoCut , GizmoMeshBoolean ,   GizmoFdmSupports , GizmoSeam , GizmoFuzzySkin , GizmoMmuSegmentation ,   GizmoEmboss , GizmoMeasure , GizmoAssembly , GizmoBrimEars ,   GizmoDisplacement , GoToLayer , LayerSliderUp , LayerSliderDown ,   MovesSliderLeft , MovesSliderRight , MovesSliderStart , MovesSliderEnd ,   PaintToolCircle , PaintToolSphere , PaintToolFill , PaintToolGapFill ,   PaintToolTriangle , PaintToolHeightRange , ViewDefault , ViewTop ,   ViewBottom , ViewFront , ViewRear , ViewLeft ,   ViewRight , ViewPlate , ZoomIn , ZoomOut ,   Mouse3DSettings , ShowLabels , ShowCollisionVolumes , ShowWireframe ,   ToggleGcodeWindow , ToggleOneLayerMode , ToggleBeltRawGcode , Preferences ,   Search , SwitchView , CollapseSidebar , ReloadDevicePage ,   KeyboardShortcuts , Quit , SpeedDial , Count }
enum class	ShortcutSection : uint8_t {   Project , SlicingAndPrinting , Selection , Editing ,   Objects , Placement , Gizmos , Sliders ,   PaintingTools , Camera , Display , Application ,   SpeedDial , Count }
enum	CameraRecordingStatus {   RECORDING_NONE , RECORDING_OFF_NORMAL , RECORDING_OFF_HOVER , RECORDING_ON_NORMAL ,   RECORDING_ON_HOVER }
enum	CameraTimelapseStatus {   TIMELAPSE_NONE , TIMELAPSE_OFF_NORMAL , TIMELAPSE_OFF_HOVER , TIMELAPSE_ON_NORMAL ,   TIMELAPSE_ON_HOVER }
enum	PrintingTaskType { PRINGINT , CALIBRATION , NOT_CLEAR }
enum	ExtruderState { FILLED_LOAD , FILLED_UNLOAD , EMPTY_LOAD , EMPTY_UNLOAD }
enum class	TextureImportState { Idle , Computing , Ready , Error }
enum class	TextureAutoMixMode { CMYW , RYBW }
enum class	TextureFilamentKind { ExistingPhysical , ExistingMixed , NewPhysical , NewMixed }
enum class	TextureSource { Shipped , User , Plugin }
enum	ActionButtons {   TRANSFER = 1 , KEEP = 2 , SAVE = 4 , DONT_SAVE = 8 ,   REMEMBER_CHOISE = 0x10000 }
enum class	Action { Undef , Transfer , Discard , Save }
enum	FIRMWARE_STASUS { UNKOWN , TESTING , BETA , RELEASE }
enum	AMSModel {   EXT_AMS = 0 , GENERIC_AMS = 1 , AMS_LITE = 2 , N3F_AMS = 3 ,   N3S_AMS = 4 }
enum	AMSModelOriginType { GENERIC_EXT , LITE_EXT }
enum	ActionButton { ACTION_BTN_CALI = 0 , ACTION_BTN_LOAD = 1 , ACTION_BTN_UNLOAD = 2 , ACTION_BTN_COUNT = 3 }
enum class	AMSRoadMode : int {   AMS_ROAD_MODE_LEFT , AMS_ROAD_MODE_LEFT_RIGHT , AMS_ROAD_MODE_END , AMS_ROAD_MODE_END_ONLY ,   AMS_ROAD_MODE_NONE , AMS_ROAD_MODE_NONE_ANY_ROAD , AMS_ROAD_MODE_VIRTUAL_TRAY }
enum class	AMSPanelPos : int { SINGLE_PANEL , LEFT_PANEL , RIGHT_PANEL }
enum class	AMSRoadShowMode : int {   AMS_ROAD_MODE_FOUR , AMS_ROAD_MODE_DOUBLE , AMS_ROAD_MODE_SINGLE , AMS_ROAD_MODE_SINGLE_N3S ,   AMS_ROAD_MODE_AMS_LITE , AMS_ROAD_MODE_NONE }
enum class	AMSPassRoadMode : int {   AMS_ROAD_MODE_NONE , AMS_ROAD_MODE_LEFT , AMS_ROAD_MODE_LEFT_RIGHT , AMS_ROAD_MODE_END_TOP ,   AMS_ROAD_MODE_END_RIGHT , AMS_ROAD_MODE_END_BOTTOM }
enum class	AMSAction : int {   AMS_ACTION_NONE , AMS_ACTION_LOAD , AMS_ACTION_UNLOAD , AMS_ACTION_CALI ,   AMS_ACTION_PRINTING , AMS_ACTION_NORMAL , AMS_ACTION_NOAMS }
enum class	AMSPassRoadSTEP : int {   AMS_ROAD_STEP_NONE = 0 , AMS_ROAD_STEP_1 = 1 , AMS_ROAD_STEP_2 = 2 , AMS_ROAD_STEP_3 = 4 ,   AMS_ROAD_STEP_COMBO_LOAD_STEP1 , AMS_ROAD_STEP_COMBO_LOAD_STEP2 , AMS_ROAD_STEP_COMBO_LOAD_STEP3 }
enum class	AMSPassRoadType : int { AMS_ROAD_TYPE_NONE , AMS_ROAD_TYPE_LOAD , AMS_ROAD_TYPE_UNLOAD }
enum class	AMSCanType : int {   AMS_CAN_TYPE_NONE , AMS_CAN_TYPE_BRAND , AMS_CAN_TYPE_THIRDBRAND , AMS_CAN_TYPE_EMPTY ,   AMS_CAN_TYPE_VIRTUAL }
enum	FilamentStep {   STEP_IDLE , STEP_HEAT_NOZZLE , STEP_CUT_FILAMENT , STEP_PULL_CURR_FILAMENT ,   STEP_PUSH_NEW_FILAMENT , STEP_GRAB_NEW_FILAMENT , STEP_PURGE_OLD_FILAMENT , STEP_CONFIRM_EXTRUDED ,   STEP_CHECK_POSITION , STEP_COUNT }
enum	FilamentStepType { STEP_TYPE_LOAD = 0 , STEP_TYPE_UNLOAD = 1 , STEP_TYPE_VT_LOAD = 2 }
enum class	DevExtruderState { FILLED_LOAD , FILLED_UNLOAD , EMPTY_LOAD , EMPTY_UNLOAD }
enum	FanControlType {   PART_FAN = 0 , AUX_FAN , EXHAUST_FAN , FILTER_FAN ,   CHAMBER_FAN , TOP_FAN }
enum class	NewSlicerInstanceType { Slicer , GCodeViewer }

Functions
bool	init_model_from_poly (GLModel &model, const ExPolygon &poly, float z)
std::vector< std::string >	cap_favourites (const std::vector< std::string > &ids, size_t limit)
nlohmann::json	action_json (const AppAction &a)
bool	requires_mode_switch (ConfigOptionMode setting_mode, ConfigOptionMode current_mode)
static std::string	get_humidity_level_img_path (int humidity_percent)
static std::string	get_dry_status_img_path (DevAmsType type, DevAms::DryStatus status, DevAms::DrySubStatus sub_status)
wxString	get_cannot_reason_text (DevAms::CannotDryReason reason)
wxString	organize_cannot_reasons_text (std::vector< DevAms::CannotDryReason > &reasons)
	wxDEFINE_EVENT (EVT_SET_FINISH_MAPPING, wxCommandEvent)
static wxString	s_wrap_mapped_nozzle_str (const wxString &text)
static int	s_get_mapped_nozzle_str_line_count (const wxString &text)
static void	_DrawRemainArea (const MappingItem *item, const TrayData &dd, bool support_remain_dect, wxDC &dc)
	wxDECLARE_EVENT (EVT_SET_FINISH_MAPPING, wxCommandEvent)
static void	_add_containers (const AmsMapingPopup *win, std::list< MappingContainer * > &one_slot_containers, const std::vector< MappingContainer * > &four_slots_containers, wxBoxSizer *target_sizer)
static std::optional< TrayData >	sGetTrayData (DevAmsTray *tray, const std::string &ams_id_str, DevAmsType ams_type)
	wxDEFINE_EVENT (EVT_SELECTED_COLOR, wxCommandEvent)
static std::string	float_to_string_with_precision (float value, int precision=3)
static std::string	colour_to_ams_string (const wxColour &color)
static wxColour	mix_colour (const wxColour &left, const wxColour &right, double ratio)
static std::vector< ColorPickerPopup::ColorItem >	collect_ams_color_items (DevFilaSystem *fila_system)
static std::vector< ColorPickerPopup::ColorItem >	collect_preset_color_items (const std::string &filament_id)
static DevFilaBlacklist::CheckResult	sCheckFilamentInfo (PresetBundle *preset_bundle, MachineObject *obj, int ams_id, int slot_id, const std::string &filament_id, std::string &ams_filament_id, std::string &ams_setting_id)
static void	_collect_filament_info (const wxString &shown_name, const Preset &filament, std::unordered_map< wxString, wxString > &query_filament_vendors, std::unordered_map< wxString, wxString > &query_filament_types)
	wxDECLARE_EVENT (EVT_SELECTED_COLOR, wxCommandEvent)
std::string	aui_pane_layout_entry (const std::string &layout, const std::string &pane_name)
	wxDEFINE_EVENT (EVT_AUXILIARY_IMPORT, wxCommandEvent)
	wxDEFINE_EVENT (EVT_AUXILIARY_UPDATE_COVER, wxCommandEvent)
	wxDEFINE_EVENT (EVT_AUXILIARY_UPDATE_DELETE, wxCommandEvent)
	wxDEFINE_EVENT (EVT_AUXILIARY_UPDATE_RENAME, wxCommandEvent)
	wxDEFINE_EVENT (EVT_AUXILIARY_DONE, wxCommandEvent)
static std::shared_ptr< ModelInfo >	ensure_model_info ()
	WX_DEFINE_ARRAY (AuFiles *, AuFilesHash)
	wxDECLARE_EVENT (EVT_AUXILIARY_IMPORT, wxCommandEvent)
	wxDECLARE_EVENT (EVT_AUXILIARY_UPDATE_COVER, wxCommandEvent)
	wxDECLARE_EVENT (EVT_AUXILIARY_UPDATE_DELETE, wxCommandEvent)
	wxDECLARE_EVENT (EVT_AUXILIARY_UPDATE_RENAME, wxCommandEvent)
	wxDECLARE_EVENT (EVT_AUXILIARY_DONE, wxCommandEvent)
static std::string	get_option_label (BedShape::Parameter param)
bool	ensure_belt_purge_tower (Model &model, PartPlateList &partplate_list, ObjectList *obj_list, std::vector< BeltPurgeSignature > &sigs)
wxString	get_fail_reason (int code)
static wxBitmap	wxImage_to_wxBitmap_with_alpha (wxImage &&image, float scale=1.0f)
static void	select_iso_view (Camera &camera)
static ColorRGBA	body_palette (int body_idx)
constexpr CadLevel	cad_escape_level (const CadInteractionState &s)
uint32_t	offer_bit (OfferSel s)
static wxFlexGridSizer *	two_col_form ()
static ComboBox *	make_combo (wxWindow *parent)
static int	combo_append_index (ComboBox *c, const wxString &label, int index)
static wxString	en_format (double v, int digits=2)
static bool	en_parse (const wxString &text, double &out)
static bool	dp_dark ()
static wxColour	dp_tok (DpTok t)
static wxColour	dp_ribbon_bg ()
static wxColour	dp_ribbon_hover ()
static wxColour	dp_panel_bg ()
static wxColour	dp_sec_text ()
static wxColour	dp_ctl_text ()
static wxColour	dp_item_text ()
static wxColour	dp_item_dim ()
static wxColour	dp_retheme (const wxColour &c, bool to_dark)
static StaticBox *	make_card (wxWindow *parent)
static void	style_sidebar_icon_btn (::Button *b)
::Button *	sidebar_icon_btn (wxWindow *parent, const char *icon, const wxString &tip, int px=20)
static std::string	commit_icon (bool bodies)
static DesignRowList::Action	eye_action (bool shown)
static wxString	origin_toggle_text (bool shown)
static wxString	bed_toggle_text (bool shown)
static wxString	sketch_plane_prompt ()
static wxSpinCtrlDouble *	make_spin (wxWindow *parent, double val, double mn=0.1, double mx=1000.0)
static wxWindow *	spin_frame (wxWindow *spin)
static SketchPlane	plane_from_index (int i)
static int	index_from_plane (const SketchPlane &p)
static bool	is_base_plane (const SketchPlane &p, const Vec3d &modeling_origin)
static SketchPlane	face_plane_inward (const TopoDS_Face &face)
static void	run_off_ui_thread (wxWindow *parent, const wxString &message, const std::function< void()> &work)
static Transform3d	xf_compose (const Vec3d &t, const Vec3d &axis, const Vec3d &pivot, double deg)
static wxString	sketch_step_prompt (DesignSketchTool::Mode m, int step, int picks)
static void	offer_trace (const char *fmt,...)
static wxString	constraint_reject_text (ConstraintReject reason, SketchConstraintType type)
static void	write_plan_value (std::vector< SketchEntityConstraintDef > &defs, double v)
static bool	entity_ref_point (const SketchEntity &e, Vec2d &out)
static void	translate_entity (SketchEntity &e, const Vec2d &d)
static double	point_segment_dist (const Vec2d &p, const Vec2d &a, const Vec2d &b)
static double	entity_pick_dist (const Vec2d &p, const SketchEntity &e)
static bool	point_in_poly (const Vec2d &q, const std::vector< Vec2d > &poly)
static bool	ray_triangle (const Vec3d &ro, const Vec3d &rd, const Vec3d &v0, const Vec3d &v1, const Vec3d &v2, double &t)
static double	ray_segment_dist3 (const Vec3d &ro, const Vec3d &rd, const Vec3d &a, const Vec3d &b)
static double	ray_axis_proj (const Linef3 &ray, const Vec3d &anchor, const Vec3d &dir)
static wxPoint	world_to_screen_px (const Camera &cam, const Vec3d &world)
static Vec2d	ellipse_point (const Vec2d &c, double a, double b, double phi, double t)
static double	ellipse_param_of (const Vec2d &center, double a, double b, double phi, const Vec2d &q)
static void	trace_autoedit (const char *why, size_t n)
static int	sketch_endpoint_roles (const SketchEntity &e, SketchPointRole out[2])
static std::vector< Vec2d >	circle_polygon (const Vec2d &c, double r, int n=48)
static std::vector< Vec2d >	ellipse_polyline (const Vec2d &c, double a, double b, double phi, double t0, double t1, int n=48)
static int	bspline_degree (int n)
static std::vector< double >	bspline_knots (int n, int p)
static Vec2d	bspline_eval (const std::vector< Vec2d > &P, const std::vector< double > &U, int p, double u)
static std::vector< Vec2d >	bspline_polyline (const std::vector< Vec2d > &ctrl, int samples=0)
static double	wrap_2pi (double a)
static bool	circumcircle (const Vec2d &a, const Vec2d &b, const Vec2d &c, Vec2d &center, double &radius)
static SketchEntity	make_arc_through (const Vec2d &center, double radius, const Vec2d &start, const Vec2d &end, const Vec2d &through, bool construction)
static void	ellipse_axes (const Vec2d &center, const Vec2d &major_end, const Vec2d &minor_pt, double &a, double &b, double &phi)
static void	dp_pick_trace (const char *fmt,...)
static bool	dp_pick_trace_on ()
static double	display_edge_tol (const TopoDS_Shape &shape)
static void	render_ribbons (GLModel &model, GLModel::Geometry &&g, const ColorRGBA &colour)
static bool	rib_frame (const Vec2d &p0, const Vec2d &p1, double thickness, Vec2d &d, Vec2d &perp, Vec2d &mid, double &half)
std::vector< PlanePiece >	planes_back_to_front (const std::vector< SketchPlane > &planes, double half, const Vec3d &eye, const Vec3d &forward, bool perspective)
SketchPlane	reference_square (const SketchPlane &plane, int base, double half)
std::array< Vec3d, 4 >	reference_label_box (const SketchPlane &square, double half, const std::string &text)
int	pick_reference_square (const std::vector< SketchPlane > &squares, double half, const Vec3d &from, const Vec3d &dir)
static Vec3d	rv_yaxis (const Vec3d &axis, const Vec3d &ref, bool flip)
static Vec3d	dr_yaxis (const Vec3d &axis, const Vec3d &ref)
static double	pt_linear_len (double spacing, int count)
static std::vector< std::vector< Vec2d > >	dash_polyline (const std::vector< Vec2d > &pts, bool closed, double dash, double gap)
static bool	entity_moved (const SketchEntity &a, const SketchEntity &b, double tol)
static void	entity_endpoints (const SketchEntity &e, std::vector< Vec2d > &out)
ColorRGBA	design_selection_color (float alpha=1.0f)
ColorRGBA	design_idle_face_color ()
double	reference_square_gap (double half)
static const wxArrayString &	font_faces ()
static bool	parse_mm (wxString t, double &out)
void	start_mcp_control_if_enabled ()
std::vector< InputShaperType >	input_shaper_types_for_flavor (GCodeFlavor flavor)
	wxDEFINE_EVENT (EVT_FINISHED_UPDATE_MLIST, wxCommandEvent)
	wxDEFINE_EVENT (EVT_UPDATE_USER_MLIST, wxCommandEvent)
wxString	get_calibration_type_name (CalibMode cali_mode)
	wxDEFINE_EVENT (EVT_DEVICE_CHANGED, wxCommandEvent)
	wxDEFINE_EVENT (EVT_CALIBRATION_JOB_FINISHED, wxCommandEvent)
std::map< int, Preset * >	get_cached_selected_filament (MachineObject *obj)
std::map< int, TrayInfo >	get_cached_selected_filament_for_multi_extruder (MachineObject *obj)
bool	is_pa_params_valid (const Calib_Params &params)
static bool	get_preset_info (const DynamicConfig &config, const BedType plate_type, int &nozzle_temp, int &bed_temp, float &max_volumetric_speed)
static bool	get_flow_ratio (const DynamicConfig &config, float &flow_ratio)
	wxDECLARE_EVENT (EVT_DEVICE_CHANGED, wxCommandEvent)
	wxDECLARE_EVENT (EVT_CALIBRATION_JOB_FINISHED, wxCommandEvent)
	wxDEFINE_EVENT (EVT_CALI_ACTION, wxCommandEvent)
	wxDEFINE_EVENT (EVT_CALI_TRAY_CHANGED, wxCommandEvent)
CalibrationStyle	get_cali_style (MachineObject *obj)
wxString	get_cali_mode_caption_string (CalibMode mode)
wxString	get_calibration_wiki_page (CalibMode cali_mode)
CalibrationFilamentMode	get_cali_filament_mode (MachineObject *obj, CalibMode mode)
CalibMode	get_obj_calibration_mode (const MachineObject *obj)
CalibMode	get_obj_calibration_mode (const MachineObject *obj, int &cali_stage)
CalibMode	get_obj_calibration_mode (const MachineObject *obj, CalibrationMethod &method, int &cali_stage)
	wxDECLARE_EVENT (EVT_CALI_ACTION, wxCommandEvent)
	wxDECLARE_EVENT (EVT_CALI_TRAY_CHANGED, wxCommandEvent)
static void	select_nozzle_volume (ComboBox *combo, NozzleVolumeType volume_type)
static void	fill_nozzle_volume_combo (ComboBox *combo)
static DynamicPrintConfig	empty_tray_config ()
static wxString	get_default_name (wxString filament_name, CalibMode mode)
static wxString	get_tray_name_by_tray_id (int tray_id)
bool	support_nozzle_volume (const MachineObject *obj)
static wxString	nozzle_id_code_to_string (int code)
static wxString	get_preset_name_by_filament_id (std::string filament_id)
	wxIMPLEMENT_CLASS (CameraPopup, PopupWindow)
	wxBEGIN_EVENT_TABLE (CameraPopup, PopupWindow) wxEND_EVENT_TABLE() wxDEFINE_EVENT(EVT_VCAMERA_SWITCH
	wxDEFINE_EVENT (EVT_SDCARD_ABSENT_HINT, wxCommandEvent)
	wxDECLARE_EVENT (EVT_VCAMERA_SWITCH, wxMouseEvent)
	wxDECLARE_EVENT (EVT_SDCARD_ABSENT_HINT, wxCommandEvent)
static const wxColour	COLOR_BRAND ("#009688")
static const wxColour	COLOR_BORDER_NORMAL ("#EEEEEE")
static const wxColour	COLOR_BG_CARD ("#F8F8F8")
static const wxColour	COLOR_LABEL_GREY ("#ACACAC")
static const wxColour	COLOR_TEXT_DARK ("#262E30")
static const wxColour	COLOR_DIVIDER ("#EEEEEE")
static const wxColour	CMYW_CYAN (0, 255, 255)
static const wxColour	CMYW_MAGENTA (255, 0, 255)
static const wxColour	CMYW_YELLOW (255, 255, 0)
static const wxColour	CMYW_WHITE (255, 255, 255)
static const wxColour	RYBW_RED (255, 0, 0)
static const wxColour	RYBW_YELLOW (255, 255, 0)
static const wxColour	RYBW_BLUE (0, 0, 255)
static const wxColour	RYBW_WHITE (255, 255, 255)
static size_t	mode_index (DecomposeMode mode)
static ColorDecomposeRgb	wx_colour_to_recipe_rgb (const wxColour &color)
static wxColour	hex_to_wx_colour (const std::string &hex, const wxColour &fallback)
static bool	same_rgb (const wxColour &lhs, const wxColour &rhs)
static DecomposeBaseColor	standard_base_color_from_key (const std::string &key)
static wxColour	pure_color_for_base (DecomposeBaseColor base)
static DecomposeBaseColor	standard_base_color_for (DecomposeMode mode, const wxColour &color)
static ColorDecomposeResult	to_dialog_result (const ColorDecomposeRecipeResult &recipe, const wxColour &fallback)
static wxPanel *	create_h_divider (wxWindow *parent, int fixed_width=-1)
static wxStaticText *	create_mode_group_label (wxWindow *parent, const wxString &text)
static void	match_parent_bg (wxWindow *w, const wxColour &bg)
static bool	material_type_matches (const std::string &a, const std::string &b)
static wxPanel *	create_color_swatch (wxWindow *parent, const wxColour &color, int size)
std::string	decompose_normalize_color_hex (std::string color)
const char *	decompose_base_color_en (DecomposeBaseColor color)
wxString	decompose_base_color_display (DecomposeBaseColor color)
std::string	decompose_basic_type_from_source (size_t source_config_idx, size_t source_physical_idx, const std::vector< std::string > &physical_types)
std::string	decompose_basic_filament_id (const std::string &basic_type)
void	set_created_standard_component_metadata (size_t config_idx, const DecomposeOfficialComponent &component)
DecomposeOfficialComponent	lookup_decompose_official_component (const std::string &basic_type, DecomposeBaseColor base_color, const wxColour &fallback)
std::string	find_decompose_standard_preset_name (size_t source_config_idx, const std::string &basic_type)
std::string	official_basic_type_from_preset_name (const std::string &preset_name)
std::string	filament_type_for_color_decompose (Preset *preset)
int	find_existing_decompose_component (const DecomposeOfficialComponent &component, const std::vector< std::string > &physical_colors, const std::vector< size_t > &physical_config_indices, size_t source_config_idx)
bool	prepare_decompose_mixed_result (const ColorDecomposeResult &result, size_t source_config_idx, size_t source_physical_idx, const std::vector< std::string > &physical_colors, const std::vector< std::string > &physical_types, const std::vector< size_t > &physical_config_indices, MixedFilamentResult &out_result, std::vector< DecomposeMissingComponent > &missing)
size_t	count_decompose_new_physical_filaments (const ColorDecomposeResult &result, const std::vector< std::string > &physical_colors, const std::vector< std::string > &physical_types, size_t source_physical_idx, const std::vector< size_t > *physical_config_indices)
bool	confirm_create_decompose_missing_components (wxWindow *parent, const std::vector< DecomposeMissingComponent > &missing)
std::optional< ColorSelection >	filament_color_picker_selection (const FilamentColorPickerValue &value)
ColorSelection	filament_color_picker_initial (const FilamentColorPickerValue &value)
FilamentColorPickerValue	filament_color_picker_result (const ColorSelection &selection)
bool	filament_color_picker_changed (const ColorSelection &initial, const std::optional< ColorSelection > &result)
std::string	get_pure_opt_key (const std::string &opt_key)
wxString	get_string_from_enum (const std::string &opt_key, const DynamicPrintConfig &config, bool is_infill, int idx)
wxString	get_full_label (const std::string &opt_key, const DynamicPrintConfig &config)
wxString	get_string_value (const std::string &opt_key, const DynamicPrintConfig &config)
	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)
static std::string	remove_special_key (const std::string &str)
static bool	str_is_all_digit (const std::string &str)
static bool	caseInsensitiveCompare (const std::string &a, const std::string &b)
static float	my_stof (std::string str)
static bool	delete_filament_preset_by_name (std::string delete_preset_name, std::string &selected_preset_name)
static std::string	get_curr_time (const char *format="%Y_%m_%d_%H_%M_%S")
static std::string	get_curr_timestmp ()
static void	get_filament_compatible_printer (Preset *preset, std::vector< std::string > &printers)
static wxBoxSizer *	create_checkbox (wxWindow *parent, Preset *preset, wxString &preset_name, std::vector< std::pair<::CheckBox *, Preset * > > &preset_checkbox)
static wxBoxSizer *	create_checkbox (wxWindow *parent, std::string &compatible_printer, Preset *preset, std::unordered_map<::CheckBox *, std::pair< std::string, Preset * > > &ptinter_compatible_filament_preset)
static wxBoxSizer *	create_checkbox (wxWindow *parent, wxString &preset_name, std::vector< std::pair<::CheckBox *, std::string > > &preset_checkbox)
static wxArrayString	get_exist_vendor_choices (VendorMap &vendors)
static std::string	get_machine_name (const std::string &preset_name)
static std::string	get_filament_name (std::string &preset_name)
static wxBoxSizer *	create_preset_tree (wxWindow *parent, std::pair< std::string, std::vector< std::shared_ptr< Preset > > > printer_and_preset)
static std::string	get_vendor_name (std::string &preset_name)
static wxBoxSizer *	create_select_filament_preset_checkbox (wxWindow *parent, std::string &compatible_printer, std::vector< Preset * > presets, std::unordered_map<::CheckBox *, std::pair< std::string, Preset * > > &machine_filament_preset)
static wxString	get_curr_radio_type (std::vector< std::pair< RadioBox *, wxString > > &radio_btns)
static std::string	calculate_md5 (const std::string &input)
static void	load_filament_id_sources (PresetBundle &temp_preset_bundle)
static std::string	get_filament_id (std::string vendor_typr_serial, const PresetBundle &temp_preset_bundle)
static json	get_config_json (const Preset *preset)
static char *	read_json_file (const std::string &preset_path)
static std::string	get_printer_nozzle_diameter (std::string printer_name)
static void	adjust_dialog_in_screen (DPIDialog *dialog)
bool	has_cjk (const std::string &text)
void	register_mac_deep_link_handler ()
	wxDEFINE_EVENT (wxEVT_REFRESH_DATA, wxCommandEvent)
	wxDECLARE_EVENT (wxEVT_REFRESH_DATA, wxCommandEvent)
static wxBitmap	SetNozzleBmpColor (const wxBitmap &bmp, const std::string &color_str)
static StateColor	s_button_style_gray ()
static void	s_update_title (const std::shared_ptr< DevNozzleRack > rack, wgtDeviceNozzleRackTitle *title_label)
static void	s_set_bg_style (StaticBox *box, ScalableButton *btn, Label *label_row, Label *label_row_status, const wxColour &clr)
static void	s_show_label (Label *label, const wxString &text)
static void	s_show_label (Label *label, const wxString &text, const wxColour &text_color)
	wxDEFINE_EVENT (wxEVT_NOZZLE_JUMP_UPGRADE, wxCommandEvent)
	wxDECLARE_EVENT (wxEVT_NOZZLE_JUMP_UPGRADE, wxCommandEvent)
static wxPanel *	s_create_title (wxWindow *parent, const wxString &text)
static void	s_update_nozzle_info (wgtDeviceNozzleRackNozzleItem *item, std::shared_ptr< DevNozzleRack > rack, const DevNozzle &nozzle_info)
static void	s_enable_item_if_match (wgtDeviceNozzleRackNozzleItem *item, const DevNozzle &nozzle_info, const DevNozzle &selected_nozzle)
volatile int	sGetNozzlePosId (wgtDeviceNozzleRackNozzleItem *item, wgtDeviceNozzleRackNozzleItem *l_item, wgtDeviceNozzleRackNozzleItem *r_item)
std::string	plugin_pane_name (const std::string &plugin_key, const std::string &title)
	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)
std::string	extract_remote_filename (const std::string &str)
	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)
	wxDEFINE_EVENT (wxEVT_DRAG_DROP_COMPLETED, wxCommandEvent)
wxColor	Hex2Color (const std::string &str)
	wxDECLARE_EVENT (wxEVT_DRAG_DROP_COMPLETED, wxCommandEvent)
static ParamType	get_type (const std::string &opt_key, const ConfigOptionDef &opt_def)
static void	make_bold (wxString &str)
static void	highlight (wxString &str)
static std::string	get_machine_name (const std::string &preset_name)
static std::string	get_filament_name (std::string &preset_name)
static std::string	get_vendor_name (std::string &preset_name)
static std::string	get_curr_time (const char *format="%Y_%m_%d_%H_%M_%S")
static mz_bool	initial_zip_archive (mz_zip_archive &zip_archive, const std::string &file_path)
wxString	double_to_string (double const value, const int max_precision)
wxString	get_thumbnail_string (const Vec2d &value)
wxString	get_thumbnails_string (const std::vector< Vec2d > &values)
ThumbnailErrors	validate_thumbnails_string (wxString &str, const wxString &def_ext="PNG")
wxString	get_formatted_tooltip_text (const ConfigOptionDef &opt, const t_config_option_key &id)
void	switch_window_pools ()
void	release_window_pools ()
wxEventFunctor &	wxMakeEventFunctor (const int, wxEventFunctorRef func)
static void	unbind_events (wxEvtHandler *h)
void	free_window (wxWindow *win)
template<class T>
bool	is_defined_input_value (wxWindow *win, const ConfigOptionType &type)
static void	remove_empty_plugin_values (std::vector< std::string > &values)
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.
double	tri_signed_area2 (TriPoint a, TriPoint b, TriPoint c)
bool	tri_contains (TriPoint p, TriPoint v0, TriPoint v1, TriPoint v2)
void	tri_barycentric (TriPoint p, TriPoint v0, TriPoint v1, TriPoint v2, double &w0, double &w1, double &w2)
TriPoint	tri_clamp (TriPoint p, TriPoint v0, TriPoint v1, TriPoint v2)
void	fill_gradient_rect_east (wxDC &dc, const wxRect &rect, const wxColour &from, const wxColour &to)
static std::string	to_hex (const wxColour &c)
wxColour	blend_n_colors (const std::vector< wxColour > &cols, const std::vector< double > &weights)
std::vector< wxColour >	sample_gradient_ramp (const wxColour &first, const wxColour &second, const Slic3r::GradientCurve &curve, int steps)
Slic3r::GradientCurve	mixed_gradient_curve (const Slic3r::DynamicPrintConfig &cfg, size_t slot)
std::vector< wxColour >	mixed_gradient_ramp (const Slic3r::DynamicPrintConfig &cfg, size_t slot, int steps)
void	fill_gradient_ramp_rect (wxDC &dc, const wxRect &rect, const std::vector< wxColour > &ramp)
static BitmapDC	init_bitmap_dc (const wxSize &size)
wxBitmap	create_gradient_ramp_bitmap (const std::vector< wxColour > &ramp, const wxSize &size)
static bool	is_transparent_color (const wxColour &color)
static wxBitmap	create_transparent_bitmap (const wxSize &size)
static wxBitmap	create_single_filament_bitmap (const wxColour &color, const wxSize &size)
static wxBitmap	create_dual_filament_bitmap (const wxColour &color1, const wxColour &color2, const wxSize &size)
static wxBitmap	create_triple_filament_bitmap (const std::vector< wxColour > &colors, const wxSize &size)
static wxBitmap	create_quadruple_filament_bitmap (const std::vector< wxColour > &colors, const wxSize &size)
static wxBitmap	create_gradient_filament_bitmap (const std::vector< wxColour > &colors, const wxSize &size)
wxBitmap	create_filament_bitmap (const std::vector< wxColour > &colors, const wxSize &size, bool force_gradient)
void	recompute_mixed_slot_colors (std::vector< wxColour > &colors, const Slic3r::DynamicPrintConfig &cfg)
wxRect	mixed_gradient_plot_rect (const wxSize &sz)
void	draw_mixed_gradient_plot (wxDC &raw_dc, const wxSize &canvas, const std::vector< MixedGradientCurve > &curves, const std::vector< wxPoint2DDouble > &anchors, const MixedGradientTheme &theme)
void	draw_mixed_ratio_blend_bar (wxDC &dc, const wxRect &rect, const wxColour &first, const wxColour &second, double second_fraction)
void	draw_mixed_ratio_segments (wxDC &dc, const wxRect &rect, const std::vector< wxColour > &colours, const std::vector< double > &shares)
std::array< TriPoint, 3 >	mixed_triangle_vertices (const wxSize &size, double margin_dip)
void	draw_mixed_triangle_picker (wxDC &dc, const wxSize &size, const std::array< wxColour, 3 > &colours, const std::array< double, 3 > &weights, const MixedTriangleTheme &theme)
void	draw_mixed_triangle_labels (wxDC &dc, const wxSize &size, const std::array< double, 3 > &weights, const MixedTriangleTheme &theme)
static bool	should_pop_up ()
static FilamentMapMode	get_prefered_map_mode ()
static void	set_prefered_map_mode (FilamentMapMode mode)
bool	play_dual_extruder_slice_video ()
bool	play_dual_extruder_print_tpu_video ()
bool	open_filament_group_wiki ()
static bool	get_pop_up_remind_flag ()
static void	set_pop_up_remind_flag (bool remind)
static FilamentMapMode	get_applied_map_mode (DynamicConfig &proj_config, const Plater *plater_ref, const PartPlate *partplate_ref, const bool sync_plate)
static std::vector< int >	get_applied_map (DynamicConfig &proj_config, const Plater *plater_ref, const PartPlate *partplate_ref, const bool sync_plate)
static std::vector< int >	get_applied_volume_map (DynamicConfig &proj_config, const Plater *plater_ref, const PartPlate *partplate_ref, const bool sync_plate)
std::string &	get_left_extruder_unprintable_text ()
std::string &	get_right_extruder_unprintable_text ()
bool	try_pop_up_before_slice (bool is_slice_all, Plater *plater_ref, PartPlate *partplate_ref, bool force_pop_up=false)
	Try to pop up the filament map dialog before slicing.
	wxDEFINE_EVENT (wxEVT_INVALID_MANUAL_MAP, wxCommandEvent)
static bool	printer_has_multi_nozzle_extruder ()
	wxDECLARE_EVENT (wxEVT_INVALID_MANUAL_MAP, wxCommandEvent)
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_swatch (ImDrawList *draw_list, const ImVec2 &min, const ImVec2 &max, const ColorRGBA &color)
static std::string	get_view_type_string (libvgcode::EViewType view_type)
static const std::vector< std::pair< std::string, libvgcode::EViewType > > &	view_type_config_map ()
static int	find_close_layer_idx (const std::vector< double > &zs, double &z, double eps)
static std::string	format_compact_weight (double value_in_grams, bool imperial_units)
static std::string	to_string (libvgcode::EMoveType type)
static std::string	to_string (libvgcode::EGCodeExtrusionRole role)
static size_t	utf8_offset (const std::string &str, size_t count)
static Transform3d	compute_belt_back_transform (const PrintConfig &cfg)
void	delete_negative_sign (Vec3d &value)
static ModelVolume *	get_model_volume (const Selection &selection, Model &model)
	wxDECLARE_EVENT (wxEVT_THREAD_DONE, wxCommandEvent)
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)
static void	check_objects_after_cut (const ModelObjectPtrs &objects)
void	synchronize_model_after_cut (Model &model, const CutObjectBase &cut_id)
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< 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)
Vec3d	GetIntersectionOfRayAndPlane (Vec3d ray_position, Vec3d ray_dir, Vec3d plane_position, Vec3d plane_normal)
static int	constraint_id (int grabber_id)
static void	call_after_if_active (std::function< void()> fn, GUI_App *app=&wxGetApp())
static ModelVolume *	get_model_volume (const Selection &selection, Model &model)
std::string	get_name_from_gizmo_etype (GLGizmosManager::EType type)
static void	append_paint_patch (GLModel::Geometry &out, const indexed_triangle_set &patch, const std::vector< Vec3f > *displaced)
static double	tip_now ()
static void	pan_camera (Camera &camera, const Vec2d &screen_delta, const Vec3d &anchor)
std::string &	get_object_limited_text ()
std::string &	get_object_clashed_text ()
std::string &	get_nozzle_filament_incompatible_text ()
std::string &	get_filament_mixture_warning_text ()
std::string &	get_single_extruder_mixed_filament_warning_text ()
static std::string	format_number (float value)
static GCodeProcessorResult::ObjectMass::Sum	mass_sum (const MassProperties &solid)
static double	marker_scale (const GLCanvas3D &canvas)
	wxDEFINE_EVENT (EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLCANVAS_OBJECT_SELECT, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLCANVAS_PLATE_NAME_CHANGE, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLCANVAS_PLATE_SELECT, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLCANVAS_RIGHT_CLICK, RBtnEvent)
	wxDEFINE_EVENT (EVT_GLCANVAS_PLATE_RIGHT_CLICK, RBtnPlateEvent)
	wxDEFINE_EVENT (EVT_GLCANVAS_REMOVE_OBJECT, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLCANVAS_ARRANGE, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLCANVAS_ARRANGE_PARTPLATE, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLCANVAS_ORIENT, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLCANVAS_ORIENT_PARTPLATE, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLCANVAS_SELECT_CURR_PLATE_ALL, 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_INSTANCE_SCALED, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLCANVAS_FORCE_UPDATE, SimpleEvent)
	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_UNDO, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLCANVAS_REDO, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLCANVAS_SWITCH_TO_OBJECT, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLCANVAS_SWITCH_TO_GLOBAL, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLCANVAS_COLLAPSE_SIDEBAR, SimpleEvent)
	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)
	wxDEFINE_EVENT (EVT_GLCANVAS_UPDATE, SimpleEvent)
	wxDEFINE_EVENT (EVT_CUSTOMEVT_TICKSCHANGED, wxCommandEvent)
	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_PRINTABLE, SimpleEvent)
static bool	construct_error_string (ObjectFilamentResults &object_result, std::string &error_string)
static std::pair< bool, bool >	construct_extruder_unprintable_error (ObjectFilamentResults &object_result, std::string &left_extruder_unprintable_text, std::string &right_extruder_unprintable_text)
static float	canvas_corner_height ()
static bool	key_repeats (int key)
static void	key_released (int key)
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)
static void	push_plate_toolbar_scrollbar_style (bool is_dark, float scrollbar_size)
static ImVec4	plate_toolbar_hover_color (bool is_dark)
static bool	plate_toolbar_keeps_scrollbar (bool shown, float scrollbar_size)
const ModelVolume *	get_model_volume (const GLVolume &v, const Model &model)
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_PLATE_NAME_CHANGE, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLCANVAS_PLATE_SELECT, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLCANVAS_RIGHT_CLICK, RBtnEvent)
	wxDECLARE_EVENT (EVT_GLCANVAS_PLATE_RIGHT_CLICK, RBtnPlateEvent)
	wxDECLARE_EVENT (EVT_GLCANVAS_REMOVE_OBJECT, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLCANVAS_ARRANGE, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLCANVAS_ARRANGE_PARTPLATE, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLCANVAS_ORIENT, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLCANVAS_ORIENT_PARTPLATE, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLCANVAS_SELECT_CURR_PLATE_ALL, 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_INSTANCE_ROTATED, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLCANVAS_INSTANCE_SCALED, SimpleEvent)
	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_UNDO, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLCANVAS_REDO, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLCANVAS_SWITCH_TO_OBJECT, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLCANVAS_SWITCH_TO_GLOBAL, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLCANVAS_COLLAPSE_SIDEBAR, SimpleEvent)
	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)
	wxDECLARE_EVENT (EVT_GLCANVAS_UPDATE, SimpleEvent)
	wxDECLARE_EVENT (EVT_CUSTOMEVT_TICKSCHANGED, wxCommandEvent)
	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_PRINTABLE, SimpleEvent)
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)
GLModel::Geometry	init_plane_data (const indexed_triangle_set &its, const std::vector< int > &triangle_indices, float normal_offset)
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	to_squared_power_of_two (const std::string &filename, int max_size_px, int &w, int &h)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_OPEN_PROJECT, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_SLICE_ALL, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_SLICE_PLATE, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_PRINT_ALL, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_PRINT_PLATE, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_EXPORT_GCODE, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_SEND_GCODE, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_UPLOAD_GCODE, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_EXPORT_SLICED_FILE, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_EXPORT_ALL_SLICED_FILE, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_PRINT_SELECT, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_SEND_TO_PRINTER, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_SEND_TO_PRINTER_ALL, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_PRINT_MULTI_MACHINE, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_ADD, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_DELETE, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_DELETE_ALL, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_ADD_PLATE, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_DEL_PLATE, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_ORIENT, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_ARRANGE, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_CUT, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_COPY, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_PASTE, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_LAYERSEDITING, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_CLONE, 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_FILLCOLOR, IntEvent)
	wxDEFINE_EVENT (EVT_GLTOOLBAR_SELECT_SLICED_PLATE, wxCommandEvent)
	wxDEFINE_EVENT (EVT_GLVIEWTOOLBAR_3D, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLVIEWTOOLBAR_PREVIEW, SimpleEvent)
	wxDEFINE_EVENT (EVT_GLVIEWTOOLBAR_ASSEMBLE, SimpleEvent)
bool	setup_collapse_toolbar (GLToolbar &toolbar, std::function< void()> toggle)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_OPEN_PROJECT, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_SLICE_ALL, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_SLICE_PLATE, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_PRINT_ALL, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_PRINT_PLATE, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_EXPORT_GCODE, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_SEND_GCODE, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_UPLOAD_GCODE, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_EXPORT_SLICED_FILE, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_EXPORT_ALL_SLICED_FILE, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_PRINT_SELECT, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_SEND_TO_PRINTER, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_SEND_TO_PRINTER_ALL, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_PRINT_MULTI_MACHINE, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_ADD, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_DELETE, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_DELETE_ALL, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_ADD_PLATE, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_DEL_PLATE, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_ORIENT, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_ARRANGE, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_CUT, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_COPY, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_PASTE, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_LAYERSEDITING, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_CLONE, 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_FILLCOLOR, IntEvent)
	wxDECLARE_EVENT (EVT_GLTOOLBAR_SELECT_SLICED_PLATE, wxCommandEvent)
	wxDECLARE_EVENT (EVT_GLVIEWTOOLBAR_3D, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLVIEWTOOLBAR_PREVIEW, SimpleEvent)
	wxDECLARE_EVENT (EVT_GLVIEWTOOLBAR_ASSEMBLE, SimpleEvent)
	wxDEFINE_EVENT (wxEVT_GRADIENT_CURVE_CHANGED, wxCommandEvent)
	wxDECLARE_EVENT (wxEVT_GRADIENT_CURVE_CHANGED, wxCommandEvent)
void	disable_screensaver ()
void	enable_screensaver ()
bool	debugged ()
void	break_to_debugger ()
const std::string &	shortkey_shift_prefix ()
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 has_code_excerpts)
void	show_error (wxWindow *parent, const char *message, bool has_code_excerpts)
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)
wxString	file_url_from_path (const boost::filesystem::path &path)
void	about ()
void	desktop_open_datadir_folder ()
void	desktop_open_any_folder (const std::string &path)
bool	desktop_open_project_attachment (wxWindow *parent, 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 has_code_excerpts=false)
void	show_info (wxWindow *parent, const std::string &message, const std::string &title=std::string())
static std::shared_ptr< OrcaCloudServiceAgent >	get_orca_cloud_agent (NetworkAgent *agent)
static wxString	cloud_page_url (NetworkAgent *agent, const std::string &path)
void	start_ping_test ()
wxString	file_wildcards (FileType file_type, const std::string &custom_extension)
static std::string	libslic3r_translate_callback (const char *s)
static void	generic_exception_handle ()
	wxDEFINE_EVENT (EVT_ENTER_FORCE_UPGRADE, wxCommandEvent)
	wxDEFINE_EVENT (EVT_SHOW_NO_NEW_VERSION, wxCommandEvent)
	wxDEFINE_EVENT (EVT_SHOW_DIALOG, wxCommandEvent)
	wxDEFINE_EVENT (EVT_CONNECT_LAN_MODE_PRINT, wxCommandEvent)
	wxDEFINE_EVENT (EVT_UPDATE_PRESET_BUNDLE, wxCommandEvent)
	wxDEFINE_EVENT (EVT_UPDATE_BUNDLE_COMPLETE, wxCommandEvent)
static std::string	decode (std::string const &extra, std::string const &path={})
static boost::optional< Semver >	parse_semver_from_ini (std::string path)
std::string	get_system_info ()
static void	update_dark_children_ui (wxWindow *window, bool just_buttons_update=false)
void	fatal_error (wxWindow *parent)
Semver	get_version (const std::string &str, const std::regex &regexp)
bool	is_soluble_filament (int extruder_id)
bool	has_filaments (const std::vector< std::string > &model_filaments)
bool	is_support_filament (int extruder_id, bool strict_check)
Vec3d	build_plate_tilt_up_direction ()
static wxString	dots ("...", wxConvUTF8)
	wxDECLARE_EVENT (EVT_CONNECT_LAN_MODE_PRINT, wxCommandEvent)
	wxDECLARE_EVENT (EVT_UPDATE_PRESET_BUNDLE, wxCommandEvent)
	wxDECLARE_EVENT (EVT_UPDATE_BUNDLE_COMPLETE, wxCommandEvent)
static PrinterTechnology	printer_technology ()
static int	filaments_count ()
static bool	is_improper_category (const std::string &category, const int filaments_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 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)
static void	add_volume_with_gizmo (GLGizmosManager::EType gizmo_type, ModelVolumeType type)
static void	append_menu_itemm_add_ (const wxString &name, GLGizmosManager::EType gizmo_type, wxMenu *menu, ModelVolumeType type, bool is_submenu_item)
int	GUI_Run (GUI_InitParams &params)
	wxDEFINE_EVENT (EVT_OBJ_LIST_OBJECT_SELECT, SimpleEvent)
	wxDEFINE_EVENT (EVT_PARTPLATE_LIST_PLATE_SELECT, IntEvent)
static PrinterTechnology	printer_technology ()
static const Selection &	scene_selection ()
static DynamicPrintConfig &	printer_config ()
static int	filaments_count ()
static void	take_snapshot (const std::string &snapshot_name)
static std::string	get_warning_icon_name (const TriangleMeshStats &stats)
static TriangleMesh	create_mesh (const std::string &type_name, const BoundingBoxf3 &bb)
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)
static bool	precise_seam_group_changed (ModelVolumeType old_type, ModelVolumeType new_type)
static void	move_volume_to_end (ModelObject *obj, ModelVolume *volume)
	wxDECLARE_EVENT (EVT_OBJ_LIST_OBJECT_SELECT, SimpleEvent)
	wxDECLARE_EVENT (EVT_PARTPLATE_LIST_PLATE_SELECT, IntEvent)
	wxBEGIN_EVENT_TABLE (ObjectGrid, wxGrid) wxEND_EVENT_TABLE() bool ObjectGrid
	wxIMPLEMENT_CLASS (ObjectTablePanel, wxPanel)
	wxBEGIN_EVENT_TABLE (ObjectTablePanel, wxPanel) wxEND_EVENT_TABLE() ObjectTablePanel
	wxDEFINE_EVENT (EVT_LOCK_DISABLE, wxCommandEvent)
	wxDEFINE_EVENT (EVT_LOCK_ENABLE, wxCommandEvent)
	wxDECLARE_EVENT (EVT_LOCK_DISABLE, wxCommandEvent)
	wxDECLARE_EVENT (EVT_LOCK_ENABLE, wxCommandEvent)
static int	find_close_layer_idx (const std::vector< double > &zs, double &z, double eps)
wxString	format_nozzle_diameter (float diameter)
CopyFileResult	copy_file_gui (const std::string &from, const std::string &to, std::string &error_message, const bool with_check)
wxTopLevelWindow *	find_toplevel_parent (wxWindow *window)
void	on_window_geometry (wxTopLevelWindow *tlw, std::function< void()> callback)
bool	is_running_in_msix ()
void	open_ms_store_product_page ()
int	get_dpi_for_window (const wxWindow *window)
wxFont	get_default_font_for_dpi (const wxWindow *window, int dpi)
bool	check_dark_mode ()
void	update_dark_config ()
std::ostream &	operator<< (std::ostream &os, const WindowMetrics &metrics)
bool	load_image (const std::string &filename, wxImage &image)
bool	generate_image (const std::string &filename, wxImage &image, wxSize img_size, int method)
void	fit_in_display (wxTopLevelWindow &window, wxSize desired_size)
	Make sure the given window fits inside current display.
int	hex_to_int (const char c)
static ColorRGBA	decode_color_to_float_array (const std::string color)
wxFont	get_default_font (const wxWindow *window)
int	hex_digit_to_int (const char c)
void	dataview_remove_insets (wxDataViewCtrl *dv)
void	staticbox_remove_margin (wxStaticBox *sb)
void	set_window_corner_radius (wxWindow *win, int radius)
bool	is_debugger_present ()
wxColour	convert_to_wxColour (const RGBA &color)
RGBA	convert_to_rgba (const wxColour &color)
float	calc_color_distance (wxColour c1, wxColour c2)
float	calc_color_distance (RGBA c1, RGBA c2)
static int	get_utf8_seq_length (const char *seq, size_t size)
static int	get_utf8_seq_length (const std::string &text, size_t pos)
int	get_hms_info_version (std::string &version)
static void	_copy_dir (const fs::path &from_dir, const fs::path &to_dir)
std::string	get_hms_wiki_url (std::string error_code)
std::string	get_error_message (int error_code)
	wxDEFINE_EVENT (EVT_ALREADY_READ_HMS, wxCommandEvent)
	wxDECLARE_EVENT (EVT_ALREADY_READ_HMS, wxCommandEvent)
std::string	url_get_param (const std::string &url, const std::string &key)
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 wxPanel *	framed_input (wxWindow *parent)
static wxStaticText *	page_label (wxStaticText *lbl)
bool	get_data_from_svg (const std::string &filename, unsigned int max_size_px, ThumbnailData &thumbnail_data)
bool	slider_behavior (ImGuiID id, const ImRect &region, const ImS32 v_min, const ImS32 v_max, ImS32 *out_value, ImRect *out_handle, ImGuiSliderFlags flags, const int fixed_value, const ImVec4 &fixed_rect)
bool	button_with_pos (ImTextureID user_texture_id, const ImVec2 &size, const ImVec2 &pos, const ImVec2 &uv0, const ImVec2 &uv1, int frame_padding, const ImVec4 &bg_col, const ImVec4 &tint_col, const ImVec2 &margin)
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), bool *out_hovered=nullptr)
bool	begin_menu (const char *label, bool enabled)
void	end_menu ()
bool	menu_item_with_icon (const char *label, const char *shortcut, ImVec2 icon_size, ImU32 icon_color, bool selected, bool enabled, bool *hovered)
static void	scroll_y (int hover_id)
static void	process_key_down (ImGuiKey imgui_key, std::function< void()> f)
static bool	drawn_last_frame (const ImGuiWindow *popup)
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)
double	min_delta_area ()
double	miscalculation ()
bool	equivalent_areas (const double &bottom_area, const double &top_area)
bool	check_color_change (PrintObject *object, size_t frst_layer_id, size_t layers_cnt, bool check_overhangs, std::function< bool(Layer *)> break_condition)
static std::string	gcode (Type type)
static std::string	short_and_splitted_time (const std::string &time)
constexpr double	epsilon ()
	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)
void	set_arrange_polygon_bed_exclusion_extruders (ArrangePolygon &polygon, const ModelObject &object, const PartPlate &plate, const DynamicPrintConfig &config)
static void	set_arrange_polygon_bed_exclusion_extruders_for_all_plates (ArrangePolygon &polygon, const ModelObject &object, PartPlateList &plate_list, const DynamicPrintConfig &config)
static bool	is_belt_purge_prism (const ModelObject *mo)
static WipeTower	get_wipe_tower (const Plater &plater, int plate_idx)
arrangement::ArrangePolygon	get_wipetower_arrange_poly (WipeTower *tower)
arrangement::ArrangePolygon	estimate_wipe_tower_info (int plate_index, std::set< int > &extruder_ids)
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_x (const Plater *plater)
double	bed_stride_y (const Plater *plater)
arrangement::ArrangeParams	init_arrange_params (Plater *p)
	wxDEFINE_EVENT (EVT_BIND_UPDATE_MESSAGE, wxCommandEvent)
	wxDEFINE_EVENT (EVT_BIND_MACHINE_SUCCESS, wxCommandEvent)
	wxDEFINE_EVENT (EVT_BIND_MACHINE_FAIL, wxCommandEvent)
	wxDECLARE_EVENT (EVT_BIND_UPDATE_MESSAGE, wxCommandEvent)
	wxDECLARE_EVENT (EVT_BIND_MACHINE_SUCCESS, wxCommandEvent)
	wxDECLARE_EVENT (EVT_BIND_MACHINE_FAIL, wxCommandEvent)
	wxDEFINE_EVENT (EVT_OAUTH_COMPLETE_MESSAGE, wxCommandEvent)
	wxDECLARE_EVENT (EVT_OAUTH_COMPLETE_MESSAGE, wxCommandEvent)
static void	setMinimalSupportAreaPrams (Slic3r::orientation::OrientParams &out)
	parameters to minimize support area
std::string	get_transform_string (int bytes)
TextureDisplacementBakeVolume	texture_displacement_bake_volume (const ModelVolume &volume, const std::vector< TextureDisplacementLayer > &layers, const TextureDisplacementOptions &options, const Vec3d &texture_anchor, float resting_drop)
void	queue_texture_displacement_bake (std::vector< TextureDisplacementBakeVolume > volumes, const TextureColorSettings &color, std::function< void()> on_finished, bool take_snapshot)
void	queue_texture_displacement_debug (const ModelVolume &volume, const TextureColorSettings &color, const TextureDisplacementPrepareParams &prepare_params, const Transform3d &prepare_texture_frame, float resting_drop, bool run_prepare, bool check_topology, std::function< void(std::vector< BakeStageSnapshot >)> on_finished)
void	queue_texture_displacement_prepare (TextureDisplacementPrepareInput &&input, std::function< void(TextureDisplacementPrepareOutcome)> on_finished)
	wxDEFINE_EVENT (EVT_UPGRADE_UPDATE_MESSAGE, wxCommandEvent)
	wxDEFINE_EVENT (EVT_UPGRADE_NETWORK_SUCCESS, wxCommandEvent)
	wxDEFINE_EVENT (EVT_DOWNLOAD_NETWORK_FAILED, wxCommandEvent)
	wxDEFINE_EVENT (EVT_INSTALL_NETWORK_FAILED, wxCommandEvent)
	wxDECLARE_EVENT (EVT_UPGRADE_UPDATE_MESSAGE, wxCommandEvent)
	wxDECLARE_EVENT (EVT_UPGRADE_NETWORK_SUCCESS, wxCommandEvent)
	wxDECLARE_EVENT (EVT_DOWNLOAD_NETWORK_FAILED, wxCommandEvent)
	wxDECLARE_EVENT (EVT_INSTALL_NETWORK_FAILED, wxCommandEvent)
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::shared_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)
void	apply_dark_ui_to_lazy_panel (wxWindow *panel)
void	mac_ime_set_active (void *ns_view, bool active)
void	mac_ime_set_caret (void *ns_view, int x, int y, int height)
bool	mac_ime_owns_key (void *ns_view)
	wxDEFINE_EVENT (EVT_SELECT_TAB, wxCommandEvent)
	wxDEFINE_EVENT (EVT_HTTP_ERROR, wxCommandEvent)
	wxDEFINE_EVENT (EVT_USER_LOGIN, wxCommandEvent)
	wxDEFINE_EVENT (EVT_USER_LOGIN_HANDLE, wxCommandEvent)
	wxDEFINE_EVENT (EVT_CHECK_PRIVACY_VER, wxCommandEvent)
	wxDEFINE_EVENT (EVT_CHECK_PRIVACY_SHOW, wxCommandEvent)
	wxDEFINE_EVENT (EVT_SHOW_IP_DIALOG, wxCommandEvent)
	wxDEFINE_EVENT (EVT_UPDATE_MACHINE_LIST, wxCommandEvent)
	wxDEFINE_EVENT (EVT_UPDATE_PRESET_CB, SimpleEvent)
	wxDEFINE_EVENT (EVT_BACKUP_POST, wxCommandEvent)
	wxDEFINE_EVENT (EVT_LOAD_URL, wxCommandEvent)
	wxDEFINE_EVENT (EVT_LOAD_PRINTER_URL, LoadPrinterViewEvent)
static wxIcon	main_frame_icon (GUI_App::EAppMode app_mode)
	wxDEFINE_EVENT (EVT_SYNC_CLOUD_PRESET, SimpleEvent)
static void	add_common_publish_menu_items (wxMenu *publish_menu, MainFrame *mainFrame)
	wxDECLARE_EVENT (EVT_HTTP_ERROR, wxCommandEvent)
	wxDECLARE_EVENT (EVT_USER_LOGIN, wxCommandEvent)
	wxDECLARE_EVENT (EVT_USER_LOGIN_HANDLE, wxCommandEvent)
	wxDECLARE_EVENT (EVT_CHECK_PRIVACY_VER, wxCommandEvent)
	wxDECLARE_EVENT (EVT_CHECK_PRIVACY_SHOW, wxCommandEvent)
	wxDECLARE_EVENT (EVT_SHOW_IP_DIALOG, wxCommandEvent)
	wxDECLARE_EVENT (EVT_UPDATE_MACHINE_LIST, wxCommandEvent)
	wxDECLARE_EVENT (EVT_UPDATE_PRESET_CB, SimpleEvent)
static std::string	url_encode (const std::string &value)
wxString	hide_passwd (wxString url, std::vector< wxString > const &passwords)
void	refresh_agora_url (char const *device, char const *dev_ver, char const *channel, void *context, void(*callback)(void *context, char const *url))
wxString	hide_id_middle_string (wxString const &str, size_t offset=0, size_t length=-1)
static const wxColour	COLOR_LABEL_MUTED ("#6B6A6A")
static wxColour	blend_colors (const wxColour &a, const wxColour &b, double ratio_a)
static wxBitmap	make_alpha_bitmap (int w, int h, const std::function< void(wxDC &dc)> &draw_fn)
static double	convert_input (int coord_byte_low, int coord_byte_high, double deadzone)
static bool	is_caret_line (const std::string &line)
static std::vector< std::pair< std::string, bool > >	classify_code_lines (const std::string &msg)
static std::string	format_parser_error_html (const std::string &msg)
static wxSize	measure_mixed_text (wxWindow *parent, const std::string &msg, const wxFont &prose_font, const wxFont &code_font)
static void	add_msg_content (wxWindow *parent, wxBoxSizer *content_sizer, wxString msg, bool has_code_excerpts=false, bool is_marked_msg=false, const wxString &link_text="", std::function< void(const wxString &)> link_callback=nullptr)
wxString	get_wraped_wxString (const wxString &in, size_t line_len)
	WX_DECLARE_HASH_MAP (wxString, MsgButton *, wxStringHash, wxStringEqual, MsgButtonsHash)
	wxDEFINE_EVENT (EVT_MULTI_CLOUD_TASK_SELECTED, wxCommandEvent)
	wxDEFINE_EVENT (EVT_MULTI_LOCAL_TASK_SELECTED, wxCommandEvent)
	wxDEFINE_EVENT (EVT_MULTI_DEVICE_SELECTED, wxCommandEvent)
	wxDEFINE_EVENT (EVT_MULTI_DEVICE_SELECTED_FINHSH, wxCommandEvent)
	wxDEFINE_EVENT (EVT_MULTI_DEVICE_VIEW, wxCommandEvent)
	wxDEFINE_EVENT (EVT_MULTI_REFRESH, wxCommandEvent)
std::vector< DeviceItem * >	selected_machines (const std::vector< DeviceItem * > &dev_item_list, std::string search_text)
	wxDECLARE_EVENT (EVT_MULTI_DEVICE_SELECTED, wxCommandEvent)
	wxDECLARE_EVENT (EVT_MULTI_DEVICE_SELECTED_FINHSH, wxCommandEvent)
	wxDECLARE_EVENT (EVT_MULTI_DEVICE_VIEW, wxCommandEvent)
	wxDECLARE_EVENT (EVT_MULTI_CLOUD_TASK_SELECTED, wxCommandEvent)
	wxDECLARE_EVENT (EVT_MULTI_LOCAL_TASK_SELECTED, wxCommandEvent)
	wxDECLARE_EVENT (EVT_MULTI_REFRESH, wxCommandEvent)
wxString	network_version_label (const NetworkLibraryVersionInfo &ver)
	wxDECLARE_EVENT (EVT_UPDATE_RESULT, wxCommandEvent)
	wxDEFINE_EVENT (EVT_UPDATE_RESULT, wxCommandEvent)
	wxDEFINE_EVENT (EVT_EJECT_DRIVE_NOTIFICAION_CLICKED, EjectDriveNotificationClickedEvent)
	wxDEFINE_EVENT (EVT_EXPORT_GCODE_NOTIFICAION_CLICKED, ExportGcodeNotificationClickedEvent)
	wxDEFINE_EVENT (EVT_PRESET_UPDATE_AVAILABLE_CLICKED, PresetUpdateAvailableClickedEvent)
	wxDEFINE_EVENT (EVT_PRINTER_CONFIG_UPDATE_AVAILABLE_CLICKED, PrinterConfigUpdateAvailableClickedEvent)
	wxDECLARE_EVENT (EVT_EJECT_DRIVE_NOTIFICAION_CLICKED, EjectDriveNotificationClickedEvent)
	wxDECLARE_EVENT (EVT_EXPORT_GCODE_NOTIFICAION_CLICKED, ExportGcodeNotificationClickedEvent)
	wxDECLARE_EVENT (EVT_PRESET_UPDATE_AVAILABLE_CLICKED, PresetUpdateAvailableClickedEvent)
	wxDECLARE_EVENT (EVT_PRINTER_CONFIG_UPDATE_AVAILABLE_CLICKED, PrinterConfigUpdateAvailableClickedEvent)
	wxDEFINE_EVENT (wxCUSTOMEVT_LAST_VOLUME_IS_DELETED, wxCommandEvent)
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 wxBitmap &bmp)
static void	draw_title (wxDC &dc, wxPoint pos, const wxString &text, const wxColour *color, int width)
std::string	gl_get_string_safe (GLenum param, const std::string &default_value)
static bool	version_greater_or_equal_to (const std::string &version, unsigned int major, unsigned int minor)
std::string	option_id_in_map (const t_opt_map &options, const t_config_option_key &opt_key, int &opt_index)
	wxDECLARE_EVENT (EVT_MODIFY_FILAMENT, SimpleEvent)
void	get_text_extent (const wxString &msg, wxCoord &w, wxCoord &h, wxFont *font)
wxFont *	find_font (const std::string &text_str, int max_size=32)
static bool	init_model_from_lines (GLModel &model, const Lines &lines, float z)
static void	register_model_for_picking (GLCanvas3D &canvas, PickingModel &model, int id)
static bool	init_model_from_lines (GLModel &model, const Lines3 &lines)
static ExPolygon	expolygon_from_polygon (const Polygon &polygon)
static void	append_expolygon_triangles (GLModel::Geometry &init_data, const ExPolygon &expolygon, float z)
static bool	init_model_from_polygons (GLModel &model, const Polygons &polygons, float z)
static bool	init_model_from_expolygons (GLModel &model, const ExPolygons &expolygons, float z)
static bool	init_exclusion_volume_prism_model (GLModel &model, const std::vector< ExclusionVolumePrismPreview > &prisms)
static void	init_raycaster_from_model (PickingModel &model)
static GLint	logo_texture_size ()
static bool	load_next_part_texture (PartPlateList::BedTextureInfo *infos, size_t count, size_t &next, bool compress_and_filter)
static bool	has_importable_texture (const Slic3r::TexturedMesh &textured_mesh)
	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)
	wxDEFINE_EVENT (EVT_EXPORT_FINISHED, wxCommandEvent)
	wxDEFINE_EVENT (EVT_IMPORT_MODEL_ID, wxCommandEvent)
	wxDEFINE_EVENT (EVT_DOWNLOAD_PROJECT, wxCommandEvent)
	wxDEFINE_EVENT (EVT_OPEN_PLATESETTINGSDIALOG, wxCommandEvent)
	wxDEFINE_EVENT (EVT_OPEN_FILAMENT_MAP_SETTINGS_DIALOG, wxCommandEvent)
	wxDEFINE_EVENT (EVT_RESTORE_PROJECT, wxCommandEvent)
	wxDEFINE_EVENT (EVT_PRINT_FINISHED, wxCommandEvent)
	wxDEFINE_EVENT (EVT_SEND_CALIBRATION_FINISHED, wxCommandEvent)
	wxDEFINE_EVENT (EVT_SEND_FINISHED, wxCommandEvent)
	wxDEFINE_EVENT (EVT_REPAIR_MODEL, wxCommandEvent)
	wxDEFINE_EVENT (EVT_FILAMENT_COLOR_CHANGED, wxCommandEvent)
	wxDEFINE_EVENT (EVT_INSTALL_PLUGIN_NETWORKING, wxCommandEvent)
	wxDEFINE_EVENT (EVT_UPDATE_PLUGINS_WHEN_LAUNCH, wxCommandEvent)
	wxDEFINE_EVENT (EVT_INSTALL_PLUGIN_HINT, wxCommandEvent)
	wxDEFINE_EVENT (EVT_PREVIEW_ONLY_MODE_HINT, wxCommandEvent)
	wxDEFINE_EVENT (EVT_GLCANVAS_COLOR_MODE_CHANGED, SimpleEvent)
	wxDEFINE_EVENT (EVT_PRINT_FROM_SDCARD_VIEW, SimpleEvent)
	wxDEFINE_EVENT (EVT_CREATE_FILAMENT, SimpleEvent)
	wxDEFINE_EVENT (EVT_MODIFY_FILAMENT, SimpleEvent)
	wxDEFINE_EVENT (EVT_ADD_FILAMENT, SimpleEvent)
	wxDEFINE_EVENT (EVT_DEL_FILAMENT, SimpleEvent)
	wxDEFINE_EVENT (EVT_ADD_CUSTOM_FILAMENT, ColorEvent)
	wxDEFINE_EVENT (EVT_NOTICE_CHILDE_SIZE_CHANGED, SimpleEvent)
	wxDEFINE_EVENT (EVT_NOTICE_FULL_SCREEN_CHANGED, IntEvent)
static std::string	get_diameter_string (float diameter)
template<typename T, typename OptionType>
static void	set_config_values (DynamicPrintConfig *config, const std::string &key, T value)
static void	zero_pressure_advance_where_disabled (DynamicPrintConfig *filament_config)
static wxColour	extruder_group_chip_bg ()
static void	use_nozzle_row_font (ComboBox *combo)
std::vector< int >	get_min_flush_volumes (const DynamicPrintConfig &full_config, size_t nozzle_id)
static bool	has_junction_deviation (const DynamicPrintConfig *printer_config)
static bool	is_skip_high_flow_printer (const std::string &printer)
static std::string	serialize_nozzle_config (const std::map< int, std::vector< DevNozzle > > &nozzle_cfg_map)
static std::map< int, std::vector< DevNozzle > >	deserialize_nozzle_config (const std::string &config_str)
static bool	is_same_nozzle_config (const std::map< int, std::vector< DevNozzle > > &config1, const std::map< int, std::vector< DevNozzle > > &config2)
static std::string	serialize_nozzle_option (const NozzleOption &option)
static std::optional< NozzleOption >	deserialize_nozzle_option (const std::string &option_str)
static std::string	blend_mixed_color (const std::vector< unsigned int > &comp_ids, const std::vector< int > &ratios, const std::vector< std::string > &color_strs)
static std::string	serialize_mixed_gradient_curve_if_custom (const MixedFilamentResult &result)
static bool	create_mixed_filament_from_result (Sidebar *sidebar, const MixedFilamentResult &result, const std::vector< std::string > &color_strs)
template<typename T>
void	setup_dialog_position (T &info)
static std::vector< Search::InputInfo >	get_search_inputs (ConfigOptionMode mode)
void	read_binary_stl (const std::string &filename, std::string &model_id, std::string &code)
static void	log_substitutions (const ConfigSubstitutions &substitutions, const std::string &source)
static void	log_substitutions (const PresetsConfigSubstitutions &substitutions, const std::string &source)
static void	sync_loaded_project_filament_config (DynamicConfig &proj_cfg)
static std::vector< BoundingBoxf3 >	free_print_volumes (const BoundingBoxf3 &bed, const std::vector< BoundingBoxf3 > &excludes)
static std::vector< wxString >	collect_imex_warnings (PartPlate *plate)
static void	get_position (wxWindowBase *child, wxWindowBase *until_parent, int &x, int &y)
LoadType	determine_load_type (std::string filename, std::string override_setting="")
static bool	belt_calib_rotation_params (double &angle_rad, Vec3d &axis)
static void	belt_calib_flip_ringing_tower (Model &model)
void	adjust_settings_for_flowrate_calib (ModelObjectPtrs &objects, bool linear, int pass, InfillPattern pattern)
static std::string	belt_temp_tower_asset (const Calib_Params &params)
static long	GetNumberFromUser (const wxString &msg, const wxString &prompt, const wxString &title, long value, long min, long max, wxWindow *parent)
Preset *	get_printer_preset (const MachineObject *obj)
wxString	get_view_type_string (Camera::ViewAngleType type)
wxArrayString	get_all_camera_view_type ()
	wxDECLARE_EVENT (EVT_SLICING_UPDATE, Slic3r::SlicingStatusEvent)
	wxDECLARE_EVENT (EVT_OPEN_PLATESETTINGSDIALOG, wxCommandEvent)
	wxDECLARE_EVENT (EVT_OPEN_FILAMENT_MAP_SETTINGS_DIALOG, wxCommandEvent)
	wxDECLARE_EVENT (EVT_REPAIR_MODEL, wxCommandEvent)
	wxDECLARE_EVENT (EVT_FILAMENT_COLOR_CHANGED, wxCommandEvent)
	wxDECLARE_EVENT (EVT_INSTALL_PLUGIN_NETWORKING, wxCommandEvent)
	wxDECLARE_EVENT (EVT_INSTALL_PLUGIN_HINT, wxCommandEvent)
	wxDECLARE_EVENT (EVT_UPDATE_PLUGINS_WHEN_LAUNCH, wxCommandEvent)
	wxDECLARE_EVENT (EVT_PREVIEW_ONLY_MODE_HINT, wxCommandEvent)
	wxDECLARE_EVENT (EVT_GLCANVAS_COLOR_MODE_CHANGED, SimpleEvent)
	wxDECLARE_EVENT (EVT_PRINT_FROM_SDCARD_VIEW, SimpleEvent)
	wxDECLARE_EVENT (EVT_CREATE_FILAMENT, SimpleEvent)
	wxDECLARE_EVENT (EVT_ADD_FILAMENT, SimpleEvent)
	wxDECLARE_EVENT (EVT_DEL_FILAMENT, SimpleEvent)
	wxDECLARE_EVENT (EVT_NOTICE_CHILDE_SIZE_CHANGED, SimpleEvent)
	wxDECLARE_EVENT (EVT_NOTICE_FULL_SCREEN_CHANGED, IntEvent)
	wxDECLARE_EVENT (EVT_ADD_CUSTOM_FILAMENT, ColorEvent)
	wxDEFINE_EVENT (EVT_SET_BED_TYPE_CONFIRM, wxCommandEvent)
	wxDEFINE_EVENT (EVT_NEED_RESORT_LAYERS, wxCommandEvent)
	wxDECLARE_EVENT (EVT_SET_BED_TYPE_CONFIRM, wxCommandEvent)
	wxDECLARE_EVENT (EVT_NEED_RESORT_LAYERS, wxCommandEvent)
void	refresh_plugin_metadata_blocking (bool fetch_cloud)
void	open_plugin_hub ()
bool	install_local_plugin_package (const boost::filesystem::path &package_file, wxWindow *parent, wxString &message)
std::string	to_string (PluginSortKey sort_key)
std::string	to_string (PluginSortOrder sort_order)
PluginSortKey	plugin_sort_key_from_string (const std::string &sort_key, PluginSortKey fallback)
PluginSortOrder	plugin_sort_order_from_string (const std::string &sort_order, PluginSortOrder fallback)
int	compare_ascii_case_insensitive_natural (const std::string &lhs, const std::string &rhs)
template<class PluginItem>
int	compare_plugin_base_order (const PluginItem &lhs, const PluginItem &rhs)
int	compare_plugin_version (const std::string &lhs, const std::string &rhs)
template<class PluginItem>
int	compare_plugin_sort_key (const PluginItem &lhs, const PluginItem &rhs, PluginSortKey sort_key)
template<class PluginItem>
void	sort_plugin_items_for_dialog (std::vector< PluginItem > &items, PluginSortKey sort_key, PluginSortOrder sort_order)
std::string	to_string (PluginSource source)
std::string	to_string (PluginStatus status)
PluginStatus	resolve_plugin_status (bool loading, bool has_error, bool is_loaded)
static wxColour	_GetLabelColour (const prePrintInfo &info)
static FilamentColorPickerValue	filament_color_picker_value (const DynamicPrintConfig &config, std::size_t index)
static void	run_wizard (ConfigWizard::StartPage sp)
static void	add_page_strings (wxWebView *webView)
static PrintHostType	active_host_type ()
std::unique_ptr< PrinterWebViewHandler >	create_printer_webview_handler (PrinterWebView &owner)
	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_PRIVACY_UPDATE_CONFIRM, wxCommandEvent)
	wxDEFINE_EVENT (EVT_PRIVACY_UPDATE_CANCEL, wxCommandEvent)
static std::string	url_encode (const std::string &value)
	wxDECLARE_EVENT (EVT_PRIVACY_UPDATE_CONFIRM, wxCommandEvent)
	wxDECLARE_EVENT (EVT_PRIVACY_UPDATE_CANCEL, wxCommandEvent)
	wxDEFINE_EVENT (EVT_PROJECT_RELOAD, wxCommandEvent)
static json	project_page_strings ()
static std::string	convert_newlines_to_br (const std::string &text)
	wxDECLARE_EVENT (EVT_PROJECT_RELOAD, wxCommandEvent)
	wxDEFINE_EVENT (EVT_SECONDARY_CHECK_CONFIRM, wxCommandEvent)
	wxDEFINE_EVENT (EVT_SECONDARY_CHECK_CANCEL, wxCommandEvent)
	wxDEFINE_EVENT (EVT_SECONDARY_CHECK_DONE, wxCommandEvent)
	wxDEFINE_EVENT (EVT_SECONDARY_CHECK_RESUME, wxCommandEvent)
	wxDEFINE_EVENT (EVT_CHECKBOX_CHANGE, wxCommandEvent)
	wxDEFINE_EVENT (EVT_ENTER_IP_ADDRESS, wxCommandEvent)
	wxDEFINE_EVENT (EVT_CLOSE_IPADDRESS_DLG, wxCommandEvent)
	wxDEFINE_EVENT (EVT_CHECK_IP_ADDRESS_FAILED, wxCommandEvent)
	wxDEFINE_EVENT (EVT_CHECK_IP_ADDRESS_LAYOUT, wxCommandEvent)
	wxDEFINE_EVENT (EVT_SECONDARY_CHECK_RETRY, wxCommandEvent)
	wxDEFINE_EVENT (EVT_UPDATE_NOZZLE, wxCommandEvent)
	wxDEFINE_EVENT (EVT_UPDATE_TEXT_MSG, wxCommandEvent)
	wxDEFINE_EVENT (EVT_ERROR_DIALOG_BTN_CLICKED, wxCommandEvent)
static std::string	url_encode (const std::string &value)
static void	nop_deleter (InputIpAddressDialog *)
	wxDECLARE_EVENT (EVT_SECONDARY_CHECK_CONFIRM, wxCommandEvent)
	wxDECLARE_EVENT (EVT_SECONDARY_CHECK_CANCEL, wxCommandEvent)
	wxDECLARE_EVENT (EVT_SECONDARY_CHECK_RETRY, wxCommandEvent)
	wxDECLARE_EVENT (EVT_SECONDARY_CHECK_DONE, wxCommandEvent)
	wxDECLARE_EVENT (EVT_SECONDARY_CHECK_RESUME, wxCommandEvent)
	wxDECLARE_EVENT (EVT_UPDATE_NOZZLE, wxCommandEvent)
	wxDECLARE_EVENT (EVT_UPDATE_TEXT_MSG, wxCommandEvent)
	wxDECLARE_EVENT (EVT_ERROR_DIALOG_BTN_CLICKED, wxCommandEvent)
	wxDECLARE_EVENT (EVT_CLOSE_IPADDRESS_DLG, wxCommandEvent)
	wxDECLARE_EVENT (EVT_CHECKBOX_CHANGE, wxCommandEvent)
	wxDECLARE_EVENT (EVT_ENTER_IP_ADDRESS, wxCommandEvent)
	wxDECLARE_EVENT (EVT_CHECK_IP_ADDRESS_FAILED, wxCommandEvent)
	wxDECLARE_EVENT (EVT_CHECK_IP_ADDRESS_LAYOUT, wxCommandEvent)
	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)
FrameTimeStats	frame_time_stats (std::vector< double > frame_ms)
void	run_scene_benchmark ()
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 Transform3d &rot_xyz_from, const Transform3d &rot_xyz_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)
ModelVolume *	get_selected_volume (const ObjectID &volume_id, const Selection &selection)
ModelVolume *	get_volume (const ObjectID &volume_id, const Selection &selection)
	wxDEFINE_EVENT (EVT_SWITCH_PRINT_OPTION, wxCommandEvent)
	wxDEFINE_EVENT (EVT_UPDATE_USER_MACHINE_LIST, wxCommandEvent)
	wxDEFINE_EVENT (EVT_PRINT_JOB_CANCEL, wxCommandEvent)
	wxDEFINE_EVENT (EVT_CLEAR_IPADDRESS, wxCommandEvent)
std::string	get_nozzle_volume_type_cloud_string (NozzleVolumeType nozzle_volume_type)
void	print_ams_mapping_result (std::vector< FilamentInfo > &result)
static std::unordered_set< int >	_get_used_nozzle_idxes ()
static bool	_is_rack_managed_nozzle (const MachineObject *obj, int nozzle_idx)
static bool	_HasExt (const std::vector< FilamentInfo > &ams_mapping_result)
static bool	_HasAms (const std::vector< FilamentInfo > &ams_mapping_result)
static bool	_compare_obj_names (MachineObject *obj1, MachineObject *obj2)
static void	_collect_sorted_machines (Slic3r::DeviceManager *dev_manager, std::vector< MachineObject * > &sorted_machine_objs)
static wxString	_check_kval_not_default (const MachineObject *obj, const std::vector< FilamentInfo > &mapping_result)
static wxString	_get_nozzle_name (int total_ext_count, int ext_id)
static std::unordered_multimap< int, NozzleDef >	s_get_slicing_extuder_nozzles ()
static wxString	_get_ext_loc_str (const std::unordered_set< int > &extruders, int total_ext_num)
static wxString	_get_tips (MachineObject *obj_)
static int	get_brightness_value (wxImage image)
	wxDECLARE_EVENT (EVT_SWITCH_PRINT_OPTION, wxCommandEvent)
	wxDEFINE_EVENT (EVT_UPDATE_WINDOWS_POSITION, wxCommandEvent)
	wxDEFINE_EVENT (EVT_FINISHED_UPDATE_MACHINE_LIST, wxCommandEvent)
	wxDEFINE_EVENT (EVT_BIND_MACHINE, wxCommandEvent)
	wxDEFINE_EVENT (EVT_UNBIND_MACHINE, wxCommandEvent)
	wxDEFINE_EVENT (EVT_DISSMISS_MACHINE_LIST, wxCommandEvent)
	wxDEFINE_EVENT (EVT_CONNECT_LAN_PRINT, wxCommandEvent)
	wxDEFINE_EVENT (EVT_EDIT_PRINT_NAME, wxCommandEvent)
	wxDECLARE_EVENT (EVT_FINISHED_UPDATE_MACHINE_LIST, wxCommandEvent)
	wxDECLARE_EVENT (EVT_WILL_DISMISS_MACHINE_LIST, wxCommandEvent)
	wxDECLARE_EVENT (EVT_UPDATE_WINDOWS_POSITION, wxCommandEvent)
	wxDECLARE_EVENT (EVT_DISSMISS_MACHINE_LIST, wxCommandEvent)
	wxDECLARE_EVENT (EVT_CONNECT_LAN_PRINT, wxCommandEvent)
	wxDECLARE_EVENT (EVT_EDIT_PRINT_NAME, wxCommandEvent)
	wxDECLARE_EVENT (EVT_UNBIND_MACHINE, wxCommandEvent)
	wxDECLARE_EVENT (EVT_BIND_MACHINE, wxCommandEvent)
	WX_DEFINE_LIST (AmsRadioSelectorList)
	WX_DECLARE_LIST (AmsRadioSelector, AmsRadioSelectorList)
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 ()
	wxDEFINE_EVENT (EVT_SEND_JOB_SUCCESS, wxCommandEvent)
static wxString	ParseErrorCode (int errorcde)
	wxDECLARE_EVENT (EVT_CLEAR_IPADDRESS, wxCommandEvent)
void	sort_sequential_clearance_instances (std::vector< SequentialClearanceInstance >::iterator first, std::vector< SequentialClearanceInstance >::iterator last, const std::map< ObjectID, int > &print_order)
std::vector< std::pair< Polygon, float > >	sequential_clearance_height_polygons (const std::vector< SequentialClearanceInstance > &instances, double printable_height, double height_to_lid, double height_to_rod)
const ShortcutInfo &	shortcut_info (Shortcut shortcut)
ShortcutSection	shortcut_section (Shortcut shortcut)
const char *	section_name (ShortcutSection section)
std::vector< Shortcut >	shortcuts_in (ShortcutContext context)
constexpr uint8_t	context_bit (ShortcutContext context)
void	DrawRoundedRect (float x, float y, float width, float height, float radius, const ColorRGB &color, int segments=16)
	wxIMPLEMENT_CLASS (SliceInfoPopup, PopupWindow)
	wxBEGIN_EVENT_TABLE (SliceInfoPopup, PopupWindow) wxEND_EVENT_TABLE() static wxColour BUTTON_BORDER_COL
float	calc_gray (wxColour color)
static wxColour	decode_color (const std::string &color)
static void	market_model_scoring_page (int design_id)
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, const 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.
std::optional< float >	calc_distance (const GLVolume &gl_volume, RaycastManager &raycaster, GLCanvas3D &canvas)
	Calculate distance by ray to surface of object in emboss direction.
std::optional< float >	calc_distance (const GLVolume &gl_volume, const RaycastManager &raycaster, const RaycastManager::ISkip *condition, const std::optional< Slic3r::Transform3d > &fix)
std::optional< float >	calc_angle (const Selection &selection)
	Calculate up vector angle.
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.
void	selection_transform (Selection &selection, const std::function< void()> &selection_transformation_fnc)
	Wrap function around selection transformation to apply fix transformation Fix transformation is needed because of (store/load) volume (to/from) 3mf.
bool	face_selected_volume_to_camera (const Camera &camera, GLCanvas3D &canvas, const std::optional< double > &wanted_up_limit={})
	Apply camera direction for emboss direction.
void	do_local_z_rotate (Selection &selection, double relative_angle)
	Rotation around z Axis(emboss direction).
void	do_local_z_move (Selection &selection, double relative_move)
	Translation along local z Axis (emboss direction).
TransformationType	get_drag_transformation_type (const Selection &selection)
	Distiguish between object and volume Differ in possible transformation type.
void	dragging_rotate_gizmo (double gizmo_angle, std::optional< float > &current_angle, std::optional< float > &start_angle, Selection &selection)
	On dragging rotate gizmo func Transform GLVolume from selection.
static void	UpdatePositionAlignment (wxWindow *w, wxPoint base_position, bool align_right)
static void	validate_custom_gcode_cb (Tab *tab, const wxString &title, const t_config_option_key &opt_key, const boost::any &value)
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 void	drop_unchanged_added_entries (std::vector< std::string > &options, const DynamicPrintConfig &current, const Preset *reference)
static const std::vector< std::string > &	preset_type_options (Preset::Type type)
static const char *	preset_type_name (Preset::Type type)
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	update_all_extruder_variants (int extruder_idx=-1)
static std::vector< std::string >	intersect (std::vector< std::string > const &l, std::vector< std::string > const &r)
static std::vector< std::string >	concat (std::vector< std::string > const &l, std::vector< std::string > const &r)
static std::vector< std::string >	substruct (std::vector< std::string > const &l, std::vector< std::string > const &r)
static std::vector< std::string >	variant_keys (DynamicPrintConfig const &config)
static void	validate_custom_gcode_cb (Tab *tab, ConfigOptionsGroupShp opt_group, const t_config_option_key &opt_key, const boost::any &value)
static wxString	custom_gcode_group_title (const Page *page, const t_config_option_key &opt_key)
static void	imex_grid_shape (const DynamicPrintConfig *cfg, int &n_cols, int &n_rows, int &layout)
static wxString	short_nozzle_volume_name (const std::string &volume_name)
	wxDEFINE_EVENT (EVT_TEXTURE_COMPUTE_DONE, wxCommandEvent)
	wxDEFINE_EVENT (EVT_TEXTURE_COMPUTE_PROGRESS, wxCommandEvent)
	wxDEFINE_EVENT (EVT_TEXTURE_COMPUTE_ERROR, wxCommandEvent)
	wxDEFINE_EVENT (EVT_TEXTURE_MESH_REPAIR_DECISION, wxCommandEvent)
static std::array< float, 4 >	parse_color_string (const std::string &hex)
static wxString	rgb_to_hex (const std::array< std::size_t, 3 > &c)
static wxString	filament_name_to_wx_string (const std::string &name)
static std::string	texture_normalize_color_hex (std::string hex)
static std::string	texture_rgba_to_hex (const std::array< float, 4 > &rgba)
static bool	texture_entry_is_physical (TextureFilamentKind kind)
static bool	texture_entry_is_mixed (TextureFilamentKind kind)
static bool	texture_entry_is_pla_basic (const TextureFilamentEntry &entry)
static bool	texture_entry_official_basic (const TextureFilamentEntry &entry)
static Slic3r::ColorDecomposeRecipeMode	texture_recipe_mode (TextureAutoMixMode mode)
static bool	starts_with_preset_name (const std::string &name, const char *prefix)
static std::string	resolve_default_virtual_filament_preset_name ()
static wxString	auto_mix_mode_label (TextureAutoMixMode mode)
static void	convert_face_colors (const std::vector< std::array< std::size_t, 3 > > &src, std::vector< std::array< float, 3 > > &dst)
	wxBEGIN_EVENT_TABLE (TextureImportDialog, DPIDialog) wxEND_EVENT_TABLE() TextureImportDialog
	wxDECLARE_EVENT (EVT_TEXTURE_COMPUTE_DONE, wxCommandEvent)
	wxDECLARE_EVENT (EVT_TEXTURE_COMPUTE_PROGRESS, wxCommandEvent)
	wxDECLARE_EVENT (EVT_TEXTURE_COMPUTE_ERROR, wxCommandEvent)
	wxDECLARE_EVENT (EVT_TEXTURE_MESH_REPAIR_DECISION, wxCommandEvent)
uint64_t	texture_library_generation ()
void	bump_texture_library_generation ()
std::string	user_texture_dir ()
const std::vector< TextureLibraryEntry > &	texture_library (bool force_rescan)
void	touch_user_texture (const std::string &path)
bool	remove_user_texture (const std::string &path, std::string &error)
std::optional< TextureLibraryEntry >	import_texture_to_library (const std::string &source_path, std::string &error)
std::shared_ptr< std::vector< unsigned char > >	load_texture_image_data (const std::string &path, std::string &error)
std::optional< TextureLibraryEntry >	save_texture_to_library (const DecodedHeightTexture &image, const std::string &stem, std::string &error)
	wxDEFINE_EVENT (EVT_DIFF_DIALOG_TRANSFER, 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 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)
static const std::string	CONFIG_UPDATE_WIKI_URL ("")
	WX_DEFINE_ARRAY (AmsPanel *, AmsPanelHash)
static json	guide_strings ()
static wxString	update_custom_filaments ()
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)
void	StringReplace (std::string &strBase, std::string strSrc, std::string strDes)
	wxDECLARE_EVENT (EVT_RESPONSE_MESSAGE, wxCommandEvent)
	wxDEFINE_EVENT (EVT_RESPONSE_MESSAGE, wxCommandEvent)
static json	home_page_strings ()
static wxString	http_origin_of (const wxString &url)
static bool	cloud_navigation_is_top_level (const wxWebViewEvent &evt)
static void	open_cloud_url_externally (const wxString &url)
	wxDEFINE_EVENT (EVT_AMS_EXTRUSION_CALI, wxCommandEvent)
	wxDEFINE_EVENT (EVT_AMS_LOAD, SimpleEvent)
	wxDEFINE_EVENT (EVT_AMS_UNLOAD, SimpleEvent)
	wxDEFINE_EVENT (EVT_AMS_SETTINGS, SimpleEvent)
	wxDEFINE_EVENT (EVT_AMS_FILAMENT_BACKUP, SimpleEvent)
	wxDEFINE_EVENT (EVT_AMS_REFRESH_RFID, wxCommandEvent)
	wxDEFINE_EVENT (EVT_AMS_ON_SELECTED, wxCommandEvent)
	wxDEFINE_EVENT (EVT_AMS_ON_FILAMENT_EDIT, wxCommandEvent)
	wxDEFINE_EVENT (EVT_VAMS_ON_FILAMENT_EDIT, wxCommandEvent)
	wxDEFINE_EVENT (EVT_AMS_CLIBRATION_AGAIN, wxCommandEvent)
	wxDEFINE_EVENT (EVT_AMS_CLIBRATION_CANCEL, wxCommandEvent)
	wxDEFINE_EVENT (EVT_AMS_GUIDE_WIKI, wxCommandEvent)
	wxDEFINE_EVENT (EVT_AMS_RETRY, wxCommandEvent)
	wxDEFINE_EVENT (EVT_AMS_SHOW_HUMIDITY_TIPS, wxCommandEvent)
	wxDEFINE_EVENT (EVT_AMS_UNSELETED_VAMS, wxCommandEvent)
	wxDEFINE_EVENT (EVT_AMS_SWITCH, SimpleEvent)
static wxColour	_get_diff_clr (wxWindow *win, wxColour pen_clr)
	wxDECLARE_EVENT (EVT_AMS_EXTRUSION_CALI, wxCommandEvent)
	wxDECLARE_EVENT (EVT_AMS_LOAD, SimpleEvent)
	wxDECLARE_EVENT (EVT_AMS_UNLOAD, SimpleEvent)
	wxDECLARE_EVENT (EVT_AMS_SETTINGS, SimpleEvent)
	wxDECLARE_EVENT (EVT_AMS_FILAMENT_BACKUP, SimpleEvent)
	wxDECLARE_EVENT (EVT_AMS_REFRESH_RFID, wxCommandEvent)
	wxDECLARE_EVENT (EVT_AMS_ON_SELECTED, wxCommandEvent)
	wxDECLARE_EVENT (EVT_AMS_ON_FILAMENT_EDIT, wxCommandEvent)
	wxDECLARE_EVENT (EVT_AMS_CLIBRATION_AGAIN, wxCommandEvent)
	wxDECLARE_EVENT (EVT_AMS_CLIBRATION_CANCEL, wxCommandEvent)
	wxDECLARE_EVENT (EVT_AMS_GUIDE_WIKI, wxCommandEvent)
	wxDECLARE_EVENT (EVT_AMS_RETRY, wxCommandEvent)
	wxDECLARE_EVENT (EVT_AMS_SHOW_HUMIDITY_TIPS, wxCommandEvent)
	wxDECLARE_EVENT (EVT_AMS_UNSELETED_VAMS, wxCommandEvent)
	wxDECLARE_EVENT (EVT_AMS_UNSELETED_AMS, wxCommandEvent)
	wxDECLARE_EVENT (EVT_VAMS_ON_FILAMENT_EDIT, wxCommandEvent)
	wxDECLARE_EVENT (EVT_AMS_SWITCH, SimpleEvent)
	wxDEFINE_EVENT (EVT_FAN_SWITCH_ON, wxCommandEvent)
	wxDEFINE_EVENT (EVT_FAN_SWITCH_OFF, wxCommandEvent)
	wxDEFINE_EVENT (EVT_FAN_ADD, wxCommandEvent)
	wxDEFINE_EVENT (EVT_FAN_DEC, wxCommandEvent)
	wxDEFINE_EVENT (EVT_FAN_CHANGED, wxCommandEvent)
static void	nop_deleter_fan_control (FanControlNew *)
static void	nop_deleter_fan_control_popup (FanControlPopupNew *)
	wxDEFINE_EVENT (EVT_FANCTRL_SWITCH, wxCommandEvent)
	wxDECLARE_EVENT (EVT_FANCTRL_SWITCH, wxCommandEvent)
	wxDECLARE_EVENT (EVT_FAN_SWITCH_ON, wxCommandEvent)
	wxDECLARE_EVENT (EVT_FAN_SWITCH_OFF, wxCommandEvent)
	wxDECLARE_EVENT (EVT_FAN_ADD, wxCommandEvent)
	wxDECLARE_EVENT (EVT_FAN_DEC, wxCommandEvent)
	wxDECLARE_EVENT (EVT_FAN_CHANGED, wxCommandEvent)
	wxDEFINE_EVENT (EVT_NOZZLE_SELECTED, wxCommandEvent)
int	getExtruderNozzleCount (PresetBundle *preset_bundle, int extruder_id, NozzleVolumeType volume_type)
int	getExtruderNozzleCountTotal (PresetBundle *preset_bundle, int extruder_id)
void	setNozzleStatsFromMachine (bool from_machine)
void	setExtruderNozzleCount (PresetBundle *preset_bundle, int extruder_id, NozzleVolumeType volume_type, int nozzle_count, bool clear_all)
bool	nozzle_diameter_supports_tpu_high_flow (double nozzle_diameter)
bool	extruder_supports_tpu_high_flow (PresetBundle *preset_bundle, int extruder_id)
void	updateNozzleCountDisplay (PresetBundle *preset_bundle, int extruder_id, NozzleVolumeType volume_type)
void	seedExtruderNozzleStats (PresetBundle *preset_bundle)
void	onNozzleVolumeTypeSwitch (PresetBundle *preset_bundle, int extruder_id, NozzleVolumeType type)
void	manuallySetNozzleCount (int extruder_id)
std::optional< NozzleOption >	tryPopUpMultiNozzleDialog (MachineObject *obj)
	wxDECLARE_EVENT (EVT_NOZZLE_SELECTED, wxCommandEvent)
static const std::string &	calib_temp_dir ()
static std::string	calib_temp_file (const std::string &name)
void	get_default_k_n_value (const std::string &filament_id, float &k, float &n)
wxString	get_nozzle_volume_type_name (NozzleVolumeType type)
void	update_speed_parameter (const std::string &key)
std::vector< double >	generate_max_speed_parameter_value (const std::string &key, const float line_width, const float layer_height, const bool linear, const int pass)
static int	get_physical_extruder_idx (std::vector< int > physical_extruder_maps, int extruder_id)
void	get_tray_ams_and_slot_id (MachineObject *obj, int in_tray_id, int &ams_id, int &slot_id, int &tray_id)
std::string	get_calib_mode_name (CalibMode cali_mode, int stage)
static wxString	to_wstring_name (std::string name)
static bool	is_same_nozzle_type (const DynamicPrintConfig &full_config, const MachineObject *obj, wxString &error_msg)
static bool	check_nozzle_diameter_and_type (const DynamicPrintConfig &full_config, wxString &error_msg)
static void	init_multi_extruder_params_for_cali (DynamicPrintConfig &config, const CalibInfo &calib_info)
static void	cut_model (Model &model, double z, ModelObjectCutAttributes attributes)
static void	read_model_from_file (const std::string &input_file, Model &model)
std::array< Vec3d, 4 >	get_cut_plane_points (const BoundingBoxf3 &bbox, const double &cut_height)
bool	mac_dark_mode ()
double	mac_max_scaling_factor ()
void	set_miniaturizable (void *window)
void	set_tag_when_enter_full_screen (bool isfullscreen)
void	set_title_colour_after_set_title (void *window)
void	WKWebView_evaluateJavaScript (void *web, wxString const &script, void(*callback)(wxString const &))
void	WKWebView_setTransparentBackground (void *web)
void	WKWebView_force_display (void *web)
void	openFolderForFile (wxString const &file)
void	initGestures (void *view, wxEvtHandler *handler)
static void	start_new_slicer_or_gcodeviewer (const NewSlicerInstanceType instance_type, const std::vector< wxString > paths_to_open, bool single_instance)
static void	start_new_slicer_or_gcodeviewer (const NewSlicerInstanceType instance_type, const wxString *path_to_open, bool single_instance)
void	start_new_slicer (const wxString *path_to_open, bool single_instance)
void	start_new_slicer (const std::vector< wxString > &files, bool single_instance)
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.
RaycastManager::AllowVolumes	create_condition (const ModelVolumePtrs &volumes, const ObjectID &disallowed_volume_id)
	Create condition to allowe only parts from volumes without one given.

Variables
constexpr const char *	kOrcaSourceKey = "orca"
constexpr const char *	kOrcaSourceName = "OrcaSlicer"
const int	AMS_DRY_STATUS_IMAGE_SIZE = 96
const int	LEFT_OFFSET = 2
static constexpr size_t	MAPPED_NOZZLE_STR_MAX_CHARS_PER_LINE = 7
static const char *	AMS_FAVORITE_FILAMENT_IDS_KEY = "ams_favorite_filament_ids"
const std::vector< std::string >	license_list
const char *const	build_commit_hash = GIT_COMMIT_HASH
const char *const	build_commit_label = GIT_COMMIT_HASH GIT_COMMIT_SUFFIX
constexpr int	kCadRightClickDriftPx = 3
static const char *const	kOfferRowNames []
static const int	kOfferRowCount = 9
static const bool	kOfferRowFlat []
static const OfferVerb	kOfferVerbs []
static const int	kOfferVerbCount = 93
static constexpr double	MESH_IMPORT_TOLERANCE = 0.01
static constexpr double	MESH_IMPORT_MERGE_ANGLE_DEG = 5.0
static constexpr size_t	MESH_IMPORT_TRIANGLE_WARN = 50000
static const DpToken	kDpTokens [TokCount]
static constexpr int	kOriginRow = 0
static constexpr int	kBedRow = 1
static std::atomic< int >	s_doc_worker_busy {0}
static constexpr int	kIconPx = 16
static constexpr int	kCellDip = 20
static constexpr int	kPadDip = 4
static constexpr int	kGapDip = 6
static constexpr int	kArcFacets = 24
static const Vec2d	kBearOutline []
static const Vec2d	kBearChin []
static const Vec3d	kBearMarks []
static const double	kBearPlateZ = +0.0360
static const Vec2d	kBearSnoutBase []
static const Vec3d	kBearCrest []
static const char *	kFontKey = "cad_text_font"
static const char *	kHeightKey = "cad_text_height"
static const wxString	NA_STR = _L("N/A")
static const float	MIN_PA_K_VALUE_STEP = 0.001
static const int	MAX_PA_HISTORY_RESULTS_NUMS = 16
static const wxString	NA_STR = _L("N/A")
static int	PA_LINE = 0
static int	PA_PATTERN = 1
float	nozzle_diameter_list [NOZZLE_LIST_COUNT] = {0.2, 0.4, 0.6, 0.8 }
	wxMouseEvent
const wxColour	TEXT_COL = wxColour(43, 52, 54)
static const wxColour	BgNormalColor = wxColour("#FFFFFF")
static const wxColour	BgSelectColor = wxColour("#E5F0EE")
static const wxColour	TextNormalColor = wxColour("#262E30")
static const wxColour	TextSelectColor = wxColour("#262E30")
static const wxColour	BorderNormalColor = wxColour("#CECECE")
static const wxColour	BorderSelectColor = wxColour("#009688")
constexpr const char *	kDecomposePlaBasicType = "PLA Basic"
constexpr const char *	kDecomposePetgBasicType = "PETG Basic"
constexpr const char *	kDecomposePlaShortType = "PLA"
constexpr const char *	kDecomposePetgShortType = "PETG"
constexpr const char *	kDecomposePlaFilamentId = "GFA00"
constexpr const char *	kDecomposePetgFilamentId = "GFG00"
constexpr const char *	kDecomposeBambuPresetPrefix = "Bambu "
constexpr std::size_t	COLOR_PICKER_MAX_GRADIENT_COLORS = 7
static const std::unordered_map< std::string, std::pair< std::string, std::string > >	legacy_preset_map
static const std::vector< std::string >	filament_vendors
static const std::vector< std::string >	filament_types
static const std::vector< std::string >	printer_vendors
static const std::unordered_map< std::string, std::vector< std::string > >	printer_model_map
static std::vector< std::string >	nozzle_diameter_vec = {"0.4", "0.15", "0.2", "0.25", "0.3", "0.35", "0.5", "0.6", "0.75", "0.8", "1.0", "1.2", "1.75"}
static std::unordered_map< std::string, float >	nozzle_diameter_map
static std::set< int >	cannot_input_key = {9, 10, 13, 33, 35, 36, 37, 38, 40, 41, 42, 44, 46, 47, 59, 60, 62, 63, 64, 92, 94, 95, 124, 126}
static std::set< char >	special_key = {'\n', '\t', '\r', '\v', '@', ';'}
static std::string	last_directory = ""
static std::unordered_set< std::string >	message_containing_retry
static const std::unordered_set< std::string >	s_jump_liveview_error_codes = { "0300-8003", "0300-8002", "0300-800A"}
const size_t	DOWNLOAD_MAX_CHUNK_SIZE = 10 * 1024 * 1024
const size_t	DOWNLOAD_SIZE_LIMIT = 1024 * 1024 * 1024
static const wxColour	CANVAS_BORDER_COLOR = wxColour(0xCECECE)
const std::map< ParamType, std::string >	ParamsInfo
std::vector< std::deque< wxWindow * > ** >	spools
std::vector< std::deque< wxWindow * > * >	spools2
static std::map< std::string, DynamicList * >	dynamic_lists
static const wxColour	LabelEnableColor = wxColour("#262E30")
static const wxColour	LabelDisableColor = wxColour("#ACACAC")
static const wxColour	GreyColor = wxColour("#6B6B6B")
static const wxColour	BackGroundColor = wxColour("#FFFFFF")
static const wxColour	BgNormalColor = wxColour("#FFFFFF")
static const wxColour	BgSelectColor = wxColour("#E5F0EE")
static const wxColour	BgDisableColor = wxColour("#CECECE")
static const wxColour	BorderNormalColor = wxColour("#CECECE")
static const wxColour	BorderSelectedColor = wxColour("#009688")
static const wxColour	BorderDisableColor = wxColour("#EEEEEE")
static const wxColour	TextNormalBlackColor = wxColour("#262E30")
static const wxColour	TextNormalGreyColor = wxColour("#6B6B6B")
static const wxColour	TextDisableColor = wxColour("#CECECE")
static const wxColour	TextErrorColor = wxColour("#E14747")
static const float	GCODE_VIEWER_SLIDER_SCALE = 0.6f
static const float	SLIDER_DEFAULT_RIGHT_MARGIN = 10.0f
static const float	SLIDER_DEFAULT_BOTTOM_MARGIN = 10.0f
static const float	SLIDER_RIGHT_MARGIN = IMSlider::vertical_slider_window_width()
static const float	SLIDER_BOTTOM_MARGIN = 64.0f
static const char *	label_values [3][3]
static const char *	label_scale_values [2][3]
static const ColorRGBA	DEF_COLOR = {0.7f, 0.7f, 0.7f, 1.f}
static const ColorRGBA	SELECTED_COLOR = {0.0f, 0.5f, 0.5f, 1.0f}
static const ColorRGBA	ERR_COLOR = {1.0f, 0.3f, 0.3f, 0.5f}
static const ColorRGBA	HOVER_COLOR = {0.7f, 0.7f, 0.7f, 0.5f}
static constexpr float	BRIM_EAR_RADIUS_MIN = 0.1f
static constexpr float	BRIM_EAR_RADIUS_MAX = 100.f
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)
static const ColorRGBA	CUT_PLANE_DEF_COLOR = ColorRGBA(0.9f, 0.9f, 0.9f, 0.5f)
static const ColorRGBA	CUT_PLANE_ERR_COLOR = ColorRGBA(1.0f, 0.8f, 0.8f, 0.5f)
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 = " "
const float	MEASURE_PLNE_NORMAL_OFFSET = 0.05
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 Slic3r::ColorRGBA	HOVER_COLOR = ColorRGBA::GREEN()
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 std::string	warning_text = _u8L("Unable to perform boolean operation on selected parts")
static constexpr double	TIP_DELAY = 0.45
static constexpr double	TIP_DELAY_AGAIN = 0.10
static constexpr double	TIP_STICKY = 0.70
static constexpr float	STD_REMESH_EDGE_MM = 1.0f
static constexpr float	STD_REMESH_SHARP_DEG = 40.f
static constexpr float	STD_SUBDIV_MAX_EDGE_MM = 20.f
static constexpr float	STD_SUBDIV_DETAIL_MM = 0.02f
static constexpr float	STD_SUBDIV_MIN_EDGE_MM = 0.1f
static constexpr float	STD_SUBDIV_BORDER_MM = 0.4f
static constexpr float	STD_SUBDIV_COLOR_MM = 0.25f
wxString	filament_printable_error_msg
static constexpr std::array< double, 4 >	marker_radii { 9., 7., 6., 5. }
static constexpr float	NAVIGATOR_SIZE = 128.f
static constexpr float	CANVAS_TOOLBAR_MARGIN = 10.f
static constexpr float	CANVAS_TOOLBAR_PADDING = 2.f
static constexpr float	CANVAS_TOOLBAR_BUTTON = 36.f
static constexpr float	CANVAS_TOOLBAR_SPACING = 6.f
static std::set< int >	s_keys_down
static const float	cameraProjection [16] = {1.f, 0.f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f, 0.f, 0.f, 1.f}
static const Vec3d	STATIC_LIGHT_DIR = Vec3d(-0.4, -0.6, 1.0).normalized()
static constexpr float	PLATE_TOOLBAR_SCROLLBAR = 14.f
static const FileWildcards	file_wildcards_by_type [FT_SIZE]
static std::mutex	conflict_ids_mutex
static std::mutex	mutex_delete_cache_presets
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 * >, 11 >	ADD_VOLUME_MENU_ITEMS
static const constexpr std::array< std::pair< const char *, const char * >, 3 >	TEXT_VOLUME_ICONS
static const constexpr std::array< std::pair< const char *, const char * >, 3 >	SVG_VOLUME_ICONS
static const int	grid_cell_border_width = 2
static const int	grid_cell_border_height = 2
static const int	grid_cell_checkbox_size = 16
static const int	g_min_row_count = 16
static const int	g_overflow_row_count = 50
static const int	g_min_row_size = 36
static const int	g_extra_height = 64
static const int	g_min_setting_width = 464
static const int	g_vscroll_width = 48
static int	g_dialog_width = 0
static int	g_dialog_height = 0
static int	g_dialog_max_width = 0
static int	g_dialog_max_height = 0
static wxSize	g_max_size_from_parent
std::deque< wxDialog * >	dialogStack
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 constexpr int	SHADOW_WIDTH = 3
static constexpr wchar_t const *	TIME_FORMATS [] = {_T("%Y-%m-%d"), _T("%Y-%m"), _T("%Y")}
static constexpr int	kImexIconPx = 20
static constexpr int	kNameColPx = 176
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 ImWchar	ranges_language_independent []
static bool	m_is_dark_mode = false
static const float	LEFT_MARGIN = 13.0f + 100.0f
static const float	HORIZONTAL_SLIDER_WINDOW_HEIGHT = 64.0f
static const float	VERTICAL_SLIDER_WINDOW_WIDTH = 164.0f
static const float	GROOVE_WIDTH = 12.0f
static const ImVec2	ONE_LAYER_MARGIN = ImVec2(20.0f, 20.0f)
static const ImVec2	ONE_LAYER_BUTTON_SIZE = ImVec2(56.0f, 56.0f)
static const ImU32	BACKGROUND_COLOR_DARK = IM_COL32(65, 65, 71, 255)
static const ImU32	BACKGROUND_COLOR_LIGHT = IM_COL32(255, 255, 255, 255)
static const ImU32	GROOVE_COLOR_DARK = IM_COL32(45, 45, 49, 255)
static const ImU32	GROOVE_COLOR_LIGHT = IM_COL32(206, 206, 206, 255)
static const ImU32	BRAND_COLOR = IM_COL32(0, 150, 136, 255)
static int	m_tick_value = -1
static ImVec4	m_tick_rect
static const constexpr double	LOGICAL_BED_GAP = 1. / 5.
static auto	waiting_auth_str = _u8L("Logging in")
static auto	login_failed_str = _u8L("Login failed")
constexpr int	ABORT_WAIT_MAX_MS = 10000
static auto	check_gcode_failed_str = _u8L("Abnormal print file data: please slice again.")
static auto	printjob_cancel_str = _u8L("Task canceled.")
static auto	timeout_to_upload_str = _u8L("Upload task timed out. Please check the network status and try again.")
static auto	failed_in_cloud_service_str = _u8L("Cloud service connection failed. Please try again.")
static auto	file_is_not_exists_str = _u8L("Print file not found; please slice again.")
static auto	file_over_size_str = _u8L("The print file exceeds the maximum allowable size (1GB). Please simplify the model and slice again.")
static auto	print_canceled_str = _u8L("Task canceled.")
static auto	send_print_failed_str = _u8L("Failed to send the print job. Please try again.")
static auto	upload_ftp_failed_str = _u8L("Failed to upload file to ftp. Please try again.")
static auto	desc_network_error = _u8L("Check the current status of the Bambu Lab server by clicking on the link above.")
static auto	desc_file_too_large = _u8L("The size of the print file is too large. Please adjust the file size and try again.")
static auto	desc_fail_not_exist = _u8L("Print file not found; please slice it again and send it for printing.")
static auto	desc_upload_ftp_failed = _u8L("Failed to upload print file via FTP. Please check the network status and try again.")
static auto	sending_over_lan_str = _u8L("Sending print job over LAN")
static auto	sending_over_cloud_str = _u8L("Sending print job through cloud service")
static wxString	wait_sending_finish = _L("Print task sending times out.")
static auto	check_gcode_failed_str = _u8L("Abnormal print file data: please slice again.")
static auto	printjob_cancel_str = _u8L("Task canceled.")
static auto	timeout_to_upload_str = _u8L("Upload task timed out. Please check the network status and try again.")
static auto	failed_in_cloud_service_str = _u8L("Cloud service connection failed. Please try again.")
static auto	file_is_not_exists_str = _u8L("Print file not found; please slice again.")
static auto	file_over_size_str = _u8L("The print file exceeds the maximum allowable size (1GB). Please simplify the model and slice again.")
static auto	print_canceled_str = _u8L("Task canceled.")
static auto	send_print_failed_str = _u8L("Failed to send the print job. Please try again.")
static auto	upload_ftp_failed_str = _u8L("Failed to upload file to ftp. Please try again.")
static auto	desc_network_error = _u8L("Check the current status of the Bambu Lab server by clicking on the link above.")
static auto	desc_file_too_large = _u8L("The size of the print file is too large. Please adjust the file size and try again.")
static auto	desc_fail_not_exist = _u8L("Print file not found; please slice it again and send it for printing.")
static auto	desc_upload_ftp_failed = _u8L("Failed to upload print file via FTP. Please check the network status and try again.")
static auto	sending_over_lan_str = _u8L("Sending print job over LAN")
static auto	sending_over_cloud_str = _u8L("Sending print job through cloud service")
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 = "\t"
static constexpr int	MAX_COMPONENTS = 3
static constexpr int	MIN_COMPONENT_RATIO = 10
static wxString	NA_STR = _L("N/A")
BitmapCache *	m_bitmap_cache = nullptr
static constexpr char	LayerRootIcon [] = "height_range_modifier"
static constexpr char	LayerIcon [] = "height_range_layer"
static constexpr char	WarningIcon [] = "obj_warning"
static constexpr char	WarningManifoldIcon [] = "obj_warning"
static constexpr char	LockIcon [] = "cut_"
const std::map< InfoItemType, InfoItemAtributes >	INFO_ITEMS
constexpr int	titleWidth = 20
constexpr int	ctrlWidth = 50
static const char *const	SCENE_CANVAS_NAME = "OrcaSceneCanvas"
static constexpr float	IMEX_GHOST_ALPHA = 0.55f
StateColor	percent_bg (std::pair< wxColour, int >(wxColour(255, 255, 255), StateColor::Disabled), std::pair< wxColour, int >(wxColour(255, 255, 255), StateColor::Pressed), std::pair< wxColour, int >(wxColour(255, 255, 255), StateColor::Hovered), std::pair< wxColour, int >(wxColour(255, 255, 255), StateColor::Enabled), std::pair< wxColour, int >(wxColour(255, 255, 255), StateColor::Normal))
static StateColor	zoom_bg (std::pair< wxColour, int >(wxColour(255, 255, 255), StateColor::Disabled), std::pair< wxColour, int >(wxColour(206, 206, 206), StateColor::Pressed), std::pair< wxColour, int >(wxColour(238, 238, 238), StateColor::Hovered), std::pair< wxColour, int >(wxColour(255, 255, 255), StateColor::Enabled), std::pair< wxColour, int >(wxColour(255, 255, 255), StateColor::Normal))
static StateColor	zoom_bd (std::pair< wxColour, int >(wxColour(144, 144, 144), StateColor::Disabled), std::pair< wxColour, int >(wxColour(38, 46, 48), StateColor::Enabled))
static StateColor	zoom_text (std::pair< wxColour, int >(wxColour(144, 144, 144), StateColor::Disabled), std::pair< wxColour, int >(wxColour(38, 46, 48), StateColor::Enabled))
static std::map< BedType, std::string >	bed_type_thumbnails
static wxString	temp_dir
static DynamicFilamentList	dynamic_filament_list
static DynamicFilamentList	dynamic_physical_filament_list (true)
static std::map< std::string, std::string >	printer_thumbnails = {}
constexpr int	kSidebarContextMenuFilamentId = -2
const wxString	DEFAULT_PROJECT_NAME = L("Untitled")
static constexpr int	MIN_LAYER_VALUE = 2
static constexpr int	MAX_LAYER_VALUE = INT_MAX - 1
static const char *	CONFIG_KEY_PATH = "printhost_path"
static const char *	CONFIG_KEY_GROUP = "printhost_group"
static const char *	CONFIG_KEY_STORAGE = "printhost_storage"
static StateColor	btn_bg_green (std::pair< wxColour, int >(wxColour(206, 206, 206), StateColor::Disabled), std::pair< wxColour, int >(wxColour(0, 137, 123), StateColor::Pressed), std::pair< wxColour, int >(wxColour(38, 166, 154), StateColor::Hovered), std::pair< wxColour, int >(wxColour(0, 150, 136), StateColor::Normal))
static const wxColour	BgNormalColor = wxColour("#FFFFFF")
static const wxColour	BgSelectColor = wxColour("#E5F0EE")
static const wxColour	BorderNormalColor = wxColour("#CECECE")
static const wxColour	BorderSelectedColor = wxColour("#009688")
static const wxColour	TextNormalBlackColor = wxColour("#262E30")
static const wxColour	TextNormalGreyColor = wxColour("#6B6B6B")
static StateColor	btn_bg_green (std::pair< wxColour, int >(wxColour(194, 194, 194), StateColor::Disabled), std::pair< wxColour, int >(wxColour(27, 136, 68), StateColor::Pressed), std::pair< wxColour, int >(wxColour(61, 203, 115), StateColor::Hovered), std::pair< wxColour, int >(wxColour(0, 177, 66), StateColor::Normal))
static wxString	task_canceled_text = _L("Task canceled")
static int	s_nozzle_mapping_last_request_time = 0
static const std::string	SEND_SYSTEM_INFO_DOMAIN = "bambu-lab.com"
static const std::string	SEND_SYSTEM_INFO_URL = "https://files." + SEND_SYSTEM_INFO_DOMAIN + "/wp-json/v1/ps"
constexpr int	timeout_period = 200000
static const std::map< int, std::string >	error_messages
static const wxString	NA_STR = _L("N/A")
static const wxString	TEMP_BLANK_STR = wxString("_")
static const wxFont	SWITCH_FONT = Label::Body_10
static const int	bed_temp_range [2] = {20, 120}
static const int	default_champer_temp_min = 20
static const int	default_champer_temp_max = 60
static const wxColour	STATUS_PANEL_BG = wxColour(238, 238, 238)
static const wxColour	STATUS_TITLE_BG = wxColour(248, 248, 248)
static const wxColour	STATIC_BOX_LINE_COL = wxColour(238, 238, 238)
static const wxColour	BUTTON_NORMAL1_COL = wxColour(238, 238, 238)
static const wxColour	BUTTON_NORMAL2_COL = wxColour(206, 206, 206)
static const wxColour	BUTTON_PRESS_COL = wxColour(172, 172, 172)
static const wxColour	BUTTON_HOVER_COL = wxColour(0, 150, 136)
static const wxColour	DISCONNECT_TEXT_COL = wxColour(171, 172, 172)
static const wxColour	NORMAL_TEXT_COL = wxColour(48,58,60)
static const wxColour	NORMAL_FAN_TEXT_COL = wxColour(107, 107, 107)
static const wxColour	WARNING_INFO_BG_COL = wxColour(255, 111, 0)
static const wxColour	STAGE_TEXT_COL = wxColour(0, 150, 136)
static const wxColour	GROUP_STATIC_LINE_COL = wxColour(206, 206, 206)
static const wxFont	PAGE_TITLE_FONT = Label::Body_14
static wxColour	PAGE_TITLE_FONT_COL = wxColour(107, 107, 107)
static wxColour	GROUP_TITLE_FONT_COL = wxColour(172, 172, 172)
static wxColour	TEXT_LIGHT_FONT_COL = wxColour(107, 107, 107)
static wxImage	fail_image
constexpr double	UP_LIMIT = 0.9
static const std::vector< std::string >	plate_keys = { "curr_bed_type", "skirt_start_angle", "first_layer_print_sequence", "first_layer_sequence_choice", "other_layers_print_sequence", "other_layers_sequence_choice", "print_sequence", "spiral_mode"}
static std::pair< std::string, std::string >	extruder_variant_keys []
static std::string	layer_height = "layer_height"
static std::unordered_set< std::string >	s_filament_temp_pair_warning_suppressed_for_session
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 = "%1%"
static const char *	URL_DOWNLOAD = "%1%"
static const char *	URL_DEV = "%1%"
static const wxColour	TEXT_NORMAL_CLR = wxColour(0, 150, 136)
static const wxColour	TEXT_FAILED_CLR = wxColour(255, 111, 0)
static const std::unordered_map< wxString, wxString >	ACCESSORY_DISPLAY_STR
static const char *const	kCloudUrl = "https://cloud.orcaslicer.com"
static const int	kLeftNavWidth = 220 + 1
static const wxColour	AMS_TRAY_DEFAULT_COL = wxColour(255, 255, 255)
constexpr int	time_out = 6
static bool	not_show_fan_speed_warning_dlg = false
static const int	LeftExtruderIdx = 0
static const int	RightExtruderIdx = 1
static bool	s_nozzle_stats_from_machine = false
const double	MIN_PA_K_VALUE = 0.0
const double	MAX_PA_K_VALUE = 2.0
static const std::string	gcode_filename = "temp.gcode"
static const std::string	model_filename = "test.3mf"
static const std::string	config_filename = "test_config.3mf"
static std::string	MachineBedTypeString [7]
static wxString	nozzle_not_set_text = _L("The printer nozzle information has not been set.\nPlease configure it before proceeding with the calibration.")
static wxString	nozzle_volume_type_not_match_text = _L("The nozzle type does not match the actual printer nozzle type.\nPlease click the Sync button above and restart the calibration.")
std::vector< std::string >	not_support_auto_pa_cali_filaments
NSTextField *	mainframe_text_field = nil
bool	is_in_full_screen_mode = false

---

Class Documentation

Slic3r::GUI::AppActionId

struct Slic3r::GUI::AppActionId

Collaboration diagram for Slic3r::GUI::AppActionId:

Class Members
string	id

Slic3r::GUI::DryingPreset

struct Slic3r::GUI::DryingPreset

Class Members
DryCtrDev	dev
int	dry_temp
int	dry_time
DryCtrState	state

Slic3r::GUI::TrayData

struct Slic3r::GUI::TrayData

Collaboration diagram for Slic3r::GUI::TrayData:

Class Members
int	ams_id = 0
wxColour	colour
int	ctype = 0
string	filament_type
int	id
vector< wxColour >	material_cols = std::vector<wxColour>()
string	name
int	remain = MAPPING_ITEM_INVALID_REMAIN
int	slot_id = 0
TrayType	type

Slic3r::GUI::AuFiles

class Slic3r::GUI::AuFiles

Collaboration diagram for Slic3r::GUI::AuFiles:

Class Members
AuFile *	file
wxString	path

Slic3r::GUI::MemoryStruct

struct Slic3r::GUI::MemoryStruct

Class Members
char *	memory
size_t	read_pos
size_t	size

Slic3r::GUI::CadInteractionState

struct Slic3r::GUI::CadInteractionState

Class Members
bool	gesture_active {false}
bool	has_selection {false}
bool	tool_armed {false}
bool	value_field_open {false}

Slic3r::GUI::OfferVerb

struct Slic3r::GUI::OfferVerb

Class Members
uint32_t	accepts
const char *	action
const char *	family
const char *	hint
const char *	icon
const char *	id
const char *	key
const char *	name
int	need_bodies
bool	need_sheet
int	need_sketches
const char *	refusal
int	row
bool	sketch_mode

Slic3r::GUI::DpToken

struct Slic3r::GUI::DpToken

Class Members
wxColour	dark
wxColour	light

Slic3r::GUI::PlanePiece

struct Slic3r::GUI::PlanePiece

Collaboration diagram for Slic3r::GUI::PlanePiece:

Class Members
vector< Vec3d >	corners
int	plane

Slic3r::GUI::MPanel

class Slic3r::GUI::MPanel

Collaboration diagram for Slic3r::GUI::MPanel:

Class Members
wxString	mIndex
MObjectPanel *	mPanel

Slic3r::GUI::TrayInfo

struct Slic3r::GUI::TrayInfo

Collaboration diagram for Slic3r::GUI::TrayInfo:

Class Members
int	extruder_id
NozzleVolumeType	nozzle_volume_type
Preset *	preset

Slic3r::GUI::ConfigIndexValue

struct Slic3r::GUI::ConfigIndexValue

Class Members
int	index {0}
float	value {0}

Slic3r::GUI::DecomposeComponent

struct Slic3r::GUI::DecomposeComponent

Class Members
DecomposeBaseColor	base_color {DecomposeBaseColor::None}
wxColour	colour
int	filament_index {-1}
int	ratio {50}

Slic3r::GUI::ColorDecomposeResult

struct Slic3r::GUI::ColorDecomposeResult

Collaboration diagram for Slic3r::GUI::ColorDecomposeResult:

Class Members
vector< DecomposeComponent >	components
wxColour	matched_color
DecomposeMode	mode {DecomposeMode::MaterialList}

Slic3r::GUI::DecomposeOfficialComponent

struct Slic3r::GUI::DecomposeOfficialComponent

Collaboration diagram for Slic3r::GUI::DecomposeOfficialComponent:

Class Members
DecomposeBaseColor	base_color {DecomposeBaseColor::None}
string	color_hex
string	filament_id

Slic3r::GUI::DecomposeMissingComponent

struct Slic3r::GUI::DecomposeMissingComponent

Collaboration diagram for Slic3r::GUI::DecomposeMissingComponent:

Class Members
size_t	component_idx {0}
wxString	display_name
DecomposeOfficialComponent	official_component
string	preset_name

Slic3r::GUI::ColorPickerOptions

struct Slic3r::GUI::ColorPickerOptions

Class Members
bool	allow_alpha = false
bool	allow_gradient = false

Slic3r::GUI::FilamentColorPickerValue

struct Slic3r::GUI::FilamentColorPickerValue

Collaboration diagram for Slic3r::GUI::FilamentColorPickerValue:

Class Members
vector< string >	colors
bool	gradient = false
string	primary

Slic3r::GUI::DailyTipsData

struct Slic3r::GUI::DailyTipsData

Collaboration diagram for Slic3r::GUI::DailyTipsData:

Class Members
string	additional_text
string	hyper_text
function< void(void)>	hypertext_callback
string	img_url
string	main_text
string	wiki_url

Slic3r::GUI::DataAmsSlotInfo

struct Slic3r::GUI::DataAmsSlotInfo

Collaboration diagram for Slic3r::GUI::DataAmsSlotInfo:

Class Members
wxString	amsName
double	colourFactor
vector< wxColour >	colours
wxString	name
double	scaleFactor
DataStatusType	status

Slic3r::GUI::DataStatusParam

struct Slic3r::GUI::DataStatusParam

Collaboration diagram for Slic3r::GUI::DataStatusParam:

Class Members
int	height = 0
vector< DataAmsSlotInfo >	slots
int	width = 0

Slic3r::GUI::uiAmsHumidityInfo

struct Slic3r::GUI::uiAmsHumidityInfo

Collaboration diagram for Slic3r::GUI::uiAmsHumidityInfo:

Class Members
string	ams_id
AMSModel	ams_type
float	current_temperature
int	humidity_display_idx = -1
int	humidity_percent = -1
int	left_dry_time = -1

Slic3r::GUI::CustomData

struct Slic3r::GUI::CustomData

Class Members
unsigned char	a
unsigned char	b
int	filament_id
unsigned char	g
unsigned char	r
char	type[64]

Slic3r::GUI::wxEventFunctorRef

struct Slic3r::GUI::wxEventFunctorRef

Class Members
wxEventFunctor *	func

Slic3r::GUI::TriPoint

struct Slic3r::GUI::TriPoint

Class Members
double	x
double	y

Slic3r::GUI::MixedGradientCurve

struct Slic3r::GUI::MixedGradientCurve

Collaboration diagram for Slic3r::GUI::MixedGradientCurve:

Class Members
wxColour	colour
vector< wxPoint2DDouble >	points
int	stroke_dip

Slic3r::GUI::MixedGradientTheme

struct Slic3r::GUI::MixedGradientTheme

Class Members
wxColour	axis
wxColour	background
wxColour	grid
wxColour	label
wxColour	label_strong
wxColour	outline
wxColour	point_fill

Slic3r::GUI::MixedTriangleTheme

struct Slic3r::GUI::MixedTriangleTheme

Class Members
wxColour	background
wxColour	label
wxColour	outline
wxColour	ring

Slic3r::GUI::Texture

struct Slic3r::GUI::Texture

Class Members
unsigned	height {0}
unsigned	id {0}
unsigned	width {0}

Slic3r::GUI::BackgroundTexture

struct Slic3r::GUI::BackgroundTexture

Collaboration diagram for Slic3r::GUI::BackgroundTexture:

Class Members
Metadata	metadata
GLTexture	texture

Slic3r::GUI::FileWildcards

struct Slic3r::GUI::FileWildcards

Collaboration diagram for Slic3r::GUI::FileWildcards:

Class Members
vector< string_view >	file_extensions
const char *	title_id

Slic3r::GUI::SimpleSettingData

struct Slic3r::GUI::SimpleSettingData

Collaboration diagram for Slic3r::GUI::SimpleSettingData:

Class Members
string	label
string	name
int	priority

Slic3r::GUI::GUI_InitParams

struct Slic3r::GUI::GUI_InitParams

Collaboration diagram for Slic3r::GUI::GUI_InitParams:

Class Members
int	argc
char **	argv
DynamicPrintConfig	extra_config
vector< string >	input_files
bool	input_gcode { false }
vector< string >	load_configs
bool	opengl_compatibility_profile { false }
bool	opengl_debug { false }
pair< int, int >	opengl_version { 0, 0 }
PresetsConfigSubstitutions	preset_substitutions

Slic3r::GUI::ObjectVolumeID

struct Slic3r::GUI::ObjectVolumeID

Collaboration diagram for Slic3r::GUI::ObjectVolumeID:

Class Members
ModelObject *	object { nullptr }
ModelVolume *	volume { nullptr }

Slic3r::GUI::MeshErrorsInfo

struct Slic3r::GUI::MeshErrorsInfo

Collaboration diagram for Slic3r::GUI::MeshErrorsInfo:

Class Members
wxString	tooltip
string	warning_icon_name

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
string	image_url
bool	runtime_disable
string	text
bool	was_displayed
size_t	weight

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
Vec2i32	size
string	text
GLuint	texture_id
GLenum	type = GL_UNSIGNED_BYTE

Slic3r::GUI::OAuthParams

struct Slic3r::GUI::OAuthParams

Collaboration diagram for Slic3r::GUI::OAuthParams:

Class Members
string	auth_fail_redirect_url
string	auth_success_redirect_url
port_type	callback_port
string	callback_url
string	client_id
string	login_url
string	response_type
string	scope
string	state
string	token_url
string	verification_code

Slic3r::GUI::OAuthResult

struct Slic3r::GUI::OAuthResult

Collaboration diagram for Slic3r::GUI::OAuthResult:

Class Members
string	access_token {""}
string	error_message {""}
string	refresh_token {""}
bool	success {false}

Slic3r::GUI::OAuthData

struct Slic3r::GUI::OAuthData

Collaboration diagram for Slic3r::GUI::OAuthData:

Class Members
OAuthParams	params
shared_ptr< OAuthResult >	result

Slic3r::GUI::PlateListData

class Slic3r::GUI::PlateListData

Class Members
BedType	bed_type = BedType::btDefault
int	cur_plate_index = 0
bool	is_valid = false
int	plate_count = 0

Slic3r::GUI::TextureDisplacementBakeVolume

struct Slic3r::GUI::TextureDisplacementBakeVolume

Collaboration diagram for Slic3r::GUI::TextureDisplacementBakeVolume:

Class Members
indexed_triangle_set	base_mesh
TextureDisplacementFacetsData	facets_data
vector< TextureDisplacementLayer >	layers
vector< Vec2f >	model_uv
TextureDisplacementOptions	options
float	resting_drop = 0.f
Vec3d	texture_anchor = Vec3d::Zero()
ObjectID	volume_id
Transform3d	volume_to_world = Transform3d::Identity()

Slic3r::GUI::TextureDisplacementBakeInput

struct Slic3r::GUI::TextureDisplacementBakeInput

Collaboration diagram for Slic3r::GUI::TextureDisplacementBakeInput:

Class Members
TextureColorSettings	color
bool	take_snapshot = true
vector< TextureDisplacementBakeVolume >	volumes

Slic3r::GUI::TextureDisplacementDebugInput

struct Slic3r::GUI::TextureDisplacementDebugInput

Collaboration diagram for Slic3r::GUI::TextureDisplacementDebugInput:

Class Members
indexed_triangle_set	base_mesh
bool	check_topology = true
TextureColorSettings	color
TextureDisplacementFacetsData	facets_data
vector< TextureDisplacementLayer >	layers
size_t	mesh_cap = 4'000'000
vector< Vec2f >	model_uv
TextureDisplacementOptions	options
TextureDisplacementPrepareParams	prepare_params
Transform3d	prepare_texture_frame = Transform3d::Identity()
float	resting_drop = 0.f
bool	run_prepare = true
ObjectID	volume_id
Transform3d	volume_to_world = Transform3d::Identity()

Slic3r::GUI::TextureDisplacementPrepareVolume

struct Slic3r::GUI::TextureDisplacementPrepareVolume

Collaboration diagram for Slic3r::GUI::TextureDisplacementPrepareVolume:

Class Members
indexed_triangle_set	base_mesh
vector< TextureDisplacementLayer >	layers
TextureDisplacementFacetsData	masks
vector< Vec2f >	model_uv
Transform3d	texture_frame = Transform3d::Identity()
ObjectID	volume_id

Slic3r::GUI::TextureDisplacementPrepareInput

struct Slic3r::GUI::TextureDisplacementPrepareInput

Collaboration diagram for Slic3r::GUI::TextureDisplacementPrepareInput:

Class Members
TextureColorSettings	color
TextureDisplacementPrepareParams	params
string	snapshot_name
vector< TextureDisplacementPrepareVolume >	volumes

Slic3r::GUI::TextureDisplacementPreviewVolume

struct Slic3r::GUI::TextureDisplacementPreviewVolume

Collaboration diagram for Slic3r::GUI::TextureDisplacementPreviewVolume:

Class Members
indexed_triangle_set	base_mesh
TextureDisplacementFacetsData	facets_data
vector< TextureDisplacementLayer >	layers
vector< Vec2f >	model_uv
TextureDisplacementOptions	options
float	resting_drop = 0.f
Vec3d	texture_anchor = Vec3d::Zero()
Transform3d	volume_to_world = Transform3d::Identity()

Slic3r::GUI::TextureDisplacementPreviewInput

struct Slic3r::GUI::TextureDisplacementPreviewInput

Collaboration diagram for Slic3r::GUI::TextureDisplacementPreviewInput:

Class Members
TextureColorSettings	color
vector< TextureDisplacementPreviewVolume >	volumes

Slic3r::GUI::TextureDisplacementPreviewResult

struct Slic3r::GUI::TextureDisplacementPreviewResult

Collaboration diagram for Slic3r::GUI::TextureDisplacementPreviewResult:

Class Members
indexed_triangle_set	mesh
vector< uint8_t >	triangle_color

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::PresetTab

struct Slic3r::GUI::PresetTab

Collaboration diagram for Slic3r::GUI::PresetTab:

Class Members
string	name
Tab *	panel
PrinterTechnology	technology

Slic3r::GUI::MixedFilamentResult

struct Slic3r::GUI::MixedFilamentResult

Collaboration diagram for Slic3r::GUI::MixedFilamentResult:

Class Members
vector< unsigned int >	components
vector< GradientAnchor >	gradient_curve
int	gradient_direction = 0
bool	gradient_enabled = false
bool	per_part_gradient = false
vector< int >	ratios

Slic3r::GUI::ButtonData

struct Slic3r::GUI::ButtonData

Collaboration diagram for Slic3r::GUI::ButtonData:

Class Members
Button *	button
ButtonSizeType	type

Slic3r::GUI::MsgButton

class Slic3r::GUI::MsgButton

Collaboration diagram for Slic3r::GUI::MsgButton:

Class Members
ButtonData *	buttondata
wxString	id

Slic3r::GUI::FilamentWarningInfo

struct Slic3r::GUI::FilamentWarningInfo

Class Members
wxString	info_msg
wxString	wiki_url

Slic3r::GUI::ObjState

struct Slic3r::GUI::ObjState

Collaboration diagram for Slic3r::GUI::ObjState:

Class Members
string	dev_id
string	state_dev_name
int	state_device { 0 }

Slic3r::GUI::NativeCommand

struct Slic3r::GUI::NativeCommand

Collaboration diagram for Slic3r::GUI::NativeCommand:

Class Members
string	group
string	icon
string	input
string	key
function< AppActionRunResult(const string &param)>	runner
string	title

Slic3r::GUI::JumpTo

struct Slic3r::GUI::JumpTo

Collaboration diagram for Slic3r::GUI::JumpTo:

Class Members
string	opt
Type	opt_type
string	text

Slic3r::GUI::InfoItemAtributes

struct Slic3r::GUI::InfoItemAtributes

Collaboration diagram for Slic3r::GUI::InfoItemAtributes:

Class Members
string	bmp_name
string	name

Slic3r::GUI::ExclusionVolumePrismPreview

struct Slic3r::GUI::ExclusionVolumePrismPreview

Collaboration diagram for Slic3r::GUI::ExclusionVolumePrismPreview:

Class Members
Polygon	footprint
double	z_max { 0.0 }
double	z_min { 0.0 }

Slic3r::GUI::WipeTowerRelocation

struct Slic3r::GUI::WipeTowerRelocation

Class Members
bool	moved = false
bool	overlaps_objects = false

Slic3r::GUI::project_file

struct Slic3r::GUI::project_file

Collaboration diagram for Slic3r::GUI::project_file:

Class Members
string	filename
string	filepath
string	size

Slic3r::GUI::PublishMaterialIdentity

struct Slic3r::GUI::PublishMaterialIdentity

Collaboration diagram for Slic3r::GUI::PublishMaterialIdentity:

Class Members
string	id
string	type
string	vendor

Slic3r::GUI::FrameTimeStats

struct Slic3r::GUI::FrameTimeStats

Class Members
double	average_ms { 0.0 }
double	fps { 0.0 }
double	max_ms { 0.0 }
double	median_ms { 0.0 }
double	p95_ms { 0.0 }
double	p99_ms { 0.0 }

Slic3r::GUI::Material

class Slic3r::GUI::Material

Collaboration diagram for Slic3r::GUI::Material:

Class Members
int	id
MaterialItem *	item

Slic3r::GUI::MachinePanel

class Slic3r::GUI::MachinePanel

Collaboration diagram for Slic3r::GUI::MachinePanel:

Class Members
wxString	mIndex
MachineObjectPanel *	mPanel

Slic3r::GUI::AmsRadioSelector

class Slic3r::GUI::AmsRadioSelector

Collaboration diagram for Slic3r::GUI::AmsRadioSelector:

Class Members
int	m_groupid
wxString	m_param_name
RadioBox *	m_radiobox
bool	m_selected = false

Slic3r::GUI::SequentialClearanceInstance

struct Slic3r::GUI::SequentialClearanceInstance

Collaboration diagram for Slic3r::GUI::SequentialClearanceInstance:

Class Members
BoundingBox	bounding_box
Polygon	hull_polygon
double	instance_height
ObjectID	instance_id

Slic3r::GUI::ShortcutInfo

struct Slic3r::GUI::ShortcutInfo

Collaboration diagram for Slic3r::GUI::ShortcutInfo:

Class Members
uint8_t	contexts
KeyChord	default_chord
Shortcut	id
const char *	key
bool	modifier_variants
const char *	name
bool	repeatable

Slic3r::GUI::ObjectInfo

struct Slic3r::GUI::ObjectInfo

Collaboration diagram for Slic3r::GUI::ObjectInfo:

Class Members
int	identify_id {-1}
string	name {""}
PartState	state {psUnCheck}

Slic3r::GUI::PlateInfo

struct Slic3r::GUI::PlateInfo

Collaboration diagram for Slic3r::GUI::PlateInfo:

Class Members
int	index {-1}
bool	label_object_enabled = false
vector< ObjectInfo >	objects

Slic3r::GUI::ScoreData

struct Slic3r::GUI::ScoreData

Collaboration diagram for Slic3r::GUI::ScoreData:

Class Members
wxString	comment_text
int	design_id
vector< string >	image_url_paths
vector< pair< wxString, string > >	local_to_url_image
string	model_id
set< wxString >	need_upload_images
int	profile_id
int	rating_id
int	star_count
bool	success_printed

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
optional< float >	start_distance
Transform3d	world

Slic3r::GUI::TextureFilamentEntry

struct Slic3r::GUI::TextureFilamentEntry

Collaboration diagram for Slic3r::GUI::TextureFilamentEntry:

Class Members
string	color_hex
int	dialog_index {-1}
TextureFilamentKind	kind {TextureFilamentKind::ExistingPhysical}
vector< unsigned int >	mixed_components
vector< int >	mixed_ratios
string	name
string	preset_name
size_t	project_config_index {size_t(-1)}
string	type

Slic3r::GUI::TextureNewMixedFilament

struct Slic3r::GUI::TextureNewMixedFilament

Collaboration diagram for Slic3r::GUI::TextureNewMixedFilament:

Class Members
string	color_hex
vector< int >	component_dialog_indices
int	dialog_index {-1}
vector< int >	ratios

Slic3r::GUI::FilamentMappingRow

struct Slic3r::GUI::FilamentMappingRow

Collaboration diagram for Slic3r::GUI::FilamentMappingRow:

Class Members
int	cluster_id = -1
array< size_t, 3 >	source_color = {0, 0, 0}
string	source_hex
wxPanel *	source_panel = nullptr
int	target_filament_idx = 0
wxPanel *	target_panel = nullptr

Slic3r::GUI::TextureLibraryEntry

struct Slic3r::GUI::TextureLibraryEntry

Collaboration diagram for Slic3r::GUI::TextureLibraryEntry:

Class Members
string	name
string	pack_name
string	path
TextureSource	source

Slic3r::GUI::PresetItem

struct Slic3r::GUI::PresetItem

Collaboration diagram for Slic3r::GUI::PresetItem:

Class Members
wxString	category_name
wxString	group_name
wxString	new_value
wxString	old_value
string	opt_key
wxString	option_name
Type	type

Slic3r::GUI::RotateOffSet

struct Slic3r::GUI::RotateOffSet

Class Members
wxPoint	offset
float	rotate

Slic3r::GUI::NozzleOption

struct Slic3r::GUI::NozzleOption

Collaboration diagram for Slic3r::GUI::NozzleOption:

Class Members
string	diameter
unordered_map< int, pair< NozzleVolumeType, int > >	extruder_nozzle_stats

Slic3r::GUI::CalibInfo

class Slic3r::GUI::CalibInfo

Collaboration diagram for Slic3r::GUI::CalibInfo:

Class Members
int	ams_id = 0
BedType	bed_type
string	dev_id
int	extruder_id = 0
ExtruderType	extruder_type {ExtruderType::etDirectDrive}
string	filament_color
Preset *	filament_prest
int	index = -1
float	nozzle_diameter = 0.0f
NozzleVolumeType	nozzle_volume_type
Calib_Params	params
Preset *	print_prest
Preset *	printer_prest
shared_ptr< ProgressIndicator >	process_bar
string	select_ams
int	slot_id = 0

Typedef Documentation

ArrangePolygon

using Slic3r::GUI::ArrangePolygon = arrangement::ArrangePolygon

CancelFn

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

choice_ctrl

using Slic3r::GUI::choice_ctrl = ::ComboBox

ColorEvent

using Slic3r::GUI::ColorEvent = Event<wxColour>

ColorGradient

using Slic3r::GUI::ColorGradient = std::vector<ColorRGBA>

ColorSelection

using Slic3r::GUI::ColorSelection = std::variant<ColorRGBA, ColorGradient>

column_t

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

ConfigOptionsGroupShp

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

ConfigOptionsGroupWkp

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

Coord

using Slic3r::GUI::Coord = float

coordf_t

typedef double Slic3r::GUI::coordf_t

DecomposeMode

using Slic3r::GUI::DecomposeMode = ColorDecomposeRecipeMode

DPIFrame

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

EjectDriveNotificationClickedEvent

using Slic3r::GUI::EjectDriveNotificationClickedEvent = SimpleEvent

ExportGcodeNotificationClickedEvent

using Slic3r::GUI::ExportGcodeNotificationClickedEvent = SimpleEvent

FilamentComboBoxList

typedef std::vector<FilamentComboBox*> Slic3r::GUI::FilamentComboBoxList

FloatPoint

using Slic3r::GUI::FloatPoint = std::array<Coord, 2>

FullSettingsHierarchy

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

GCodeResult

using Slic3r::GUI::GCodeResult = GCodeProcessorResult

HeightProfileSmoothEvent

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

InstallProgressFn

typedef std::function<void(int status, int percent, bool& cancel)> Slic3r::GUI::InstallProgressFn

InstanceGoToFrontEvent

using Slic3r::GUI::InstanceGoToFrontEvent = SimpleEvent

LoadFromOtherInstanceEvent

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

MaterialHash

using Slic3r::GUI::MaterialHash = std::map<int, Material *>

ModelFilter

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

ModelNodePtrArray

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

ObjectSettingEvent

typedef Event<ObjectVolumeID> Slic3r::GUI::ObjectSettingEvent

OnGetSubTaskFn

typedef std::function<void(BBLModelTask* subtask)> Slic3r::GUI::OnGetSubTaskFn

OnUpdateStatusFn

typedef std::function<void(int status, int code, std::string msg)> Slic3r::GUI::OnUpdateStatusFn

Pages3rdparty

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

PageShp

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

ParamsNodePtrArray

using Slic3r::GUI::ParamsNodePtrArray = std::vector<std::unique_ptr<ParamsNode>>

PartsInfo

typedef std::vector<std::pair<int, PartState> > Slic3r::GUI::PartsInfo

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 = SimpleEvent

PrinterConfigUpdateAvailableClickedEvent

using Slic3r::GUI::PrinterConfigUpdateAvailableClickedEvent = SimpleEvent

RBtnEvent

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

RBtnPlateEvent

using Slic3r::GUI::RBtnPlateEvent = Event<std::pair<Vec2d, int>>

RemovableDriveEjectEvent

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

RemovableDrivesChangedEvent

using Slic3r::GUI::RemovableDrivesChangedEvent = SimpleEvent

StartDownloadOtherInstanceEvent

using Slic3r::GUI::StartDownloadOtherInstanceEvent = 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 = std::function<void(const std::string&)>

t_change

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

t_field

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

t_kill_focus

using Slic3r::GUI::t_kill_focus = 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 = std::map< std::string, std::pair<std::string, int> >

t_optionfield_map

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

Vec3dsEvent

template<size_t N>

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

WasCancelledFn

typedef std::function<bool()> Slic3r::GUI::WasCancelledFn

widget_t

using Slic3r::GUI::widget_t = 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

{ DPI_DEFAULT = 96 };

Action

enum class Slic3r::GUI::Action

strong

Enumerator
Undef
Transfer
Discard
Save

                  {
    Undef,
    Transfer,
    Discard,
    Save
};

ActionButton

enum Slic3r::GUI::ActionButton

Enumerator
ACTION_BTN_CALI
ACTION_BTN_LOAD
ACTION_BTN_UNLOAD
ACTION_BTN_COUNT

                  {
    ACTION_BTN_CALI     = 0,
    ACTION_BTN_LOAD     = 1,
    ACTION_BTN_UNLOAD   = 2,
    ACTION_BTN_COUNT    = 3
};

ActionButtons

enum Slic3r::GUI::ActionButtons

Enumerator
TRANSFER
KEEP
SAVE
DONT_SAVE
REMEMBER_CHOISE

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

ActionButtonType

enum class Slic3r::GUI::ActionButtonType : int

strong

Enumerator
abReslice
abExport
abSendGCode

                            : int {
    abReslice,
    abExport,
    abSendGCode
};

ActionChange

enum class Slic3r::GUI::ActionChange

strong

Enumerator
Added
Removed

{ Added, Removed };

AMSAction

enum class Slic3r::GUI::AMSAction : int

strong

Enumerator
AMS_ACTION_NONE
AMS_ACTION_LOAD
AMS_ACTION_UNLOAD
AMS_ACTION_CALI
AMS_ACTION_PRINTING
AMS_ACTION_NORMAL
AMS_ACTION_NOAMS

                     : int {
    AMS_ACTION_NONE,
    AMS_ACTION_LOAD,
    AMS_ACTION_UNLOAD,
    AMS_ACTION_CALI,
    AMS_ACTION_PRINTING,
    AMS_ACTION_NORMAL,
    AMS_ACTION_NOAMS,
};

AMSCanType

enum class Slic3r::GUI::AMSCanType : int

strong

Enumerator
AMS_CAN_TYPE_NONE
AMS_CAN_TYPE_BRAND
AMS_CAN_TYPE_THIRDBRAND
AMS_CAN_TYPE_EMPTY
AMS_CAN_TYPE_VIRTUAL

                      : int {
    AMS_CAN_TYPE_NONE,
    AMS_CAN_TYPE_BRAND,
    AMS_CAN_TYPE_THIRDBRAND,
    AMS_CAN_TYPE_EMPTY,
    AMS_CAN_TYPE_VIRTUAL,
};

AMSModel

enum Slic3r::GUI::AMSModel

Enumerator
EXT_AMS
GENERIC_AMS
AMS_LITE
N3F_AMS
N3S_AMS

              {
    EXT_AMS             = 0,    //ext
    GENERIC_AMS         = 1,
    AMS_LITE            = 2,    //ams-lite
    N3F_AMS             = 3,
    N3S_AMS             = 4     //n3s  single_ams
};

AMSModelOriginType

enum Slic3r::GUI::AMSModelOriginType

Enumerator
GENERIC_EXT
LITE_EXT

                        {
    GENERIC_EXT,
    LITE_EXT
};

AMSPanelPos

enum class Slic3r::GUI::AMSPanelPos : int

strong

Enumerator
SINGLE_PANEL
LEFT_PANEL
RIGHT_PANEL

                       : int {
    SINGLE_PANEL,
    LEFT_PANEL,
    RIGHT_PANEL,
};

AMSPassRoadMode

enum class Slic3r::GUI::AMSPassRoadMode : int

strong

Enumerator
AMS_ROAD_MODE_NONE
AMS_ROAD_MODE_LEFT
AMS_ROAD_MODE_LEFT_RIGHT
AMS_ROAD_MODE_END_TOP
AMS_ROAD_MODE_END_RIGHT
AMS_ROAD_MODE_END_BOTTOM

                           : int {
    AMS_ROAD_MODE_NONE,
    AMS_ROAD_MODE_LEFT,
    AMS_ROAD_MODE_LEFT_RIGHT,
    AMS_ROAD_MODE_END_TOP,
    AMS_ROAD_MODE_END_RIGHT,
    AMS_ROAD_MODE_END_BOTTOM,
};

AMSPassRoadSTEP

enum class Slic3r::GUI::AMSPassRoadSTEP : int

strong

Enumerator
AMS_ROAD_STEP_NONE
AMS_ROAD_STEP_1
AMS_ROAD_STEP_2
AMS_ROAD_STEP_3
AMS_ROAD_STEP_COMBO_LOAD_STEP1
AMS_ROAD_STEP_COMBO_LOAD_STEP2
AMS_ROAD_STEP_COMBO_LOAD_STEP3

                           : int {
    AMS_ROAD_STEP_NONE = 0,
    AMS_ROAD_STEP_1 = 1, // lib -> extrusion
    AMS_ROAD_STEP_2 = 2, // extrusion->buffer
    AMS_ROAD_STEP_3 = 4, // extrusion
 
    AMS_ROAD_STEP_COMBO_LOAD_STEP1,
    AMS_ROAD_STEP_COMBO_LOAD_STEP2,
    AMS_ROAD_STEP_COMBO_LOAD_STEP3,
};

AMSPassRoadType

enum class Slic3r::GUI::AMSPassRoadType : int

strong

Enumerator
AMS_ROAD_TYPE_NONE
AMS_ROAD_TYPE_LOAD
AMS_ROAD_TYPE_UNLOAD

                           : int {
    AMS_ROAD_TYPE_NONE,
    AMS_ROAD_TYPE_LOAD,
    AMS_ROAD_TYPE_UNLOAD,
};

AMSRoadMode

enum class Slic3r::GUI::AMSRoadMode : int

strong

Enumerator
AMS_ROAD_MODE_LEFT
AMS_ROAD_MODE_LEFT_RIGHT
AMS_ROAD_MODE_END
AMS_ROAD_MODE_END_ONLY
AMS_ROAD_MODE_NONE
AMS_ROAD_MODE_NONE_ANY_ROAD
AMS_ROAD_MODE_VIRTUAL_TRAY

                       : int {
    AMS_ROAD_MODE_LEFT,
    AMS_ROAD_MODE_LEFT_RIGHT,
    AMS_ROAD_MODE_END,
    AMS_ROAD_MODE_END_ONLY,
    AMS_ROAD_MODE_NONE,
    AMS_ROAD_MODE_NONE_ANY_ROAD,
    AMS_ROAD_MODE_VIRTUAL_TRAY
};

AMSRoadShowMode

enum class Slic3r::GUI::AMSRoadShowMode : int

strong

Enumerator
AMS_ROAD_MODE_FOUR
AMS_ROAD_MODE_DOUBLE
AMS_ROAD_MODE_SINGLE
AMS_ROAD_MODE_SINGLE_N3S
AMS_ROAD_MODE_AMS_LITE
AMS_ROAD_MODE_NONE

                           : int {
    AMS_ROAD_MODE_FOUR,
    AMS_ROAD_MODE_DOUBLE,
    AMS_ROAD_MODE_SINGLE,
    AMS_ROAD_MODE_SINGLE_N3S,
    AMS_ROAD_MODE_AMS_LITE,
    AMS_ROAD_MODE_NONE
};

AppActionKind

enum class Slic3r::GUI::AppActionKind

strong

Enumerator
Plugin
Command

{ Plugin, Command };

AssemblyMode

enum class Slic3r::GUI::AssemblyMode : unsigned char

strong

Enumerator
FACE_FACE
POINT_POINT

                        : unsigned char {
    FACE_FACE,
    POINT_POINT,
};

CadLevel

enum class Slic3r::GUI::CadLevel : int

strong

Enumerator
Idle
Tool
Gesture
Transient

                    : int {
    Idle      = 0,   // nothing transient is up: Esc clears the selection
    Tool      = 1,   // a feature card / armed sketch tool / constrain session: Esc exits it
    Gesture   = 2,   // an uncommitted delta (entity being drawn, body being dragged): Esc reverts it
    Transient = 3,   // a value field or a popup menu: Esc closes just that
};

CalibKind

enum class Slic3r::GUI::CalibKind : int

strong

Enumerator
Temperature
MaxVolumetric
PressureAdvance
FlowRatio
Retraction
Cornering
InputShapingFreq
InputShapingDamp
VFA

{ 
    Temperature, 
    MaxVolumetric, 
    PressureAdvance, 
    FlowRatio, 
    Retraction,
    Cornering, 
    InputShapingFreq, 
    InputShapingDamp,
    VFA
};

CalibrationFilamentMode

enum Slic3r::GUI::CalibrationFilamentMode

Enumerator
CALI_MODEL_SINGLE
CALI_MODEL_MULITI

                             {
    /* calibration single filament at once */
    CALI_MODEL_SINGLE = 0,
    /* calibration multi filament at once */
    CALI_MODEL_MULITI,
};

CalibrationMethod

enum Slic3r::GUI::CalibrationMethod

Enumerator
CALI_METHOD_MANUAL
CALI_METHOD_AUTO
CALI_METHOD_NEW_AUTO
CALI_METHOD_NONE

                       {
    CALI_METHOD_MANUAL = 0,
    CALI_METHOD_AUTO,
    CALI_METHOD_NEW_AUTO,
    CALI_METHOD_NONE,
};

CalibrationStyle

enum class Slic3r::GUI::CalibrationStyle : int

strong

Enumerator
CALI_STYLE_DEFAULT
CALI_STYLE_X1
CALI_STYLE_P1P

{
    CALI_STYLE_DEFAULT = 0,
    CALI_STYLE_X1,
    CALI_STYLE_P1P,
};

CaliColumnType

enum Slic3r::GUI::CaliColumnType : int

Enumerator
Cali_Name
Cali_Filament
Cali_Nozzle_ID
Cali_Nozzle
Cali_K_Value
Cali_Delete
Cali_Edit
Cali_Type_Count

                    : int {
    Cali_Name = 0,
    Cali_Filament,
    Cali_Nozzle_ID,
    Cali_Nozzle,
    Cali_K_Value,
    Cali_Delete,
    Cali_Edit,
    Cali_Type_Count
};

CaliPageActionType

enum class Slic3r::GUI::CaliPageActionType : int

strong

Enumerator
CALI_ACTION_MANAGE_RESULT
CALI_ACTION_MANUAL_CALI
CALI_ACTION_AUTO_CALI
CALI_ACTION_START
CALI_ACTION_CALI
CALI_ACTION_FLOW_CALI_STAGE_2
CALI_ACTION_RECALI
CALI_ACTION_PREV
CALI_ACTION_NEXT
CALI_ACTION_CALI_NEXT
CALI_ACTION_PA_SAVE
CALI_ACTION_FLOW_SAVE
CALI_ACTION_FLOW_COARSE_SAVE
CALI_ACTION_FLOW_FINE_SAVE
CALI_ACTION_COMMON_SAVE
CALI_ACTION_GO_HOME
CALI_ACTION_COUNT

{
    CALI_ACTION_MANAGE_RESULT = 0,
    CALI_ACTION_MANUAL_CALI,
    CALI_ACTION_AUTO_CALI,
    CALI_ACTION_START,
    CALI_ACTION_CALI,
    CALI_ACTION_FLOW_CALI_STAGE_2,
    CALI_ACTION_RECALI,
    CALI_ACTION_PREV,
    CALI_ACTION_NEXT,
    CALI_ACTION_CALI_NEXT,
    CALI_ACTION_PA_SAVE,
    CALI_ACTION_FLOW_SAVE,
    CALI_ACTION_FLOW_COARSE_SAVE,
    CALI_ACTION_FLOW_FINE_SAVE,
    CALI_ACTION_COMMON_SAVE,
    CALI_ACTION_GO_HOME,
    CALI_ACTION_COUNT
};

CaliPageType

enum class Slic3r::GUI::CaliPageType

strong

Enumerator
CALI_PAGE_START
CALI_PAGE_PRESET
CALI_PAGE_CALI
CALI_PAGE_COARSE_SAVE
CALI_PAGE_FINE_CALI
CALI_PAGE_FINE_SAVE
CALI_PAGE_PA_SAVE
CALI_PAGE_FLOW_SAVE
CALI_PAGE_COMMON_SAVE

                        {
    CALI_PAGE_START = 0,
    CALI_PAGE_PRESET,
    CALI_PAGE_CALI,
    CALI_PAGE_COARSE_SAVE,
    CALI_PAGE_FINE_CALI,
    CALI_PAGE_FINE_SAVE,
    CALI_PAGE_PA_SAVE,
    CALI_PAGE_FLOW_SAVE,
    CALI_PAGE_COMMON_SAVE,
};

CaliPresetPageStatus

enum Slic3r::GUI::CaliPresetPageStatus

Enumerator
CaliPresetStatusInit
CaliPresetStatusNormal
CaliPresetStatusNoUserLogin
CaliPresetStatusInvalidPrinter
CaliPresetStatusConnectingServer
CaliPresetStatusInUpgrading
CaliPresetStatusInSystemPrinting
CaliPresetStatusInPrinting
CaliPresetStatusLanModeNoSdcard
CaliPresetStatusNoSdcard
CaliPresetStatusNeedForceUpgrading
CaliPresetStatusNeedConsistencyUpgrading
CaliPresetStatusUnsupportedPrinter
CaliPresetStatusInConnecting
CaliPresetStatusFilamentIncompatible
CaliPresetStatusLanModeSDcardNotAvailable
CaliPresetStatusDifferentNozzleDiameters
CaliPresetStatusOptionalPrinterModel

{
    CaliPresetStatusInit = 0,
    CaliPresetStatusNormal,
    CaliPresetStatusNoUserLogin,
    CaliPresetStatusInvalidPrinter,
    CaliPresetStatusConnectingServer,
    CaliPresetStatusInUpgrading,
    CaliPresetStatusInSystemPrinting,
    CaliPresetStatusInPrinting,
    CaliPresetStatusLanModeNoSdcard,
    CaliPresetStatusNoSdcard,
    CaliPresetStatusNeedForceUpgrading,
    CaliPresetStatusNeedConsistencyUpgrading,
    CaliPresetStatusUnsupportedPrinter,
    CaliPresetStatusInConnecting, 
    CaliPresetStatusFilamentIncompatible,
    CaliPresetStatusLanModeSDcardNotAvailable,
    CaliPresetStatusDifferentNozzleDiameters,
    CaliPresetStatusOptionalPrinterModel
};

CaliPresetStage

enum Slic3r::GUI::CaliPresetStage

Enumerator
CALI_MANULA_STAGE_NONE
CALI_MANUAL_STAGE_1
CALI_MANUAL_STAGE_2

                     {
    CALI_MANULA_STAGE_NONE = 0,
    CALI_MANUAL_STAGE_1,
    CALI_MANUAL_STAGE_2,
};

CaliSaveStyle

enum Slic3r::GUI::CaliSaveStyle

Enumerator
CALI_SAVE_P1P_STYLE
CALI_SAVE_X1_STYLE

                   {
    CALI_SAVE_P1P_STYLE = 0,
    CALI_SAVE_X1_STYLE,
};

CameraMenuIDs

enum Slic3r::GUI::CameraMenuIDs

Enumerator
wxID_CAMERA_PERSPECTIVE
wxID_CAMERA_ORTHOGONAL
wxID_CAMERA_COUNT

                   {
    wxID_CAMERA_PERSPECTIVE,
    wxID_CAMERA_ORTHOGONAL,
    wxID_CAMERA_COUNT,
};

CameraRecordingStatus

enum Slic3r::GUI::CameraRecordingStatus

Enumerator
RECORDING_NONE
RECORDING_OFF_NORMAL
RECORDING_OFF_HOVER
RECORDING_ON_NORMAL
RECORDING_ON_HOVER

                           {
    RECORDING_NONE,
    RECORDING_OFF_NORMAL,
    RECORDING_OFF_HOVER,
    RECORDING_ON_NORMAL,
    RECORDING_ON_HOVER,
};

CameraTimelapseStatus

enum Slic3r::GUI::CameraTimelapseStatus

Enumerator
TIMELAPSE_NONE
TIMELAPSE_OFF_NORMAL
TIMELAPSE_OFF_HOVER
TIMELAPSE_ON_NORMAL
TIMELAPSE_ON_HOVER

                           {
    TIMELAPSE_NONE,
    TIMELAPSE_OFF_NORMAL,
    TIMELAPSE_OFF_HOVER,
    TIMELAPSE_ON_NORMAL,
    TIMELAPSE_ON_HOVER,
};

CloudTaskNozzleId

enum class Slic3r::GUI::CloudTaskNozzleId : int

strong

Enumerator
NOZZLE_RIGHT
NOZZLE_LEFT

{
    NOZZLE_RIGHT    = 0,
    NOZZLE_LEFT     = 1,
};

CollapseSide

enum class Slic3r::GUI::CollapseSide

strong

Enumerator
None
Left
Right

{ None, Left, Right };

ColumnNumber

enum Slic3r::GUI::ColumnNumber

Enumerator
colName
colHeight
colPrint
colFilament
colSupportPaint
colColorPaint
colSinking
colEditing
colCount

{
    colName         = 0,    // item name
    colHeight          ,    // variable height
    colPrint           ,    // printable property
    colFilament        ,    // extruder selection
    // BBS
    colSupportPaint    ,
    colColorPaint      ,
    colSinking         ,
    colEditing         ,    // item editing
    colCount           ,
};

CommonGizmosDataID

enum class Slic3r::GUI::CommonGizmosDataID

strong

Enumerator
None
SelectionInfo
InstancesHider
Raycaster
ObjectClipper

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

ConfigMenuIDs

enum Slic3r::GUI::ConfigMenuIDs

Enumerator
ConfigMenuPreferences
ConfigMenuPrinter
ConfigMenuCnt

                   {
    //ConfigMenuWizard,
    //ConfigMenuSnapshots,
    //ConfigMenuTakeSnapshot,
    //ConfigMenuUpdate,
    //ConfigMenuDesktopIntegration,
    ConfigMenuPreferences,
    ConfigMenuPrinter,
    //ConfigMenuModeSimple,
    //ConfigMenuModeAdvanced,
    //ConfigMenuLanguage,
    //ConfigMenuFlashFirmware,
    ConfigMenuCnt,
};

ConfigNozzleIdx

enum class Slic3r::GUI::ConfigNozzleIdx : int

strong

Enumerator
NOZZLE_LEFT
NOZZLE_RIGHT

{
    NOZZLE_LEFT      = 0,
    NOZZLE_RIGHT     = 1,
};

DailyTipsLayout

enum class Slic3r::GUI::DailyTipsLayout

strong

Enumerator
Horizontal
Vertical

                          {
    Horizontal,
    Vertical
};

DataStatusType

enum Slic3r::GUI::DataStatusType

Enumerator
ADJUST
OK
UNMATCHED

                    {
    ADJUST,
    OK,
    UNMATCHED
};

DecomposeBaseColor

enum class Slic3r::GUI::DecomposeBaseColor

strong

Enumerator
None
Cyan
Magenta
Yellow
White
Red
Green
Blue

                              {
    None,
    Cyan,
    Magenta,
    Yellow,
    White,
    Red,
    Green,
    Blue
};

DevExtruderState

enum class Slic3r::GUI::DevExtruderState

strong

Enumerator
FILLED_LOAD
FILLED_UNLOAD
EMPTY_LOAD
EMPTY_UNLOAD

                            {
    FILLED_LOAD,
    FILLED_UNLOAD,
    EMPTY_LOAD,
    EMPTY_UNLOAD
};

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
};

DpTok

enum Slic3r::GUI::DpTok

Enumerator
TokRibbonBg
TokRibbonHover
TokPanelBg
TokSecText
TokCtlText
TokItemText
TokItemDim
TokBorder
TokCount

           { TokRibbonBg, TokRibbonHover, TokPanelBg, TokSecText, TokCtlText, TokItemText, TokItemDim,
             TokBorder, TokCount };

DragMode

enum class Slic3r::GUI::DragMode

strong

Enumerator
NONE
DRAGGING

                    {
    NONE,
    DRAGGING,
};

DrawMode

enum Slic3r::GUI::DrawMode

Enumerator
dmRegular
dmSlaPrint
dmSequentialFffPrint
dmSequentialGCodeView

{
    dmRegular,
    dmSlaPrint,
    dmSequentialFffPrint,
    dmSequentialGCodeView,
};

DryCtrDev

enum class Slic3r::GUI::DryCtrDev

strong

Enumerator
N3S
N3F
UNKNOWN

                     {
    N3S,
    N3F,
    UNKNOWN
};

DryCtrState

enum class Slic3r::GUI::DryCtrState

strong

Enumerator
IDLE
DRY_WHEN_PRINT
UNKNOWN

                       {
    IDLE,
    DRY_WHEN_PRINT,
    UNKNOWN
};

ECoordinatesType

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

strong

Enumerator
World
Instance
Local

{
    World = 0,
    Instance,
    Local
};

EditorType

enum Slic3r::GUI::EditorType

Enumerator
etUndef
etMinZ
etMaxZ
etLayerHeight

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

EMeasureMode

enum class Slic3r::GUI::EMeasureMode : unsigned char

strong

Enumerator
ONLY_MEASURE
ONLY_ASSEMBLY

                        : unsigned char {
    ONLY_MEASURE,
    ONLY_ASSEMBLY
};

ERescaleTarget

enum class Slic3r::GUI::ERescaleTarget

strong

Enumerator
Mainframe
SettingsDialog

{
    Mainframe,
    SettingsDialog
};

ExportCase

enum Slic3r::GUI::ExportCase

Enumerator
INITIALIZE_FAIL
ADD_FILE_FAIL
ADD_BUNDLE_STRUCTURE_FAIL
FINALIZE_FAIL
OPEN_ZIP_WRITTEN_FILE
EXPORT_CANCEL
EXPORT_SUCCESS
CASE_COUNT

                {
    INITIALIZE_FAIL = 0,
    ADD_FILE_FAIL,
    ADD_BUNDLE_STRUCTURE_FAIL,
    FINALIZE_FAIL,
    OPEN_ZIP_WRITTEN_FILE,
    EXPORT_CANCEL,
    EXPORT_SUCCESS,
    CASE_COUNT,
};

ExportingStatus

enum Slic3r::GUI::ExportingStatus

Enumerator
NOT_EXPORTING
EXPORTING_TO_REMOVABLE
EXPORTING_TO_LOCAL

                    {
    NOT_EXPORTING,
    EXPORTING_TO_REMOVABLE,
    EXPORTING_TO_LOCAL
};

ExtruderState

enum Slic3r::GUI::ExtruderState

Enumerator
FILLED_LOAD
FILLED_UNLOAD
EMPTY_LOAD
EMPTY_UNLOAD

                   {
    FILLED_LOAD,
    FILLED_UNLOAD,
    EMPTY_LOAD,
    EMPTY_UNLOAD
};

FanControlType

enum Slic3r::GUI::FanControlType

Enumerator
PART_FAN
AUX_FAN
EXHAUST_FAN
FILTER_FAN
CHAMBER_FAN
TOP_FAN

{
    PART_FAN = 0,
    AUX_FAN,
    EXHAUST_FAN,
    FILTER_FAN,
    CHAMBER_FAN,
    TOP_FAN
};

FILAMENT_TYPE

enum Slic3r::GUI::FILAMENT_TYPE : int

Enumerator
tPLA
tABS_ASA
tPETG
tPCTG
tTPU
tTPU_AMS
tPA_CF
tPET_CF
tCustom

{
    tPLA = 0,
    tABS_ASA,
    tPETG,
    tPCTG,
    tTPU,
    tTPU_AMS,
    tPA_CF,
    tPET_CF,
    tCustom
};

FilamentMapNozzleId

enum class Slic3r::GUI::FilamentMapNozzleId : int

strong

Enumerator
NOZZLE_LEFT
NOZZLE_RIGHT

{
    NOZZLE_LEFT     = 1,
    NOZZLE_RIGHT    = 2,
};

FilamentRenderMode

enum class Slic3r::GUI::FilamentRenderMode

strong

Enumerator
Single
Dual
Triple
Quadruple
Gradient

                              {
    Single,
    Dual,
    Triple,
    Quadruple,
    Gradient
};

FilamentStep

enum Slic3r::GUI::FilamentStep

Enumerator
STEP_IDLE
STEP_HEAT_NOZZLE
STEP_CUT_FILAMENT
STEP_PULL_CURR_FILAMENT
STEP_PUSH_NEW_FILAMENT
STEP_GRAB_NEW_FILAMENT
STEP_PURGE_OLD_FILAMENT
STEP_CONFIRM_EXTRUDED
STEP_CHECK_POSITION
STEP_COUNT

                  {
    STEP_IDLE,
    STEP_HEAT_NOZZLE,
    STEP_CUT_FILAMENT,
    STEP_PULL_CURR_FILAMENT,
    STEP_PUSH_NEW_FILAMENT,
    STEP_GRAB_NEW_FILAMENT,
    STEP_PURGE_OLD_FILAMENT,
    STEP_CONFIRM_EXTRUDED,
    STEP_CHECK_POSITION,
    STEP_COUNT,
};

FilamentStepType

enum Slic3r::GUI::FilamentStepType

Enumerator
STEP_TYPE_LOAD
STEP_TYPE_UNLOAD
STEP_TYPE_VT_LOAD

                      {
    STEP_TYPE_LOAD      = 0,
    STEP_TYPE_UNLOAD    = 1,
    STEP_TYPE_VT_LOAD   = 2,
};

FileType

enum Slic3r::GUI::FileType

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

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

FIRMWARE_STASUS

enum Slic3r::GUI::FIRMWARE_STASUS

Enumerator
UNKOWN
TESTING
BETA
RELEASE

{
    UNKOWN,
    TESTING,
    BETA,
    RELEASE,
};

FlowRatioCaliSource

enum Slic3r::GUI::FlowRatioCaliSource

Enumerator
FROM_PRESET_PAGE
FROM_COARSE_PAGE

                         {
    FROM_PRESET_PAGE = 0,
    FROM_COARSE_PAGE,
};

GridTextInputType

enum class Slic3r::GUI::GridTextInputType

strong

Enumerator
K
N
FlowRatio
Name

                             {
    K,
    N,
    FlowRatio,
    Name
};

HintDataNavigation

enum class Slic3r::GUI::HintDataNavigation

strong

Enumerator
Curr
Prev
Next
Random

                              {
  Curr,
  Prev,
  Next,
  Random,
};

InfoItemType

enum class Slic3r::GUI::InfoItemType

strong

Enumerator
Undef
CustomSupports
MmSegmentation
FuzzySkin
CutConnectors

{
    Undef,
    CustomSupports,
    //CustomSeam,
    MmSegmentation,
    FuzzySkin,
    //Sinking
    CutConnectors,
};

ItemType

enum Slic3r::GUI::ItemType

Enumerator
itUndef
itPlate
itObject
itVolume
itInstanceRoot
itInstance
itSettings
itLayerRoot
itLayer
itInfo

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

LabelType

enum Slic3r::GUI::LabelType

Enumerator
ltHeightWithLayer
ltHeight
ltEstimatedTime

{
    ltHeightWithLayer,
    ltHeight,
    ltEstimatedTime,
};

LoadFilesType

enum class Slic3r::GUI::LoadFilesType

strong

Enumerator
NoFile
Single3MF
SingleOther
Multiple3MF
MultipleOther
Multiple3MFOther

                         {
    NoFile,
    Single3MF,
    SingleOther,
    Multiple3MF,
    MultipleOther,
    Multiple3MFOther,
};

LoadType

enum class Slic3r::GUI::LoadType : unsigned char

strong

Enumerator
Unknown
OpenProject
LoadGeometry
LoadConfig

{
    Unknown,
    OpenProject,
    LoadGeometry,
    LoadConfig
};

MeshBooleanOperation

enum class Slic3r::GUI::MeshBooleanOperation

strong

Enumerator
Undef
Union
Difference
Intersection

                               {
    Undef,
    Union,
    Difference,
    Intersection,
};

MeshBooleanSelectingState

enum class Slic3r::GUI::MeshBooleanSelectingState

strong

Enumerator
Undef
SelectSource
SelectTool

                                     {
    Undef,
    SelectSource,
    SelectTool,
 
};

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
PresetUpdateAvailable
PresetUpdateFinished
ValidateError
ValidateWarning
SlicingError
SlicingSeriousWarning
SlicingWarning
BBLGeneralError
PlaterError
LeftExtruderUnprintableError
RightExtruderUnprintableError
PlaterWarning
ProgressBar
PrintHostUpload
SlicingProgress
EmptyColorChangeCode
CustomSupportsAndSeamRemovedAfterRepair
EmptyAutoColorChange
SignDetected
QuitSLAManualMode
DesktopIntegrationSuccess
DesktopIntegrationFail
UndoDesktopIntegrationSuccess
UndoDesktopIntegrationFail
MmSegmentationExceededExtrudersLimit
DidYouKnowHint
UpdatedItemsInfo
ProgressIndicator
SimplifySuggestion
UnknownFont
CgalFinished
ExportOngoing
URLDownload
ArrangeOngoing
BBLPlateInfo
BBL3MFInfo
BBLObjectInfo
BBLSliceEmptyLayer
BBLNeedSupportON
BBLGcodeOverlap
BBLSeqPrintInfo
BBLPluginInstallHint
BBLFlushingVolumeZero
BBLMixedFilamentBroken
BBLPluginUpdateAvailable
BBLPreviewOnlyMode
BBLPrinterConfigUpdateAvailable
BBLUserPresetExceedLimit
BBLFilamentPrintableError
BBLSliceLimitError
BBLSliceMultiExtruderHeightOutside
BBLBedFilamentIncompatible
BBLMixUsePLAAndPETG
BBLNozzleFilamentIncompatible
BBLSingleExtruderMixedFilamentRisk
OrcaSharedProfilesAvailable
OrcaCloudAPIError
OrcaSyncConflict
OrcaLocalPluginMissingError
OrcaCloudPluginMissingError
OrcaPluginInactiveError
OrcaPluginCapabilityUnavailableError
NotificationTypeCount

{
  CustomNotification = 0,
        //  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,
  // 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,
  PresetUpdateFinished,
//  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,
  //Gcode conflict generates slicing severe warning
    SlicingSeriousWarning,
  // Slicing warnings, issued by the slicing process.
  // Slicing warnings are registered for a particular Print milestone or a PrintObject and its milestone.
  SlicingWarning,
  // BBL: general error
  BBLGeneralError,
  // Object partially outside the print volume. Cannot slice.
  PlaterError,
  LeftExtruderUnprintableError,
  RightExtruderUnprintableError,
  // 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 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 cgal is finished repairing model (blocking process)
  CgalFinished,
  // Short meesage to fill space between start and finish of export
  ExportOngoing,
    // Progressbar of download from prusaslicer://url
    URLDownload,
  // BBS: Short meesage to fill space between start and finish of arranging
  ArrangeOngoing,
  // BBL: Plate Info ,Design For @YangLeDuo
  BBLPlateInfo,
  // BBL: 3MF warnings
  BBL3MFInfo,
  // BBL: Some Objects Info, Design For @YangLeDuo
  BBLObjectInfo,
  // BBL: Objects have empty layer when Slicing
  BBLSliceEmptyLayer,
  // BBL: model need support
  BBLNeedSupportON,
  // BBL: Gcode overlap
  BBLGcodeOverlap,
  //BBL: sequence print info
  BBLSeqPrintInfo,
  //BBL: plugin install hint
  BBLPluginInstallHint,
    BBLFlushingVolumeZero,
    // A mixed-color filament references a deleted component, or its components disagree in type.
    BBLMixedFilamentBroken,
  BBLPluginUpdateAvailable,
  BBLPreviewOnlyMode,
    BBLPrinterConfigUpdateAvailable,
  BBLUserPresetExceedLimit,
    BBLFilamentPrintableError,
    BBLSliceLimitError,
    BBLSliceMultiExtruderHeightOutside,
  BBLBedFilamentIncompatible,
    BBLMixUsePLAAndPETG,
  BBLNozzleFilamentIncompatible,
    // A mixed-color filament is printed on a single-nozzle printer (frequent changes and purging).
    BBLSingleExtruderMixedFilamentRisk,
    OrcaSharedProfilesAvailable,
  OrcaCloudAPIError,
    OrcaSyncConflict,
    // Active preset requires plugin capabilities that are not installed/loadable. Persistent,
    // non-modal; offers install (cloud) / OrcaCloud search (local) and blocks slicing.
    OrcaLocalPluginMissingError,
    OrcaCloudPluginMissingError,
    // Active preset references capabilities that are installed but not active (plugin not loaded, or
    // capability disabled). Resolved locally by activating them; persistent, blocks slicing.
    OrcaPluginInactiveError,
    // Active preset references a capability the installed+loaded plugin does not provide (outdated
    // plugin). Informational; cannot be auto-resolved; persistent, blocks slicing.
    OrcaPluginCapabilityUnavailableError,
    NotificationTypeCount
 
};

OfferSel

enum class Slic3r::GUI::OfferSel : int

strong

Enumerator
None
FacePlanar
FaceCyl
FaceOther
EdgeStr
EdgeCirc
Vertex
BodySolid
BodySheet
Bodies2
DatumPlane
DatumAxis
CoordSys
Art
SkLoop
SkNone
SkLine
SkArc
SkPoint
Sk2Ent
Count

                    : int {
    None = 0,
    FacePlanar = 1,
    FaceCyl = 2,
    FaceOther = 3,
    EdgeStr = 4,
    EdgeCirc = 5,
    Vertex = 6,
    BodySolid = 7,
    BodySheet = 8,
    Bodies2 = 9,
    DatumPlane = 10,
    DatumAxis = 11,
    CoordSys = 12,
    Art = 13,
    SkLoop = 14,
    SkNone = 15,
    SkLine = 16,
    SkArc = 17,
    SkPoint = 18,
    Sk2Ent = 19,
    Count = 20
};

OrcaSlicerMenuIDs

enum Slic3r::GUI::OrcaSlicerMenuIDs

Enumerator
OrcaSlicerMenuAbout
OrcaSlicerMenuPreferences

                       {
  OrcaSlicerMenuAbout,
  OrcaSlicerMenuPreferences,
};

PainterGizmoType

enum class Slic3r::GUI::PainterGizmoType

strong

Enumerator
FDM_SUPPORTS
SEAM
MM_SEGMENTATION
FUZZY_SKIN
TEXTURE_DISPLACEMENT

                            {
    FDM_SUPPORTS,
    SEAM,
    MM_SEGMENTATION,
    FUZZY_SKIN,
    TEXTURE_DISPLACEMENT
};

ParamType

enum class Slic3r::GUI::ParamType

strong

Enumerator
Undef
Scalar
Vector
FilamentVector

                     {
    Undef,
    Scalar,
    Vector,
    FilamentVector,
};

PartState

enum Slic3r::GUI::PartState

Enumerator
psUnCheck
psChecked
psSkipped

               {
    psUnCheck,
    psChecked,
    psSkipped
};

PluginInstallStatus

enum Slic3r::GUI::PluginInstallStatus

Enumerator
InstallStatusNormal
InstallStatusDownloadFailed
InstallStatusDownloadCompleted
InstallStatusUnzipFailed
InstallStatusInstallCompleted

                         {
    InstallStatusNormal = 0,
    InstallStatusDownloadFailed = 1,
    InstallStatusDownloadCompleted = 2,
    InstallStatusUnzipFailed = 3,
    InstallStatusInstallCompleted = 4,
};

PluginSortKey

enum class Slic3r::GUI::PluginSortKey

strong

Enumerator
Status
Name
Source
Version
None

    {
        Status,
        Name,
        Source,
        Version,
        // why: neutral "no column selected" state - clearing a header sort returns here and the
        //   list falls to compare_plugin_base_order only. Header UI reaches it via the asc/desc/clear cycle.
        None
    };

PluginSortOrder

enum class Slic3r::GUI::PluginSortOrder

strong

Enumerator
Asc
Desc

    {
        Asc,
        Desc
    };

PluginSource

enum class Slic3r::GUI::PluginSource

strong

Enumerator
Mine
Subscribed
Orphaned
Local

        {
            // IMPORTANT: ordinal order is the Plugins dialog Source sort priority.
            Mine,
            Subscribed,
            Orphaned,
            Local
        };

PluginStatus

enum class Slic3r::GUI::PluginStatus

strong

Enumerator
Activated
Error
RuntimeError
Inactive
Loading

        {
            // IMPORTANT: ordinal order is the Plugins dialog Status sort priority.
            Activated,
            Error,
            RuntimeError,
            Inactive,
            Loading
        };

PreferencesTab

enum class Slic3r::GUI::PreferencesTab

strong

Enumerator
General
Control
Graphics
Online

{ General, Control, Graphics, Online };

prePrintInfoLevel

enum Slic3r::GUI::prePrintInfoLevel

Enumerator
Normal
Warning
Error

                       {
    Normal,
    Warning,
    Error
};

prePrintInfoType

enum Slic3r::GUI::prePrintInfoType

Enumerator
Printer
Filament

                      {
    Printer,
    Filament
};

PrintDialogStatus

enum Slic3r::GUI::PrintDialogStatus : unsigned int

Enumerator
PrintStatusErrorBegin
PrintStatusPrinterErrorBegin
PrintStatusInit
PrintStatusNoUserLogin
PrintStatusInvalidPrinter
PrintStatusConnectingServer
PrintStatusReadingTimeout
PrintStatusReading
PrintStatusConnecting
PrintStatusReconnecting
PrintStatusInUpgrading
PrintStatusFirmwareNotSupportTpuAtLeft
PrintStatusModeNotFDM
PrintStatusInSystemPrinting
PrintStatusInPrinting
PrintStatusNozzleMatchInvalid
PrintStatusNozzleDataInvalid
PrintStatusNozzleTypeMismatch
PrintStatusNozzleNoMatchedHotends
PrintStatusNozzleRackMaximumInstalled
PrintStatusRefreshingMachineList
PrintStatusSending
PrintStatusLanModeNoSdcard
PrintStatusNoSdcard
PrintStatusLanModeSDcardNotAvailable
PrintStatusNeedForceUpgrading
PrintStatusNeedConsistencyUpgrading
PrintStatusNotSupportedPrintAll
PrintStatusBlankPlate
PrintStatusUnsupportedPrinter
PrintStatusRackNozzleMappingWaiting
PrintStatusRackNozzleMappingError
PrintStatusRackReading
PrintStatusFilaSwitcherError
PrintStatusPrinterErrorEnd
PrintStatusFilamentErrorBegin
PrintStatusAmsOnSettingup
PrintStatusAmsMappingInvalid
PrintStatusAmsMappingU0Invalid
PrintStatusAmsMappingMixInvalid
PrintStatusTPUUnsupportAutoCali
PrintStatusHasFilamentInBlackListError
PrintStatusColorQuantityExceed
PrintStatusFilamentErrorEnd
PrintStatusErrorEnd
PrintStatusWarningBegin
PrintStatusPrinterWarningBegin
PrintStatusTimelapseNoSdcard
PrintStatusTimelapseWarning
PrintStatusTimelapseStorageLow
PrintStatusMixAmsAndVtSlotWarning
PrintStatusToolHeadCoolingFanWarning
PrintStatusRackNozzleMappingWarning
PrintStatusFilaSwitcherSlicingNotMatch
PrintStatusRackNozzleNumUnmeetWarning
PrintStatusHasUnreliableNozzleWarning
PrintStatusNozzleDiameterMismatch
PrintStatusOptionalPrinterModel
PrintStatusPrinterWarningEnd
PrintStatusFilamentWarningBegin
PrintStatusWarningKvalueNotUsed
PrintStatusHasFilamentInBlackListWarning
PrintStatusFilamentWarningHighChamberTemp
PrintStatusFilamentWarningHighChamberTempCloseDoor
PrintStatusFilamentWarningHighChamberTempSoft
PrintStatusFilamentWarningUnknownHighChamberTempSoft
PrintStatusWarningExtFilamentNotMatch
PrintStatusFilamentWarningNozzleHRC
PrintStatusFilamentCrossExtruderWarning
PrintStatusTPUUnsupportCaliOn
PrintStatusTPUUnsuggestCali
PrintStatusSmartNozzleBlobNeedAuto
PrintStatusFilamentWarningRemainNotEnough
PrintStatusPrintTimeEstimateWarning
PrintStatusFilamentWarningEnd
PrintStatusWarningEnd
PrintStatusReadingFinished
PrintStatusSendingCanceled
PrintStatusReadyToGo
PrintStatusAmsMappingSuccess
PrintStatusNotOnTheSameLAN
PrintStatusNotSupportedSendToSDCard
PrintStatusPublicInitFailed
PrintStatusPublicUploadFiled

                       : unsigned int {
 
    PrintStatusErrorBegin,//->start error<-
 
    // Errors for printer, Block Print
    PrintStatusPrinterErrorBegin,
    PrintStatusInit,
    PrintStatusNoUserLogin,
    PrintStatusInvalidPrinter,
    PrintStatusConnectingServer,
    PrintStatusReadingTimeout,
    PrintStatusReading,
    PrintStatusConnecting,
    PrintStatusReconnecting,
    PrintStatusInUpgrading,
    PrintStatusFirmwareNotSupportTpuAtLeft,
    PrintStatusModeNotFDM,
    PrintStatusInSystemPrinting,
    PrintStatusInPrinting,
    PrintStatusNozzleMatchInvalid,
    PrintStatusNozzleDataInvalid,
    PrintStatusNozzleTypeMismatch,
    PrintStatusNozzleNoMatchedHotends,
    PrintStatusNozzleRackMaximumInstalled,
    PrintStatusRefreshingMachineList,
    PrintStatusSending,
    PrintStatusLanModeNoSdcard,
    PrintStatusNoSdcard,
    PrintStatusLanModeSDcardNotAvailable,
    PrintStatusNeedForceUpgrading,
    PrintStatusNeedConsistencyUpgrading,
    PrintStatusNotSupportedPrintAll,
    PrintStatusBlankPlate,
    PrintStatusUnsupportedPrinter,
    PrintStatusRackNozzleMappingWaiting,
    PrintStatusRackNozzleMappingError,
    PrintStatusRackReading,
    PrintStatusFilaSwitcherError,
    PrintStatusPrinterErrorEnd,
 
    // Errors for filament, Block Print
    PrintStatusFilamentErrorBegin,
    PrintStatusAmsOnSettingup,
    PrintStatusAmsMappingInvalid,
    PrintStatusAmsMappingU0Invalid,
    PrintStatusAmsMappingMixInvalid,
    PrintStatusTPUUnsupportAutoCali,
    PrintStatusHasFilamentInBlackListError,
    PrintStatusColorQuantityExceed,
    PrintStatusFilamentErrorEnd,
 
    PrintStatusErrorEnd,//->end error<-
 
 
    PrintStatusWarningBegin,//->start warning<-
 
    // Warnings for printer
    PrintStatusPrinterWarningBegin,
    PrintStatusTimelapseNoSdcard,
    PrintStatusTimelapseWarning,
    PrintStatusTimelapseStorageLow,
    PrintStatusMixAmsAndVtSlotWarning,
    PrintStatusToolHeadCoolingFanWarning,
    PrintStatusRackNozzleMappingWarning,
    PrintStatusFilaSwitcherSlicingNotMatch,
    PrintStatusRackNozzleNumUnmeetWarning,
    PrintStatusHasUnreliableNozzleWarning,
    // Orca: a nozzle diameter that differs from the one the printer remembers is a warning,
    // not an error, so non-standard nozzles can still be printed with.
    PrintStatusNozzleDiameterMismatch,
    PrintStatusOptionalPrinterModel,
    PrintStatusPrinterWarningEnd,
 
    // Warnings for filament
    PrintStatusFilamentWarningBegin,
    PrintStatusWarningKvalueNotUsed,
    PrintStatusHasFilamentInBlackListWarning,
    PrintStatusFilamentWarningHighChamberTemp,
    PrintStatusFilamentWarningHighChamberTempCloseDoor,
    PrintStatusFilamentWarningHighChamberTempSoft,
    PrintStatusFilamentWarningUnknownHighChamberTempSoft,
    PrintStatusWarningExtFilamentNotMatch,
    PrintStatusFilamentWarningNozzleHRC,
    PrintStatusFilamentCrossExtruderWarning,
    // Non-blocking advisories. FilamentWarningRemainNotEnough is declared but not wired (missing
    // device-model surface); PrintTimeEstimateWarning has no call site or message and is kept only
    // to match the reference enum table.
    PrintStatusTPUUnsupportCaliOn,
    PrintStatusTPUUnsuggestCali,
    PrintStatusSmartNozzleBlobNeedAuto,
    PrintStatusFilamentWarningRemainNotEnough,
    PrintStatusPrintTimeEstimateWarning,
    PrintStatusFilamentWarningEnd,
 
    PrintStatusWarningEnd,//->end error<-
 
    /*success*/
    // printer
    PrintStatusReadingFinished,
    PrintStatusSendingCanceled,
    PrintStatusReadyToGo,
 
    // filament
    PrintStatusAmsMappingSuccess,
 
    /*Other, SendToPrinterDialog*/
    PrintStatusNotOnTheSameLAN,
    PrintStatusNotSupportedSendToSDCard,
    PrintStatusPublicInitFailed,
    PrintStatusPublicUploadFiled,
};

PrinterBindState

enum Slic3r::GUI::PrinterBindState

Enumerator
NONE
ALLOW_BIND
ALLOW_UNBIND

                      {
    NONE,
    ALLOW_BIND,
    ALLOW_UNBIND
};

PrinterState

enum Slic3r::GUI::PrinterState

Enumerator
OFFLINE
IDLE
BUSY
LOCK
IN_LAN

                  {
    OFFLINE,
    IDLE,
    BUSY,
    LOCK,
    IN_LAN
};

PrintFromType

enum Slic3r::GUI::PrintFromType

Enumerator
FROM_NORMAL
FROM_SDCARD_VIEW

{
    FROM_NORMAL,
    FROM_SDCARD_VIEW,
};

PrintIndicator

enum Slic3r::GUI::PrintIndicator

Enumerator
piUndef
piPrintable
piUnprintable

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

PrintingTaskType

enum Slic3r::GUI::PrintingTaskType

Enumerator
PRINGINT
CALIBRATION
NOT_CLEAR

                      {
    PRINGINT,
    CALIBRATION,
    NOT_CLEAR
};

PrintPageMode

enum Slic3r::GUI::PrintPageMode

Enumerator
PrintPageModePrepare
PrintPageModeSending
PrintPageModeFinish

                   {
    PrintPageModePrepare = 0,
    PrintPageModeSending,
    PrintPageModeFinish
};

PurgeModeDialogType

enum class Slic3r::GUI::PurgeModeDialogType

strong

Enumerator
MultiNozzle
FastMode

                               {
    MultiNozzle,
    FastMode
};

QuickSlice

enum Slic3r::GUI::QuickSlice

Enumerator
qsUndef
qsReslice
qsSaveAs
qsExportSVG
qsExportPNG

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

RowAction

enum Slic3r::GUI::RowAction

Enumerator
RowEdit
RowMove
RowVisibility
RowDelete
RowZoom

{ RowEdit, RowMove, RowVisibility, RowDelete, RowZoom };

SelectedSlider

enum Slic3r::GUI::SelectedSlider

Enumerator
ssUndef
ssLower
ssHigher

                    {
    ssUndef = 0,
    ssLower = 1,
    ssHigher = 2
};

Shortcut

enum class Slic3r::GUI::Shortcut : uint8_t

strong

Enumerator
NewProject
OpenProject
SaveProject
SaveProjectAs
ImportModel
Publish3mf
SlicePlate
ExportSlicedFile
PrintPlate
PrintHostQueue
SelectAll
SelectAllPlates
Undo
Redo
Cut
Copy
Paste
DeleteSelected
DeleteAll
CloneSelected
AddInstance
RemoveInstance
TogglePrintable
ToggleAutoDrop
Arrange
ArrangePlate
Orient
OrientPlate
MoveSelectionLeft
MoveSelectionRight
MoveSelectionUp
MoveSelectionDown
RotateSelectionLeft
RotateSelectionRight
GizmoMove
GizmoRotate
GizmoScale
GizmoFlatten
GizmoCut
GizmoMeshBoolean
GizmoFdmSupports
GizmoSeam
GizmoFuzzySkin
GizmoMmuSegmentation
GizmoEmboss
GizmoMeasure
GizmoAssembly
GizmoBrimEars
GizmoDisplacement
GoToLayer
LayerSliderUp
LayerSliderDown
MovesSliderLeft
MovesSliderRight
MovesSliderStart
MovesSliderEnd
PaintToolCircle
PaintToolSphere
PaintToolFill
PaintToolGapFill
PaintToolTriangle
PaintToolHeightRange
ViewDefault
ViewTop
ViewBottom
ViewFront
ViewRear
ViewLeft
ViewRight
ViewPlate
ZoomIn
ZoomOut
Mouse3DSettings
ShowLabels
ShowCollisionVolumes
ShowWireframe
ToggleGcodeWindow
ToggleOneLayerMode
ToggleBeltRawGcode
Preferences
Search
SwitchView
CollapseSidebar
ReloadDevicePage
KeyboardShortcuts
Quit
SpeedDial
Count

                    : uint8_t {
    // Project
    NewProject, OpenProject, SaveProject, SaveProjectAs, ImportModel, Publish3mf,
    // Slicing and printing
    SlicePlate, ExportSlicedFile, PrintPlate, PrintHostQueue,
    // Selection
    SelectAll, SelectAllPlates,
    // Editing
    Undo, Redo, Cut, Copy, Paste, DeleteSelected, DeleteAll, CloneSelected,
    // Objects
    AddInstance, RemoveInstance, TogglePrintable, ToggleAutoDrop,
    // Placement
    Arrange, ArrangePlate, Orient, OrientPlate,
    MoveSelectionLeft, MoveSelectionRight, MoveSelectionUp, MoveSelectionDown, RotateSelectionLeft, RotateSelectionRight,
    // Gizmos
    GizmoMove, GizmoRotate, GizmoScale, GizmoFlatten, GizmoCut, GizmoMeshBoolean, GizmoFdmSupports, GizmoSeam, GizmoFuzzySkin,
    GizmoMmuSegmentation, GizmoEmboss, GizmoMeasure, GizmoAssembly, GizmoBrimEars, GizmoDisplacement,
    // Sliders
    GoToLayer, LayerSliderUp, LayerSliderDown, MovesSliderLeft, MovesSliderRight, MovesSliderStart, MovesSliderEnd,
    // Painting tools
    PaintToolCircle, PaintToolSphere, PaintToolFill, PaintToolGapFill, PaintToolTriangle, PaintToolHeightRange,
    // Camera
    ViewDefault, ViewTop, ViewBottom, ViewFront, ViewRear, ViewLeft, ViewRight, ViewPlate, ZoomIn, ZoomOut, Mouse3DSettings,
    // Display
    ShowLabels, ShowCollisionVolumes, ShowWireframe, ToggleGcodeWindow, ToggleOneLayerMode, ToggleBeltRawGcode,
    // Application
    Preferences, Search, SwitchView, CollapseSidebar, ReloadDevicePage, KeyboardShortcuts, Quit,
    // Speed Dial
    SpeedDial,
    Count
};

ShortcutContext

enum class Slic3r::GUI::ShortcutContext : uint8_t

strong

Enumerator
Global
Plater
Preview
ObjectList
Painting
Count

: uint8_t { Global, Plater, Preview, ObjectList, Painting, Count };

ShortcutSection

enum class Slic3r::GUI::ShortcutSection : uint8_t

strong

Enumerator
Project
SlicingAndPrinting
Selection
Editing
Objects
Placement
Gizmos
Sliders
PaintingTools
Camera
Display
Application
SpeedDial
Count

                           : uint8_t {
    Project, SlicingAndPrinting, Selection, Editing, Objects, Placement, Gizmos, Sliders, PaintingTools, Camera, Display, Application, SpeedDial,
    Count
};

ShowType

enum Slic3r::GUI::ShowType

Enumerator
LEFT
RIGHT
LEFT_AND_RIGHT
LEFT_AND_RIGHT_DYNAMIC

              {
    LEFT,   //  only show left ams and left ext
    RIGHT,  //only show right ams and right ext
    LEFT_AND_RIGHT,  //show left and right ams at the same time
    LEFT_AND_RIGHT_DYNAMIC  //show all left and right at one panel when use_dynamic_switch
};

SLAGizmoEventType

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

strong

Enumerator
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_m
siFilament_mm3
siFilament_g
siMateril_unit
siCost
siEstimatedTime
siWTNumbetOfToolchanges
siCount

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

SuccessType

enum Slic3r::GUI::SuccessType

Enumerator
PRINTER
FILAMENT

                 {
    PRINTER = 0,
    FILAMENT
};

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,
};

TestJob

enum Slic3r::GUI::TestJob

Enumerator
TEST_BING_JOB
TEST_ORCA_JOB
TEST_PING_JOB
TEST_JOB_MAX

             {
  TEST_BING_JOB = 0,
  TEST_ORCA_JOB = 1,
  TEST_PING_JOB,
  TEST_JOB_MAX
};

TextureAutoMixMode

enum class Slic3r::GUI::TextureAutoMixMode

strong

Enumerator
CMYW
RYBW

                              {
    CMYW,
    RYBW
};

TextureDisplacementPrepareOutcome

enum class Slic3r::GUI::TextureDisplacementPrepareOutcome

strong

Enumerator
Committed
Unchanged
PaintLost
Failed

{
    Committed, // the parts now carry the prepared mesh and the paint carried onto it
    Unchanged, // nothing needed doing - the meshes already met the criteria; the model was not touched
    PaintLost, // a remesh landed but no layer's paint survived it, so nothing was committed
    Failed,    // cancelled, threw, or the volumes went away while the job ran
};

TextureFilamentKind

enum class Slic3r::GUI::TextureFilamentKind

strong

Enumerator
ExistingPhysical
ExistingMixed
NewPhysical
NewMixed

                               {
    ExistingPhysical,
    ExistingMixed,
    NewPhysical,
    NewMixed
};

TextureImportState

enum class Slic3r::GUI::TextureImportState

strong

Enumerator
Idle
Computing
Ready
Error

                              {
    Idle,
    Computing,
    Ready,
    Error
};

TextureSource

enum class Slic3r::GUI::TextureSource

strong

Enumerator
Shipped
User
Plugin

{ Shipped, User, Plugin };

TrayType

enum Slic3r::GUI::TrayType

Enumerator
NORMAL
THIRD
EMPTY

              {
    NORMAL,
    THIRD,
    EMPTY
};

URL_STATE

enum Slic3r::GUI::URL_STATE

Enumerator
URL_TCP
URL_TUTK

               {
    URL_TCP,
    URL_TUTK,
};

VaryHeightIndicator

enum Slic3r::GUI::VaryHeightIndicator

Enumerator
hiUnVariable
hiVariable

{
    hiUnVariable,    // unvariable height
    hiVariable,    // variable height
};

Function Documentation

_add_containers()

void Slic3r::GUI::_add_containers ( const AmsMapingPopup * win, std::list< MappingContainer * > & one_slot_containers, const std::vector< MappingContainer * > & four_slots_containers, wxBoxSizer * target_sizer )

static

{
    for (auto container : four_slots_containers) { target_sizer->Add(container, 0, wxTOP, win->FromDIP(5)); }
 
    while (!one_slot_containers.empty()) {
        wxBoxSizer* sizer = new wxBoxSizer(wxHORIZONTAL);
        for (int i = 0; i < 3; i++) {
            if (one_slot_containers.empty()) { break; }
 
            sizer->Add(one_slot_containers.front(), 0, wxLEFT, (i == 0) ? 0 : win->FromDIP(5));
            one_slot_containers.pop_front();
        }
 
        target_sizer->Add(sizer, 0, wxTOP, win->FromDIP(5));
    }
}

Referenced by Slic3r::GUI::AmsMapingPopup::update_ams_data_multi_machines(), and Slic3r::GUI::AmsMapingPopup::update_mapping_items().

Here is the caller graph for this function:

_check_kval_not_default()

wxString Slic3r::GUI::_check_kval_not_default ( const MachineObject * obj, const std::vector< FilamentInfo > & mapping_result )

static

{
    if (!obj) { return wxEmptyString;}
 
    wxString ams_names;
    for (const auto& info : mapping_result) {
        if (!obj->contains_tray(info.ams_id, std::to_string(info.tray_id))) { continue; }
        if (obj->get_tray(info.ams_id, std::to_string(info.tray_id)).cali_idx == -1) { continue; } /*-1 means default*/
 
        wxString ams_name;
        if (info.tray_id == VIRTUAL_TRAY_MAIN_ID) {
            ams_name = _L("Right-Ext");
        } else if (info.tray_id == VIRTUAL_TRAY_DEPUTY_ID) {
            ams_name = _L("Left-Ext");
        } else {
            ams_name = wxGetApp().transition_tridid(info.tray_id);
        }
 
        if (!ams_names.empty()) { ams_names += ", ";}
        ams_names += ams_name;
    }
 
    return ams_names;
}

References _L, Slic3r::DevAmsTray::cali_idx, Slic3r::MachineObject::contains_tray(), Slic3r::MachineObject::get_tray(), VIRTUAL_TRAY_DEPUTY_ID, and VIRTUAL_TRAY_MAIN_ID.

Referenced by Slic3r::GUI::SelectMachineDialog::update_show_status().

Here is the call graph for this function:

Here is the caller graph for this function:

_collect_filament_info()

void Slic3r::GUI::_collect_filament_info ( const wxString & shown_name, const Preset & filament, std::unordered_map< wxString, wxString > & query_filament_vendors, std::unordered_map< wxString, wxString > & query_filament_types )

static

{
    query_filament_vendors[shown_name] = filament.config.get_filament_vendor();
    query_filament_types[shown_name] = filament.config.get_filament_type();
}

References Slic3r::Preset::config, Slic3r::DynamicPrintConfig::get_filament_type(), and Slic3r::DynamicPrintConfig::get_filament_vendor().

Referenced by Slic3r::GUI::AMSMaterialsSetting::Popup().

Here is the call graph for this function:

Here is the caller graph for this function:

_collect_sorted_machines()

void Slic3r::GUI::_collect_sorted_machines ( Slic3r::DeviceManager * dev_manager, std::vector< MachineObject * > & sorted_machine_objs )

static

{
    sorted_machine_objs.clear();
    if (!dev_manager)
    {
        return;
    }
 
    /* Step 1 :Collect the target and compatible types*/
    PresetBundle* preset_bundle = wxGetApp().preset_bundle;
    const std::string& printer_type = preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle);
    const auto& compatible_types_list = DevPrinterConfigUtil::get_compatible_machine(printer_type);
    std::set<std::string> compatible_types_set(compatible_types_list.begin(), compatible_types_list.end());
 
    /* Step 2: collect different machine list*/
    MachineObject* cur_selected_obj = dev_manager->get_selected_machine();
    std::vector<MachineObject*> match_avaliable_list;  // match and availiable machines
    std::vector<MachineObject*> match_inavaliable_list;// match but inavaliable machines
    std::vector<MachineObject*> other_list;// other bound machines
    auto _collect_machine = [&](MachineObject* obj)
    {
         if (obj == cur_selected_obj)
         {
             return;
         }
 
        if (obj->printer_type == printer_type)
        {
            obj->is_avaliable() ? match_avaliable_list.push_back(obj) : match_inavaliable_list.push_back(obj);
        }
        else
        {
            other_list.push_back(obj);
        }
    };
 
    // collect from user machine list
    const auto& user_machine_list = dev_manager->get_my_machine_list(dev_manager->get_current_printer_agent_id());// user machine list
    for (const auto& elem : user_machine_list)
    {
        MachineObject* mobj = elem.second;
        if (mobj && (mobj->is_online() || mobj->is_connected()))
        {
            _collect_machine(mobj);
        }
    }
 
    /* Step 2: Sort the lists*/
    std::sort(match_avaliable_list.begin(), match_avaliable_list.end(), _compare_obj_names);
    std::sort(match_inavaliable_list.begin(), match_inavaliable_list.end(), _compare_obj_names);
    std::sort(other_list.begin(), other_list.end(), _compare_obj_names);
 
    /* Step 3: Get the sorted objects*/
    auto _collect_sorted_objs = [](const std::vector<MachineObject*>& obj_list,
                                   std::vector<MachineObject*>& sorted_machine_objs)
    {
        for (auto obj : obj_list)
        {
            sorted_machine_objs.push_back(obj);
        }
    };
 
    // the shown list, STUDIO-8235
    if (cur_selected_obj)
    {
        std::vector<MachineObject*> cur_selected_obj_list{ cur_selected_obj };
        _collect_sorted_objs(cur_selected_obj_list, sorted_machine_objs);
    }
    _collect_sorted_objs(match_avaliable_list, sorted_machine_objs);
    _collect_sorted_objs(match_inavaliable_list, sorted_machine_objs);
    _collect_sorted_objs(other_list, sorted_machine_objs);
}

References _compare_obj_names(), Slic3r::DevPrinterConfigUtil::get_compatible_machine(), Slic3r::DeviceManager::get_current_printer_agent_id(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::DeviceManager::get_my_machine_list(), Slic3r::Preset::get_printer_type(), Slic3r::DeviceManager::get_selected_machine(), Slic3r::MachineObject::is_connected(), Slic3r::MachineObject::is_online(), obj_list(), and Slic3r::PresetBundle::printers.

Referenced by Slic3r::GUI::SelectMachineDialog::update_user_printer().

Here is the call graph for this function:

Here is the caller graph for this function:

_compare_obj_names()

bool Slic3r::GUI::_compare_obj_names ( MachineObject * obj1, MachineObject * obj2 )

static

{
    return obj1->get_dev_name() < obj2->get_dev_name();
}

References Slic3r::MachineObject::get_dev_name().

Referenced by _collect_sorted_machines().

Here is the call graph for this function:

Here is the caller graph for this function:

_copy_dir()

void Slic3r::GUI::_copy_dir ( const fs::path & from_dir, const fs::path & to_dir )

static

{
    try
    {
      if (!fs::exists(from_dir))
      {
          return;
      }
 
      if (!fs::exists(to_dir))
      {
          fs::create_directory(to_dir);
      }
 
      for (const auto &entry : fs::directory_iterator(from_dir))
      {
          const fs::path &source_path   = entry.path();
          const fs::path &relative_path = fs::relative(source_path, from_dir);
          const fs::path &dest_path     = to_dir / relative_path;
 
          if (fs::is_regular_file(source_path))
            {
                if (fs::exists(dest_path))
                {
                    fs::remove(dest_path);
                }
 
                copy_file(source_path, dest_path);
            }
            else if (fs::is_directory(source_path))
            {
                _copy_dir(source_path, dest_path);
            }
      }
    }
    catch (...)
    {
 
    }
}

References _copy_dir(), and Slic3r::copy_file().

Referenced by _copy_dir(), and Slic3r::GUI::HMSQuery::copy_from_data_dir_to_local().

Here is the call graph for this function:

Here is the caller graph for this function:

_DrawRemainArea()

void Slic3r::GUI::_DrawRemainArea ( const MappingItem * item, const TrayData & dd, bool support_remain_dect, wxDC & dc )

static

{
    int to_paint_remain = dd.remain;
 
     /*paint invalid data as 100*/
    if (!support_remain_dect) { to_paint_remain = 100;}
    if (0 > to_paint_remain || to_paint_remain > 100) { to_paint_remain = 100; }
 
    wxSize size          = item->GetSize();
    int x_margin         = item->FromDIP(4);
    int y_margin         = item->FromDIP(2);
    int full_range_width = size.x;
 
    /*range background*/
    dc.SetPen(wxColour("#E4E4E4"));
    dc.SetBrush(wxColour("#E4E4E4"));
    int bg_height = item->FromDIP(6);
    int bg_width  = full_range_width - (2 * x_margin);
    dc.DrawRoundedRectangle(x_margin, y_margin, bg_width, bg_height, item->FromDIP(2));
 
    /*remain fill*/
    if (!dd.name.empty())
    {
        dc.SetPen(dd.colour);
        dc.SetBrush(dd.colour);
        int border        = item->FromDIP(1);
        int remain_width  = (bg_width - (2 * border)) * to_paint_remain / 100;
        int remain_height = bg_height - (2 * border);
        dc.DrawRoundedRectangle(x_margin + border, y_margin + border, remain_width, remain_height, item->FromDIP(2));
    }
}

References Slic3r::GUI::TrayData::colour, Slic3r::GUI::TrayData::name, and Slic3r::GUI::TrayData::remain.

Referenced by Slic3r::GUI::MappingItem::render().

Here is the caller graph for this function:

_get_diff_clr()

wxColour Slic3r::GUI::_get_diff_clr ( wxWindow * win, wxColour pen_clr )

static

{
    if (!wxGetApp().dark_mode())
    {
        if (pen_clr.GetRGB() == wxWHITE->GetRGB())
        {
            static int default_distance = 20;
            pen_clr.Set(pen_clr.Red() - default_distance, pen_clr.Green() - default_distance, pen_clr.Blue() - default_distance, pen_clr.Alpha());
        }
    }
 
    if (pen_clr.Alpha() == 0)/*STUDIO-10249 Make the color visible*/
    {
        pen_clr.Set(pen_clr.Red(), pen_clr.Green(), pen_clr.Blue(), 150);
    }
 
    return pen_clr;
}

Referenced by Slic3r::GUI::AMSRoadDownPart::doRender(), and Slic3r::GUI::AMSRoadUpPart::doRender().

Here is the caller graph for this function:

_get_ext_loc_str()

wxString Slic3r::GUI::_get_ext_loc_str ( const std::unordered_set< int > & extruders, int total_ext_num )

static

{
    assert(!extruders.empty());
    if (total_ext_num == 1)
    {
        return _L("extruder");
    }
    else if (total_ext_num == 2)
    {
        if (extruders.size() == 2)
        {
            return _L("both extruders");
        }
        else if (extruders.size() == 1)
        {
            auto iter = extruders.begin();
            if (*iter == MAIN_EXTRUDER_ID)
            {
                return _L("right extruder");
            }
            else
            {
                return _L("left extruder");
            }
        }
    }
 
    return wxEmptyString;
}

References _L, and MAIN_EXTRUDER_ID.

Referenced by Slic3r::GUI::SelectMachineDialog::update_show_status().

Here is the caller graph for this function:

_get_nozzle_name()

wxString Slic3r::GUI::_get_nozzle_name ( int total_ext_count, int ext_id )

static

{
    if (total_ext_count == 2) {
        if (ext_id == MAIN_EXTRUDER_ID) {
            return _L("right nozzle");
        } else {
            return _L("left nozzle");
        }
    }
 
    return _L("nozzle");
}

References _L, and MAIN_EXTRUDER_ID.

Referenced by Slic3r::GUI::SelectMachineDialog::CheckErrorExtruderNozzleWithSlicing(), and Slic3r::GUI::SelectMachineDialog::update_show_status().

Here is the caller graph for this function:

_get_tips()

wxString Slic3r::GUI::_get_tips ( MachineObject * obj_ )

static

{
    wxString tips;
    tips = obj_->get_printer_type_display_str();
 
    wxString ext_diameter;
    if (obj_->GetExtderSystem()->GetTotalExtderCount() == 1) {
        ext_diameter += format_nozzle_diameter(obj_->GetExtderSystem()->GetNozzleDiameter(0));
    } else if (obj_->GetExtderSystem()->GetTotalExtderCount() == 2) {
        ext_diameter += format_nozzle_diameter(obj_->GetExtderSystem()->GetNozzleDiameter(1));//Left
        ext_diameter += "/";
        ext_diameter += format_nozzle_diameter(obj_->GetExtderSystem()->GetNozzleDiameter(0));
    } else {
        assert(0);
    }
 
    if (!ext_diameter.empty()) {
        tips += "  ";
        tips += ext_diameter;
    }
 
    return tips;
}

References format_nozzle_diameter(), Slic3r::MachineObject::get_printer_type_display_str(), Slic3r::MachineObject::GetExtderSystem(), Slic3r::DevExtderSystem::GetNozzleDiameter(), and Slic3r::DevExtderSystem::GetTotalExtderCount().

Referenced by Slic3r::GUI::PrinterInfoBox::SetPrinters().

Here is the call graph for this function:

Here is the caller graph for this function:

_get_used_nozzle_idxes()

std::unordered_set< int > Slic3r::GUI::_get_used_nozzle_idxes ( )

static

{
    std::unordered_set<int> used_nozzle_idxes;
 
    DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (dev) {
        MachineObject *obj_ = dev->get_selected_machine();
        if (obj_) {
            try {
                PresetBundle *preset_bundle   = wxGetApp().preset_bundle;
                PartPlate *cur_plate          = wxGetApp().plater()->get_partplate_list().get_curr_plate();
                auto       used_filament_idxs = cur_plate->get_used_filaments(); /*the index is started from 1*/
                for (int used_filament_idx : used_filament_idxs) {
                    int used_nozzle_idx = cur_plate->get_physical_extruder_by_filament_id(preset_bundle->full_config(), used_filament_idx);
                    used_nozzle_idxes.insert(used_nozzle_idx);
                }
            } catch (const std::exception &) {}
        }
    }
 
    return used_nozzle_idxes;
}

References Slic3r::PresetBundle::full_config(), Slic3r::GUI::PartPlate::get_physical_extruder_by_filament_id(), Slic3r::DeviceManager::get_selected_machine(), and Slic3r::GUI::PartPlate::get_used_filaments().

Referenced by Slic3r::GUI::SelectMachineDialog::update_show_status().

Here is the call graph for this function:

Here is the caller graph for this function:

_GetLabelColour()

wxColour Slic3r::GUI::_GetLabelColour ( const prePrintInfo & info )

static

{
    if (info.level == Error)
    {
        return wxColour("#D01B1B");
    }
    else if (info.level == Warning)
    {
        return wxColour("#FF6F00");
    }
 
    return *wxBLACK; // Default colour for normal messages
}

References Error, Slic3r::GUI::prePrintInfo::level, and Warning.

Referenced by Slic3r::GUI::PrinterMsgPanel::UpdateInfos().

Here is the caller graph for this function:

_HasAms()

bool Slic3r::GUI::_HasAms ( const std::vector< FilamentInfo > & ams_mapping_result )

static

                                                                       {
    for (const auto &info : ams_mapping_result) {
        if (info.ams_id != VIRTUAL_AMS_MAIN_ID_STR && info.ams_id != VIRTUAL_AMS_DEPUTY_ID_STR && !info.ams_id.empty()) {
            return true;
        }
    }
 
    return false;
}

References VIRTUAL_AMS_DEPUTY_ID_STR, and VIRTUAL_AMS_MAIN_ID_STR.

Referenced by Slic3r::GUI::SelectMachineDialog::on_send_print(), Slic3r::GUI::SelectMachineDialog::on_timer(), and Slic3r::GUI::SelectMachineDialog::update_show_status().

Here is the caller graph for this function:

_HasExt()

bool Slic3r::GUI::_HasExt ( const std::vector< FilamentInfo > & ams_mapping_result )

static

                                                                       {
    if (ams_mapping_result.empty()) {
        return true;
    };
 
    for (const auto &info : ams_mapping_result) {
        if (info.ams_id == VIRTUAL_AMS_MAIN_ID_STR || (info.ams_id == VIRTUAL_AMS_DEPUTY_ID_STR && !info.ams_id.empty())) {
            return true;
        }
    }
 
    return false;
}

References VIRTUAL_AMS_DEPUTY_ID_STR, and VIRTUAL_AMS_MAIN_ID_STR.

Referenced by Slic3r::GUI::SelectMachineDialog::on_send_print(), and Slic3r::GUI::SelectMachineDialog::update_show_status().

Here is the caller graph for this function:

_is_rack_managed_nozzle()

bool Slic3r::GUI::_is_rack_managed_nozzle ( const MachineObject * obj, int nozzle_idx )

static

{
    if (nozzle_idx != MAIN_EXTRUDER_ID)
        return false;
 
    const DevNozzleSystem* nozzle_sys = obj ? obj->GetNozzleSystem() : nullptr;
    return nozzle_sys && nozzle_sys->GetNozzleRack() && nozzle_sys->GetNozzleRack()->IsSupported();
}

References Slic3r::DevNozzleSystem::GetNozzleRack(), Slic3r::MachineObject::GetNozzleSystem(), and MAIN_EXTRUDER_ID.

Referenced by Slic3r::GUI::SelectMachineDialog::update_show_status().

Here is the call graph for this function:

Here is the caller graph for this function:

about()

void Slic3r::GUI::about

(

)

{
    AboutDialog dlg;
    dlg.ShowModal();
}

References Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), Slic3r::GUI::MainFrame::generate_help_menu(), and Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

action_json()

nlohmann::json Slic3r::GUI::action_json

(

const AppAction &

a

)

{
    nlohmann::json j({{"id", a.id()},
                      {"title", a.title()},
                      {"full_label", a.full_label},
                      {"source", a.source_name()},
                      {"group", a.group},
                      {"kind", a.kind == AppActionKind::Plugin ? "plugin" : "command"},
                      {"input", a.input},
                      {"icon", a.icon},
                      {"mode", mode_key(a.required_mode)},
                      {"desc", a.tooltip},
                      {"wiki", !a.help_url.empty()}});
    auto add_alias = [&j](const char* key, const std::string& english, const std::string& local) {
        if (!english.empty() && english != local)
            j[key] = english;
    };
    add_alias("title_en", a.title_en, a.title());
    add_alias("group_en", a.group_en, a.group);
    add_alias("source_en", a.source_en, a.source_name());
    add_alias("full_label_en", a.full_label_en, a.full_label);
    return j;
}

References Slic3r::GUI::AppAction::full_label, Slic3r::GUI::AppAction::full_label_en, Slic3r::GUI::AppAction::group, Slic3r::GUI::AppAction::group_en, Slic3r::GUI::AppAction::help_url, Slic3r::GUI::AppAction::icon, Slic3r::GUI::AppAction::id(), Slic3r::GUI::AppAction::input, Slic3r::GUI::AppAction::kind, Plugin, Slic3r::GUI::AppAction::required_mode, Slic3r::GUI::AppAction::source_en, Slic3r::GUI::AppAction::source_name(), Slic3r::GUI::AppAction::title(), Slic3r::GUI::AppAction::title_en, and Slic3r::GUI::AppAction::tooltip.

Referenced by Slic3r::GUI::DeviceErrorDialog::set_action_json(), and Slic3r::GUI::ActionRegistry::snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

active_host_type()

PrintHostType Slic3r::GUI::active_host_type ( )

static

{
    if (wxGetApp().preset_bundle == nullptr)
        return htOctoPrint;
    return wxGetApp().preset_bundle->printers.get_edited_preset().config.option<ConfigOptionEnum<PrintHostType>>("host_type")->value;
}

References Slic3r::htOctoPrint.

Referenced by Slic3r::GUI::PrinterWebView::load_url().

Here is the caller graph for this function:

add_common_publish_menu_items()

void Slic3r::GUI::add_common_publish_menu_items ( wxMenu * publish_menu, MainFrame * mainFrame )

static

{
#ifndef __WINDOWS__
    append_menu_item(publish_menu, wxID_ANY, _L("Upload Models"), _L("Upload Models"),
        [](wxCommandEvent&) {
            if (!wxGetApp().getAgent()) {
                BOOST_LOG_TRIVIAL(info) << "publish: no agent";
                return;
            }
 
            json j;
            NetworkAgent* agent = GUI::wxGetApp().getAgent();
 
            //if (GUI::wxGetApp().plater()->model().objects.empty()) return;
            wxGetApp().open_publish_page_dialog();
        });
 
    append_menu_item(publish_menu, wxID_ANY, _L("Download Models"), _L("Download Models"),
        [](wxCommandEvent&) {
            if (!wxGetApp().getAgent()) {
                BOOST_LOG_TRIVIAL(info) << "publish: no agent";
                return;
}
 
            //if (GUI::wxGetApp().plater()->model().objects.empty()) return;
            wxGetApp().open_mall_page_dialog();
        });
#endif
}

References _L, and append_menu_item().

Here is the call graph for this function:

add_config_substitutions()

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:
    {
      const std::vector<std::string>& labels = def->enum_labels;
      const std::vector<std::string>& values = def->enum_values;
      int val = conf_substitution.new_value->getInt();
 
      bool is_infill = def->opt_key == "top_surface_pattern"     ||
               def->opt_key == "bottom_surface_pattern" ||
               def->opt_key == "internal_solid_infill_pattern" ||
               def->opt_key == "support_base_pattern" ||
               def->opt_key == "support_interface_pattern" ||
               def->opt_key == "ironing_pattern" ||
               def->opt_key == "support_ironing_pattern" ||
               def->opt_key == "sparse_infill_pattern";
 
      // Each infill doesn't use all list of infill declared in PrintConfig.hpp.
      // So we should "convert" val to the correct one
      if (is_infill) {
        for (const auto& key_val : *def->enum_keys_map)
          if ((int)key_val.second == val) {
            auto it = std::find(values.begin(), values.end(), key_val.first);
            if (it == values.end())
              break;
            auto idx = it - values.begin();
            new_val = wxString("\"") + values[idx] + "\"" + " (" + from_u8(_utf8(labels[idx])) + ")";
            break;
          }
        if (new_val.IsEmpty()) {
          assert(false);
          new_val = _L("Undefined");
        }
      }
      else
        new_val = wxString("\"") + values[val] + "\"" + " (" + from_u8(_utf8(labels[val])) + ")";
      break;
    }
    case coEnums:
    {
      const std::vector<std::string>& labels = def->enum_labels;
      const std::vector<std::string>& values = def->enum_values;
      std::string val = conf_substitution.new_value->serialize();
      new_val = wxString("\"") + from_u8(_utf8(val)) + "\"";
      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 replaced with %2%"), bold_string(conf_substitution.old_value), bold(new_val)) +
           "</td></tr>";
  }
  changes += "</table>";
}

References _, _L, _utf8, bold(), bold_string(), Slic3r::coBool, Slic3r::coBools, Slic3r::coEnum, Slic3r::coEnums, Slic3r::ConfigOptionDef::enum_keys_map, Slic3r::ConfigOptionDef::enum_labels, Slic3r::ConfigOptionDef::enum_values, format_wxstr(), from_u8(), Slic3r::is_infill(), Slic3r::ConfigOptionDef::label, Slic3r::ConfigOptionBoolsTempl< true >::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 )

{
    map.emplace(opt_key + "#0", value);
}

add_menus()

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

extern

add_msg_content()

void Slic3r::GUI::add_msg_content ( wxWindow * parent, wxBoxSizer * content_sizer, wxString msg, bool has_code_excerpts = false, bool is_marked_msg = false, const wxString & link_text = "", std::function< void(const wxString &)> link_callback = nullptr )

static

{
    wxHtmlWindow* html = new wxHtmlWindow(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxHW_SCROLLBAR_AUTO);
    html->SetBackgroundColour(StateColor::darkModeColorFor(*wxWHITE));
 
    // count lines in the message
    int msg_lines = 0;
    if (!has_code_excerpts) {
        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 = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
    wxFont      monospace = wxGetApp().code_font();
    wxColour    text_clr = wxGetApp().get_label_clr_default();
    wxColour    bgr_clr = parent->GetBackgroundColour();
    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__
    }
    auto info_width = 68 * em;
    // 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, info_width);
        page_size       = wxSize(info_width, page_height);
    }
    else {
        wxSize msg_sz;
        if (has_code_excerpts) {
            msg_sz = measure_mixed_text(parent, msg.ToUTF8().data(), font, monospace);
        } else {
            wxClientDC dc(parent);
            dc.SetFont(font); // ORCA without this it calculates bigger size
            msg_sz = dc.GetMultiLineTextExtent(msg);
        }
        msg_sz += parent->FromDIP(wxSize(10,5)); // added extra spacing to prevent wrapping
 
        int page_height = msg_sz.GetY();
        // Reserve the horizontal scrollbar's height, or it clips the last line.
        if (msg_sz.GetX() > info_width)
            page_height += wxSystemSettings::GetMetric(wxSYS_HSCROLL_Y, parent);
        page_size = wxSize(std::min(msg_sz.GetX(), info_width), std::min(page_height, info_width));
        // Extra line breaks in message dialog
        if (link_text.IsEmpty() && !link_callback && is_marked_msg == false && !has_code_excerpts) {//for common text
            html->Destroy();
            if (msg_sz.GetX() < info_width) {//No need for line breaks
                info_width = msg_sz.GetX();
            }
            wxScrolledWindow *scrolledWindow = new wxScrolledWindow(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxVSCROLL);
            scrolledWindow->SetBackgroundColour(*wxWHITE);
            scrolledWindow->SetScrollRate(0, scrolledWindow->FromDIP(20));
            scrolledWindow->EnableScrolling(false, true);
            wxBoxSizer *sizer_scrolled = new wxBoxSizer(wxHORIZONTAL);
            Label *wrapped_text = new Label(scrolledWindow, font, msg, LB_AUTO_WRAP, wxSize(info_width, -1));
            wrapped_text->SetMinSize(wxSize(info_width, -1));
            wrapped_text->SetMaxSize(wxSize(info_width, -1));
            wrapped_text->Wrap(info_width);
            sizer_scrolled->Add(wrapped_text, wxALIGN_LEFT ,0);
            sizer_scrolled->AddSpacer(5);
            sizer_scrolled->AddStretchSpacer();
            scrolledWindow->SetSizer(sizer_scrolled);
            auto info_height = 48 * em;
            if (sizer_scrolled->GetMinSize().GetHeight() < info_height) {
                info_height = sizer_scrolled->GetMinSize().GetHeight();
            }
            scrolledWindow->SetMinSize(wxSize(info_width, info_height));
            scrolledWindow->SetMaxSize(wxSize(info_width, info_height));
            scrolledWindow->FitInside();
            content_sizer->Add(scrolledWindow, 1, wxEXPAND | wxRIGHT, 8);
            return;
        }
    }
    html->SetMinSize(page_size);
 
    std::string msg_escaped;
    if (has_code_excerpts) {
        html->GetParser()->AddTagHandler(new CodeExcerptTagHandler());
        msg_escaped = format_parser_error_html(msg.ToUTF8().data());
    } else {
        msg_escaped = xml_escape(msg.ToUTF8().data(), is_marked_msg);
        boost::replace_all(msg_escaped, "\r\n", "<br>");
        boost::replace_all(msg_escaped, "\n", "<br>");
    }
 
    if (!link_text.IsEmpty() && link_callback) {
        msg_escaped += " <span><a href=\"#\" style=\"color:rgb(0, 150, 136); text-decoration:underline;\">" + std::string(link_text.ToUTF8().data()) + "</a></span>";
    }
 
    html->SetPage("<html><body bgcolor=\"" + bgr_clr_str + "\"><font color=\"" + text_clr_str + "\">" + wxString::FromUTF8(msg_escaped.data()) + "</font></body></html>");
    content_sizer->Add(html, 1, wxEXPAND|wxRIGHT, 8);
    wxGetApp().UpdateDarkUIWin(html);
 
    html->Bind(wxEVT_HTML_LINK_CLICKED, [=](wxHtmlLinkEvent& event) {
        if (link_callback)
            link_callback(event.GetLinkInfo().GetHref());
    });
}

References StateColor::darkModeColorFor(), DPI_DEFAULT, Slic3r::encode_color(), format_parser_error_html(), get_dpi_for_window(), LB_AUTO_WRAP, measure_mixed_text(), Label::Wrap(), and Slic3r::xml_escape().

Referenced by Slic3r::GUI::ErrorDialog::ErrorDialog(), Slic3r::GUI::InfoDialog::InfoDialog(), Slic3r::GUI::MessageDialog::MessageDialog(), Slic3r::GUI::RichMessageDialog::RichMessageDialog(), Slic3r::GUI::WarningDialog::WarningDialog(), and Slic3r::GUI::DownloadDialog::SetExtendedMessage().

Here is the call graph for this function:

Here is the caller graph for this function:

add_page_strings()

void Slic3r::GUI::add_page_strings ( wxWebView * webView )

static

{
    const nlohmann::json strings = {
        {"printer_connection", _u8L("Printer Connection")},
        {"printer_connection_setup", _u8L("Please set up your printer connection to view the device.")},
    };
    webView->AddUserScript(wxString::FromUTF8(WebViewHostDialog::localized_strings_script(strings)));
}

References _u8L, and Slic3r::GUI::WebViewHostDialog::localized_strings_script().

Referenced by Slic3r::GUI::PrinterWebView::create_browser().

Here is the call graph for this function:

Here is the caller graph for this function:

add_row_to_table()

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();
}

Referenced by add_strings_row_to_table().

Here is the caller graph for this function:

add_strings_row_to_table()

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().

Here is the call graph for this function:

Here is the caller graph for this function:

add_swatch()

void Slic3r::GUI::add_swatch ( ImDrawList * draw_list, const ImVec2 & min, const ImVec2 & max, const ColorRGBA & color )

static

{
    if (color.is_transparent()) {
        for (int i = 0; i < 4; ++i)
            for (int j = 0; j < 4; ++j)
                draw_list->AddRectFilled(ImLerp(min, max, ImVec2(0.25f * i, 0.25f * j)), ImLerp(min, max, ImVec2(0.25f * (i + 1), 0.25f * (j + 1))),
                                         (i + j) % 2 == 0 ? IM_COL32_WHITE : IM_COL32(217, 217, 217, 255));
    }
    draw_list->AddRectFilled(min, max, ImGuiWrapper::to_ImU32(color));
}

References Slic3r::ColorRGBA::is_transparent(), and Slic3r::GUI::ImGuiWrapper::to_ImU32().

Referenced by Slic3r::GUI::GCodeViewer::render_all_plates_stats(), and Slic3r::GUI::GCodeViewer::render_legend().

Here is the call graph for this function:

Here is the caller graph for this function:

add_volume_with_gizmo()

void Slic3r::GUI::add_volume_with_gizmo ( GLGizmosManager::EType gizmo_type, ModelVolumeType type )

static

{
    Plater* pl = plater();
    if (!pl)
        return;
    const GLCanvas3D* canvas = pl->canvas3D();
    if (!canvas)
        return;
    GLGizmoBase* gizmo_base = canvas->get_gizmos_manager().get_gizmo(gizmo_type);
    if (!gizmo_base)
        return;
 
    ModelVolumeType volume_type = type;
    // no selected object means create new object
    if (volume_type == ModelVolumeType::INVALID)
        volume_type = ModelVolumeType::MODEL_PART;
 
    auto screen_position = canvas->get_popup_menu_position();
    if (gizmo_type == GLGizmosManager::Emboss) {
        auto* emboss = dynamic_cast<GLGizmoEmboss*>(gizmo_base);
        if (emboss == nullptr)
            return;
        if (screen_position.has_value())
            emboss->create_volume(volume_type, *screen_position);
        else
            emboss->create_volume(volume_type);
    } else if (gizmo_type == GLGizmosManager::Svg) {
        auto* svg = dynamic_cast<GLGizmoSVG*>(gizmo_base);
        if (svg == nullptr)
            return;
        if (screen_position.has_value())
            svg->create_volume(volume_type, *screen_position);
        else
            svg->create_volume(volume_type);
    }
}

References add_volume_with_gizmo(), Slic3r::GUI::Plater::canvas3D(), Slic3r::GUI::GLGizmoEmboss::create_volume(), Slic3r::GUI::GLGizmoSVG::create_volume(), Slic3r::GUI::GLGizmosManager::Emboss, Slic3r::GUI::GLGizmosManager::get_gizmo(), Slic3r::GUI::GLCanvas3D::get_gizmos_manager(), Slic3r::GUI::GLCanvas3D::get_popup_menu_position(), Slic3r::INVALID, Slic3r::MODEL_PART, plater(), and Slic3r::GUI::GLGizmosManager::Svg.

Referenced by Slic3r::GUI::MenuFactory::add_svg_volume(), Slic3r::GUI::MenuFactory::add_text_volume(), add_volume_with_gizmo(), and append_menu_itemm_add_().

Here is the call graph for this function:

Here is the caller graph for this function:

adjust_dialog_in_screen()

void Slic3r::GUI::adjust_dialog_in_screen ( DPIDialog * dialog )

static

                                                       {
    wxSize screen_size = wxGetDisplaySize();
    int    pos_x, pos_y, size_x, size_y, screen_width, screen_height, dialog_x, dialog_y;
    pos_x         = dialog->GetPosition().x;
    pos_y         = dialog->GetPosition().y;
    size_x        = dialog->GetSize().x;
    size_y        = dialog->GetSize().y;
    screen_width  = screen_size.GetWidth();
    screen_height = screen_size.GetHeight();
    dialog_x      = pos_x;
    dialog_y      = pos_y;
    if (pos_x + size_x > screen_width) {
        int exceed_x = pos_x + size_x - screen_width;
        dialog_x -= exceed_x;
    }
    if (pos_y + size_y > screen_height - 50) {
        int exceed_y = pos_y + size_y - screen_height + 50;
        dialog_y -= exceed_y;
    }
    if (pos_x != dialog_x || pos_y != dialog_y) { dialog->SetPosition(wxPoint(dialog_x, dialog_y)); }
}

Referenced by Slic3r::GUI::ExportConfigsDialog::select_curr_radiobox(), Slic3r::GUI::CreateFilamentPresetDialog::update_dialog_size(), Slic3r::GUI::CreatePrinterPresetDialog::update_preset_list_size(), and Slic3r::GUI::EditFilamentPresetDialog::update_preset_tree().

Here is the caller graph for this function:

adjust_settings_for_flowrate_calib()

void Slic3r::GUI::adjust_settings_for_flowrate_calib	(	ModelObjectPtrs &	objects,
		bool	linear,
		int	pass,
		InfillPattern	pattern )

– scale –

{
    auto print_config = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
    auto printer_config  = &wxGetApp().preset_bundle->printers.get_edited_preset().config;
    auto filament_config = &wxGetApp().preset_bundle->filaments.get_edited_preset().config;

    // model is created for a 0.4 nozzle, scale z with nozzle size.
    const ConfigOptionFloats* nozzle_diameter_config = printer_config->option<ConfigOptionFloats>("nozzle_diameter");
    std::vector<int> extruder_types         = printer_config->option<ConfigOptionEnumsGeneric>("extruder_type")->values;
    std::vector<int> nozzle_volume_types    = wxGetApp().preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type")->values;
 
    assert(nozzle_diameter_config->values.size() > 0);
    float nozzle_diameter = nozzle_diameter_config->values[0];
    float xyScale = nozzle_diameter / 0.6;
    //scale z to have 10 layers
    // 2 bottom, 5 top, 3 sparse infill
    double first_layer_height = print_config->option<ConfigOptionFloat>("initial_layer_print_height")->value;
    double layer_height = nozzle_diameter / 2.0; // prefer 0.2 layer height for 0.4 nozzle
    first_layer_height = std::max(first_layer_height, layer_height);
 
    const auto canvas    = wxGetApp().plater()->canvas3D();
    auto&      selection = canvas->get_selection();
    selection.setup_cache();
    TransformationType transformation_type;
    transformation_type.set_relative();
    float zscale = (first_layer_height + 9 * layer_height) / 2;
    // only enlarge
    if (xyScale > 1.2) {
        selection.scale({xyScale, xyScale, zscale}, transformation_type);
    } else {
        selection.scale({1, 1, zscale}, transformation_type);
    }
    canvas->do_scale("");
 
    auto cur_flowrate = filament_config->option<ConfigOptionFloats>("filament_flow_ratio")->get_at(0); // TODO: per-filament param
    // Cap the speeds for the extrusion the test prints, not the profile's line width and layer height
    const float infill_line_width = nozzle_diameter * 1.2f;
    std::vector<double> internal_solid_speeds = generate_max_speed_parameter_value("internal_solid_infill_speed", infill_line_width, layer_height, linear, pass);
    std::vector<double> top_surface_speeds = generate_max_speed_parameter_value("top_surface_speed", infill_line_width, layer_height, linear, pass);
 
    // adjust parameters
    for (auto _obj : objects) {
        _obj->ensure_on_bed();
        _obj->config.set_key_value("wall_loops", new ConfigOptionInt(1));
        _obj->config.set_key_value("only_one_wall_top", new ConfigOptionBool(true));
        _obj->config.set_key_value("thick_internal_bridges", new ConfigOptionBool(false));
        _obj->config.set_key_value("enable_extra_bridge_layer", new ConfigOptionEnum<EnableExtraBridgeLayer>(eblDisabled));
        _obj->config.set_key_value("internal_bridge_density", new ConfigOptionPercent(100));
        _obj->config.set_key_value("sparse_infill_density", new ConfigOptionPercent(35));
        _obj->config.set_key_value("min_width_top_surface", new ConfigOptionFloatOrPercent(100,true));
        _obj->config.set_key_value("bottom_shell_layers", new ConfigOptionInt(2));
        _obj->config.set_key_value("top_shell_layers", new ConfigOptionInt(5));
        _obj->config.set_key_value("top_shell_thickness", new ConfigOptionFloat(0));
        _obj->config.set_key_value("bottom_shell_thickness", new ConfigOptionFloat(0));
        _obj->config.set_key_value("detect_thin_wall", new ConfigOptionBool(true));
        _obj->config.set_key_value("filter_out_gap_fill", new ConfigOptionFloat(0));
        _obj->config.set_key_value("sparse_infill_pattern", new ConfigOptionEnum<InfillPattern>(ipRectilinear));
        _obj->config.set_key_value("top_surface_line_width", new ConfigOptionFloatOrPercent(infill_line_width, false));
        _obj->config.set_key_value("internal_solid_infill_line_width", new ConfigOptionFloatOrPercent(infill_line_width, false));
        // ORCA: use the pattern parameter
        _obj->config.set_key_value("top_surface_pattern", new ConfigOptionEnum<InfillPattern>(pattern));
        const auto *top_solid_flow = dynamic_cast<const ConfigOptionFloatsNullable *>(_obj->config.option("top_solid_infill_flow_ratio"));
        _obj->config.set_key_value("top_solid_infill_flow_ratio",
                                   new ConfigOptionFloatsNullable(top_solid_flow ? top_solid_flow->size() : 1, 1.0f));
        _obj->config.set_key_value("infill_direction", new ConfigOptionFloat(45));
        _obj->config.set_key_value("solid_infill_direction", new ConfigOptionFloat(135));
        _obj->config.set_key_value("center_of_surface_pattern", new ConfigOptionEnum<CenterOfSurfacePattern>(CenterOfSurfacePattern::Each_Surface));
        _obj->config.set_key_value("separated_infills", new ConfigOptionBool(false));
        _obj->config.set_key_value("align_infill_direction_to_model", new ConfigOptionBool(true));
        _obj->config.set_key_value("ironing_type", new ConfigOptionEnum<IroningType>(IroningType::NoIroning));
        _obj->config.set_key_value("internal_solid_infill_speed", new ConfigOptionFloatsNullable(internal_solid_speeds));
        _obj->config.set_key_value("top_surface_speed", new ConfigOptionFloatsNullable(top_surface_speeds));
        _obj->config.set_key_value("seam_slope_type", new ConfigOptionEnum<SeamScarfType>(SeamScarfType::None));
        _obj->config.set_key_value("gap_fill_target", new ConfigOptionEnum<GapFillTarget>(GapFillTarget::gftNowhere));
        print_config->set_key_value("max_volumetric_extrusion_rate_slope", new ConfigOptionFloat(0));
        // ORCA: request the calibration's special toolpath order (chords first, center spiral
        // last and inside-out) so opposing directions collide into the tactile lip the test
        // reads. The special order only applies while the fill order is Default, so reset the
        // profile's fill order on the calibration objects; changing the setting on the object
        // afterwards deliberately overrides the special order.
        _obj->config.set_key_value("calib_flowrate_topinfill_special_order", new ConfigOptionBool(true));
        _obj->config.set_key_value("top_surface_fill_order", new ConfigOptionEnum<SurfaceFillOrder>(SurfaceFillOrder::Default));
 
        // extract flowrate from name, filename format: flowrate_xxx
        std::string obj_name = _obj->name;
        assert(obj_name.length() > 9);
        obj_name = obj_name.substr(9);
        if (obj_name[0] == 'm')
            obj_name[0] = '-';
        // Orca: force set locale to C to avoid parsing error
        const std::string _loc = std::setlocale(LC_NUMERIC, nullptr);
        std::setlocale(LC_NUMERIC,"C");
        auto              modifier  = 1.0f;
        try {
            modifier = stof(obj_name);
        } catch (...) {
        }
        // restore locale
        std::setlocale(LC_NUMERIC, _loc.c_str());
 
        if(linear)
            _obj->config.set_key_value("print_flow_ratio", new ConfigOptionFloat((cur_flowrate + modifier)/cur_flowrate));
        else
            _obj->config.set_key_value("print_flow_ratio", new ConfigOptionFloat(1.0f + modifier/100.f));
 
    }
 
    print_config->set_key_value("layer_height", new ConfigOptionFloat(layer_height));
    print_config->set_key_value("alternate_extra_wall", new ConfigOptionBool(false));
    print_config->set_key_value("initial_layer_print_height", new ConfigOptionFloat(first_layer_height));
    print_config->set_key_value("reduce_crossing_wall", new ConfigOptionBool(true));
    print_config->set_key_value("enable_wrapping_detection", new ConfigOptionBool(false));
 
    wxGetApp().get_tab(Preset::TYPE_PRINT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_PRINTER)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_PRINT)->reload_config();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->reload_config();
    wxGetApp().get_tab(Preset::TYPE_PRINTER)->reload_config();
}

References Slic3r::ConfigOptionFloat, Slic3r::Default, Slic3r::Each_Surface, Slic3r::eblDisabled, generate_max_speed_parameter_value(), Slic3r::gftNowhere, Slic3r::ipRectilinear, layer_height, Slic3r::NoIroning, Slic3r::None, Slic3r::nozzle_diameter(), printer_config(), Slic3r::GUI::Selection::scale(), Slic3r::GUI::TransformationType::set_relative(), Slic3r::GUI::Selection::setup_cache(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, and Slic3r::ConfigOptionVector< double >::values.

Referenced by Slic3r::GUI::Plater::calib_flowrate().

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_expolygon_triangles()

void Slic3r::GUI::append_expolygon_triangles ( GLModel::Geometry & init_data, const ExPolygon & expolygon, float z )

static

{
    const std::vector<Vec2f> triangles = triangulate_expolygon_2f(expolygon, NORMALS_UP);
    if (triangles.empty() || triangles.size() % 3 != 0)
        return;
 
    Vec2f min = triangles.front();
    Vec2f max = min;
    for (const Vec2f &v : triangles) {
        min = min.cwiseMin(v).eval();
        max = max.cwiseMax(v).eval();
    }
 
    const Vec2f size = max - min;
    if (size.x() <= 0.0f || size.y() <= 0.0f)
        return;
 
    Vec2f inv_size = size.cwiseInverse();
    inv_size.y() *= -1.0f;
 
    init_data.reserve_vertices(init_data.vertices_count() + triangles.size());
    init_data.reserve_indices(init_data.indices_count() + triangles.size());
    for (const Vec2f &v : triangles) {
        init_data.add_vertex(Vec3f(v.x(), v.y(), z), (Vec2f)(v - min).cwiseProduct(inv_size).eval());
        const unsigned int vertices_counter = (unsigned int)init_data.vertices_count();
        if (vertices_counter % 3 == 0)
            init_data.add_triangle(vertices_counter - 3, vertices_counter - 2, vertices_counter - 1);
    }
}

References Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::indices_count(), Slic3r::NORMALS_UP, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::triangulate_expolygon_2f(), and Slic3r::GUI::GLModel::Geometry::vertices_count().

Referenced by init_model_from_expolygons(), and init_model_from_polygons().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_itemm_add_()

void Slic3r::GUI::append_menu_itemm_add_ ( const wxString & name, GLGizmosManager::EType gizmo_type, wxMenu * menu, ModelVolumeType type, bool is_submenu_item )

static

                                                                                                                                                    {
    auto add_ = [type, gizmo_type](const wxCommandEvent & /*unnamed*/) { add_volume_with_gizmo(gizmo_type, type); };
 
    if (type == ModelVolumeType::MODEL_PART || type == ModelVolumeType::NEGATIVE_VOLUME || type == ModelVolumeType::PARAMETER_MODIFIER ||
        type == ModelVolumeType::INVALID // cannot use gizmo without selected object
    ) {
        wxString item_name = wxString(is_submenu_item ? "" : _(ADD_VOLUME_MENU_ITEMS[int(type)].first) + ": ") + name;
        menu->AppendSeparator();
        auto def_icon_name = (gizmo_type == GLGizmosManager::Emboss) ? "menu_obj_text" : "menu_obj_svg";
        const std::string icon_name = is_submenu_item ? def_icon_name : ADD_VOLUME_MENU_ITEMS[int(type)].second;
        append_menu_item(menu, wxID_ANY, item_name, "", add_, icon_name, menu);
    }
}

References _, ADD_VOLUME_MENU_ITEMS, add_volume_with_gizmo(), append_menu_item(), append_menu_itemm_add_(), Slic3r::GUI::GLGizmosManager::Emboss, Slic3r::INVALID, Slic3r::MODEL_PART, Slic3r::NEGATIVE_VOLUME, and Slic3r::PARAMETER_MODIFIER.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_add_svg(), Slic3r::GUI::MenuFactory::append_menu_item_add_text(), and append_menu_itemm_add_().

Here is the call graph for this function:

Here is the caller graph for this function:

append_paint_patch()

void Slic3r::GUI::append_paint_patch ( GLModel::Geometry & out, const indexed_triangle_set & patch, const std::vector< Vec3f > * displaced )

static

{
    unsigned n = unsigned(out.vertices_count());
    for (const stl_triangle_vertex_indices &tri : patch.indices) {
        for (int i = 0; i < 3; ++i) {
            const size_t idx = size_t(tri[i]);
            out.add_vertex((displaced != nullptr && idx < displaced->size()) ? (*displaced)[idx] : patch.vertices[idx]);
        }
        out.add_triangle(n, n + 1, n + 2);
        n += 3;
    }
}

References Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), and Slic3r::GUI::GLModel::Geometry::vertices_count().

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::rebuild_other_paint_overlay(), and Slic3r::GUI::GLGizmoTextureDisplacement::rebuild_paint_overlay().

Here is the call graph for this function:

Here is the caller graph for this function:

append_root_node()

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:

apply_dark_ui_to_lazy_panel()

void Slic3r::GUI::apply_dark_ui_to_lazy_panel

(

wxWindow *

panel

)

{
#ifdef _MSW_DARK_MODE
    wxGetApp().UpdateDarkUIWin(panel);
#endif
}

aui_pane_layout_entry()

std::string Slic3r::GUI::aui_pane_layout_entry	(	const std::string &	layout,
		const std::string &	pane_name )

{
    // Panes are separated by '|'; SavePerspective() escapes a '|' inside a caption as "\|".
    const std::string prefix = "name=" + pane_name + ";";
    size_t            begin  = 0;
    for (size_t i = 0; i <= layout.size(); ++i) {
        if (i < layout.size() && (layout[i] != '|' || (i > 0 && layout[i - 1] == '\\')))
            continue;
        if (layout.compare(begin, prefix.size(), prefix) == 0)
            return layout.substr(begin, i - begin);
        begin = i + 1;
    }
    return {};
}

Referenced by Slic3r::GUI::Plater::priv::add_dock_pane().

Here is the caller graph for this function:

auto_mix_mode_label()

wxString Slic3r::GUI::auto_mix_mode_label ( TextureAutoMixMode mode )

static

{
    return mode == TextureAutoMixMode::CMYW ? _L("One-click CMYW auto-mix") :
                                             _L("One-click RYBW auto-mix");
}

References _L, and CMYW.

Referenced by Slic3r::GUI::TextureImportDialog::build_mapping_panel(), Slic3r::GUI::AutoMixSelectPopup::create_item_row(), and Slic3r::GUI::TextureImportDialog::set_auto_mix_mode().

Here is the caller graph for this function:

bed_stride_x()

double Slic3r::GUI::bed_stride_x

(

const Plater *

plater

)

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

References LOGICAL_BED_GAP, and plater().

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

Here is the call graph for this function:

Here is the caller graph for this function:

bed_stride_y()

double Slic3r::GUI::bed_stride_y

(

const Plater *

plater

)

                                          {
    double beddepth = plater->build_volume().bounding_box().size().y();
    return (1. + LOGICAL_BED_GAP) * beddepth;
}

References LOGICAL_BED_GAP, and plater().

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

Here is the call graph for this function:

Here is the caller graph for this function:

bed_toggle_text()

wxString Slic3r::GUI::bed_toggle_text ( bool shown )

static

{
    return shown ? _L("Hide the printer bed and its plate grid")
                 : _L("Show the printer bed and its plate grid");
}

References _L.

Referenced by Slic3r::GUI::DesignPanel::DesignPanel(), and Slic3r::GUI::DesignPanel::refresh_pinned().

Here is the caller graph for this function:

begin_menu()

bool Slic3r::GUI::begin_menu	(	const char *	label,
		bool	enabled )

{
    ImGuiWindow *window = ImGui::GetCurrentWindow();
    if (window->SkipItems) return false;
 
    ImGuiContext &    g            = *GImGui;
    const ImGuiStyle &style        = g.Style;
    const ImGuiID     id           = window->GetID(label);
    bool              menu_is_open = ImGui::IsPopupOpen(id, ImGuiPopupFlags_None);
 
    // Sub-menus are ChildWindow so that mouse can be hovering across them (otherwise top-most popup menu would steal focus and not allow hovering on parent menu)
    ImGuiWindowFlags flags = ImGuiWindowFlags_ChildMenu | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar |
                             ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoNavFocus;
    if (window->Flags & (ImGuiWindowFlags_Popup | ImGuiWindowFlags_ChildMenu)) flags |= ImGuiWindowFlags_ChildWindow;
 
    // If a menu with same the ID was already submitted, we will append to it, matching the behavior of Begin().
    // We are relying on a O(N) search - so O(N log N) over the frame - which seems like the most efficient for the expected small amount of BeginMenu() calls per frame.
    // If somehow this is ever becoming a problem we can switch to use e.g. ImGuiStorage mapping key to last frame used.
    if (g.MenusIdSubmittedThisFrame.contains(id)) {
        if (menu_is_open)
            menu_is_open = ImGui::BeginPopupEx(id, flags); // menu_is_open can be 'false' when the popup is completely clipped (e.g. zero size display)
        else
            g.NextWindowData.ClearFlags(); // we behave like Begin() and need to consume those values
        return menu_is_open;
    }
 
    // Tag menu as used. Next time BeginMenu() with same ID is called it will append to existing menu
    g.MenusIdSubmittedThisFrame.push_back(id);
 
    ImVec2 label_size = ImGui::CalcTextSize(label, NULL, true);
    bool   pressed;
    bool   menuset_is_open = !(window->Flags & ImGuiWindowFlags_Popup) &&
                           (g.OpenPopupStack.Size > g.BeginPopupStack.Size && g.OpenPopupStack[g.BeginPopupStack.Size].OpenParentId == window->IDStack.back());
    ImGuiWindow *backed_nav_window = g.NavWindow;
    if (menuset_is_open) g.NavWindow = window; // Odd hack to allow hovering across menus of a same menu-set (otherwise we wouldn't be able to hover parent)
 
    // The reference position stored in popup_pos will be used by Begin() to find a suitable position for the child menu,
    // However the final position is going to be different! It is chosen by FindBestWindowPosForPopup().
    // e.g. Menus tend to overlap each other horizontally to amplify relative Z-ordering.
    ImVec2 popup_pos, pos = window->DC.CursorPos;
    if (window->DC.LayoutType == ImGuiLayoutType_Horizontal) {
        // Menu inside an horizontal menu bar
        // Selectable extend their highlight by half ItemSpacing in each direction.
        // For ChildMenu, the popup position will be overwritten by the call to FindBestWindowPosForPopup() in Begin()
        popup_pos = ImVec2(pos.x - 1.0f - IM_FLOOR(style.ItemSpacing.x * 0.5f), pos.y - style.FramePadding.y + window->MenuBarHeight());
        window->DC.CursorPos.x += IM_FLOOR(style.ItemSpacing.x * 0.5f);
        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(style.ItemSpacing.x * 2.0f, style.ItemSpacing.y));
        float w = label_size.x;
        pressed = selectable(label, menu_is_open,
                             ImGuiSelectableFlags_NoHoldingActiveID | ImGuiSelectableFlags_SelectOnClick | ImGuiSelectableFlags_DontClosePopups |
                                 (!enabled ? ImGuiSelectableFlags_Disabled : 0),
                             ImVec2(w, 0.0f));
        ImGui::PopStyleVar();
        window->DC.CursorPos.x += IM_FLOOR(
            style.ItemSpacing.x *
            (-1.0f +
             0.5f)); // -1 spacing to compensate the spacing added when Selectable() did a SameLine(). It would also work to call SameLine() ourselves after the PopStyleVar().
    } else {
        // Menu inside a menu
        // (In a typical menu window where all items are BeginMenu() or MenuItem() calls, extra_w will always be 0.0f.
        //  Only when they are other items sticking out we're going to add spacing, yet only register minimum width into the layout system.
        popup_pos      = ImVec2(pos.x, pos.y - style.WindowPadding.y);
        float min_w    = window->DC.MenuColumns.DeclColumns(label_size.x, 0.0f, IM_FLOOR(g.FontSize * 1.20f)); // Feedback to next frame
        float extra_w  = ImMax(0.0f, ImGui::GetContentRegionAvail().x - min_w);
        pressed        = selectable(label, menu_is_open,
                             ImGuiSelectableFlags_NoHoldingActiveID | ImGuiSelectableFlags_SelectOnClick | ImGuiSelectableFlags_DontClosePopups |
                                 ImGuiSelectableFlags_SpanAvailWidth | (!enabled ? ImGuiSelectableFlags_Disabled : 0),
                             ImVec2(min_w, 0.0f));
        ImU32 text_col = ImGui::GetColorU32(enabled ? ImGuiCol_Text : ImGuiCol_TextDisabled);
        ImGui::RenderArrow(window->DrawList, pos + ImVec2(window->DC.MenuColumns.Pos[2] + extra_w + g.FontSize * 0.30f, 0.0f), text_col, ImGuiDir_Right);
    }
 
    const bool hovered = enabled && ImGui::ItemHoverable(window->DC.LastItemRect, id);
    if (menuset_is_open) g.NavWindow = backed_nav_window;
 
    bool want_open  = false;
    bool want_close = false;
    if (window->DC.LayoutType == ImGuiLayoutType_Vertical) // (window->Flags & (ImGuiWindowFlags_Popup|ImGuiWindowFlags_ChildMenu))
    {
        // Close menu when not hovering it anymore unless we are moving roughly in the direction of the menu
        // Implement http://bjk5.com/post/44698559168/breaking-down-amazons-mega-dropdown to avoid using timers, so menus feels more reactive.
        bool moving_toward_other_child_menu = false;
 
        ImGuiWindow *child_menu_window = (g.BeginPopupStack.Size < g.OpenPopupStack.Size && g.OpenPopupStack[g.BeginPopupStack.Size].SourceWindow == window) ?
                                             g.OpenPopupStack[g.BeginPopupStack.Size].Window :
                                             NULL;
        if (g.HoveredWindow == window && child_menu_window != NULL && !(window->Flags & ImGuiWindowFlags_MenuBar)) {
            // FIXME-DPI: Values should be derived from a master "scale" factor.
            ImRect next_window_rect = child_menu_window->Rect();
            ImVec2 ta               = g.IO.MousePos - g.IO.MouseDelta;
            ImVec2 tb               = (window->Pos.x < child_menu_window->Pos.x) ? next_window_rect.GetTL() : next_window_rect.GetTR();
            ImVec2 tc               = (window->Pos.x < child_menu_window->Pos.x) ? next_window_rect.GetBL() : next_window_rect.GetBR();
            float  extra            = ImClamp(ImFabs(ta.x - tb.x) * 0.30f, 5.0f, 30.0f); // add a bit of extra slack.
            ta.x += (window->Pos.x < child_menu_window->Pos.x) ? -0.5f : +0.5f;          // to avoid numerical issues
            tb.y = ta.y +
                   ImMax((tb.y - extra) - ta.y, -100.0f); // triangle is maximum 200 high to limit the slope and the bias toward large sub-menus // FIXME: Multiply by fb_scale?
            tc.y                           = ta.y + ImMin((tc.y + extra) - ta.y, +100.0f);
            moving_toward_other_child_menu = ImTriangleContainsPoint(ta, tb, tc, g.IO.MousePos);
            // GetForegroundDrawList()->AddTriangleFilled(ta, tb, tc, moving_within_opened_triangle ? IM_COL32(0,128,0,128) : IM_COL32(128,0,0,128)); // [DEBUG]
        }
        if (menu_is_open && !hovered && g.HoveredWindow == window && g.HoveredIdPreviousFrame != 0 && g.HoveredIdPreviousFrame != id && !moving_toward_other_child_menu)
            want_close = true;
 
        if (!menu_is_open && hovered && pressed) // Click to open
            want_open = true;
        else if (!menu_is_open && hovered && !moving_toward_other_child_menu) // Hover to open
            want_open = true;
 
        if (g.NavActivateId == id) {
            want_close = menu_is_open;
            want_open  = !menu_is_open;
        }
        if (g.NavId == id && g.NavMoveRequest && g.NavMoveDir == ImGuiDir_Right) // Nav-Right to open
        {
            want_open = true;
            ImGui::NavMoveRequestCancel();
        }
    } else {
        // Menu bar
        if (menu_is_open && pressed && menuset_is_open) // Click an open menu again to close it
        {
            want_close = true;
            want_open = menu_is_open = false;
        } else if (pressed || (hovered && menuset_is_open && !menu_is_open)) // First click to open, then hover to open others
        {
            want_open = true;
        } else if (g.NavId == id && g.NavMoveRequest && g.NavMoveDir == ImGuiDir_Down) // Nav-Down to open
        {
            want_open = true;
            ImGui::NavMoveRequestCancel();
        }
    }
 
    if (!enabled) // explicitly close if an open menu becomes disabled, facilitate users code a lot in pattern such as 'if (BeginMenu("options", has_object)) { ..use object.. }'
        want_close = true;
    if (want_close && ImGui::IsPopupOpen(id, ImGuiPopupFlags_None)) ImGui::ClosePopupToLevel(g.BeginPopupStack.Size, true);
 
    IMGUI_TEST_ENGINE_ITEM_INFO(id, label, window->DC.LastItemStatusFlags | ImGuiItemStatusFlags_Openable | (menu_is_open ? ImGuiItemStatusFlags_Opened : 0));
 
    if (!menu_is_open && want_open && g.OpenPopupStack.Size > g.BeginPopupStack.Size) {
        // Don't recycle same menu level in the same frame, first close the other menu and yield for a frame.
        ImGui::OpenPopup(label);
        return false;
    }
 
    menu_is_open |= want_open;
    if (want_open) ImGui::OpenPopup(label);
 
    if (menu_is_open) {
        ImGui::SetNextWindowPos(popup_pos,
                                ImGuiCond_Always);     // Note: this is super misleading! The value will serve as reference for FindBestWindowPosForPopup(), not actual pos.
        menu_is_open = ImGui::BeginPopupEx(id, flags); // menu_is_open can be 'false' when the popup is completely clipped (e.g. zero size display)
    } else {
        g.NextWindowData.ClearFlags(); // We behave like Begin() and need to consume those values
    }
 
    return menu_is_open;
}

References ImRect, selectable(), and style.

Referenced by Slic3r::GUI::IMSlider::render_add_menu(), and Slic3r::GUI::IMSlider::render_edit_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

belt_calib_flip_ringing_tower()

void Slic3r::GUI::belt_calib_flip_ringing_tower ( Model & model )

static

{
    double angle_rad = 0.;
    Vec3d  axis      = Vec3d::UnitX();
    if (belt_calib_rotation_params(angle_rad, axis) && !model.objects.empty())
        model.objects.front()->rotate(M_PI, Vec3d::UnitZ());
}

References belt_calib_rotation_params(), M_PI, Slic3r::GUI::Plater::model(), and Slic3r::Model::objects.

Referenced by Slic3r::GUI::Plater::Calib_Cornering(), Slic3r::GUI::Plater::calib_input_shaping_damp(), and Slic3r::GUI::Plater::calib_input_shaping_freq().

Here is the call graph for this function:

Here is the caller graph for this function:

belt_calib_rotation_params()

bool Slic3r::GUI::belt_calib_rotation_params ( double & angle_rad, Vec3d & axis )

static

{
    const auto& printer_config = wxGetApp().preset_bundle->printers.get_edited_preset().config;
    const auto* belt_opt = printer_config.option<ConfigOptionBool>("belt_printer");
    if (belt_opt == nullptr || !belt_opt->value)
        return false;
    const auto* axis_opt  = printer_config.option<ConfigOptionEnum<BeltRotationAxis>>("belt_slice_rotation");
    const auto* angle_opt = printer_config.option<ConfigOptionFloat>("belt_slice_rotation_angle");
    if (axis_opt == nullptr || angle_opt == nullptr)
        return false;
    switch (axis_opt->value) {
    case BeltRotationAxis::X: axis = Vec3d::UnitX(); break;
    case BeltRotationAxis::Y: axis = Vec3d::UnitY(); break;
    // Z rotation is an in-plane spin and None means no tilt; objects already
    // slice upright in those cases and need no special handling.
    default: return false;
    }
    angle_rad = -Geometry::deg2rad(angle_opt->value);
    return std::abs(angle_rad) > EPSILON;
}

References Slic3r::Geometry::deg2rad(), EPSILON, printer_config(), Slic3r::ConfigOptionSingle< T >::value, Slic3r::X, and Slic3r::Y.

Referenced by Slic3r::GUI::Plater::_calib_apply_belt_mode(), belt_calib_flip_ringing_tower(), Slic3r::GUI::Plater::calib_pa(), and Slic3r::GUI::Plater::calib_temp().

Here is the call graph for this function:

Here is the caller graph for this function:

belt_temp_tower_asset()

std::string Slic3r::GUI::belt_temp_tower_asset ( const Calib_Params & params )

static

{
    const int t_start = (int) lround(params.start);
    const int t_end   = (int) lround(params.end);
    return Slic3r::resources_dir() + "/calib/temperature_tower/belt_temp_tower_" +
           std::to_string(t_start) + "_" + std::to_string(t_end) + ".stl";
}

References Slic3r::Calib_Params::end, Slic3r::resources_dir(), and Slic3r::Calib_Params::start.

Referenced by Slic3r::GUI::Plater::calib_temp().

Here is the call graph for this function:

Here is the caller graph for this function:

blend_colors()

wxColour Slic3r::GUI::blend_colors ( const wxColour & a, const wxColour & b, double ratio_a )

static

{
    unsigned char r, g, bl;
    Slic3r::filament_mixer_lerp(a.Red(), a.Green(), a.Blue(),
                                b.Red(), b.Green(), b.Blue(),
                                static_cast<float>(1.0 - ratio_a),
                                &r, &g, &bl);
    return wxColour(r, g, bl);
}

References Slic3r::filament_mixer_lerp().

Referenced by Slic3r::GUI::MixedFilamentDialog::rebuild_recommendation_items().

Here is the call graph for this function:

Here is the caller graph for this function:

blend_mixed_color()

std::string Slic3r::GUI::blend_mixed_color ( const std::vector< unsigned int > & comp_ids, const std::vector< int > & ratios, const std::vector< std::string > & color_strs )

static

{
    std::vector<std::string> hex_colors;
    hex_colors.reserve(comp_ids.size());
    for (unsigned int id : comp_ids)
        hex_colors.push_back((id >= 1 && id <= color_strs.size()) ? color_strs[id - 1] : "#808080");
    return Slic3r::blend_color_multi(hex_colors, ratios);
}

References Slic3r::blend_color_multi().

Referenced by create_mixed_filament_from_result(), Slic3r::GUI::Sidebar::edit_mixed_filament(), and Slic3r::GUI::Sidebar::update_mixed_filament_list().

Here is the call graph for this function:

Here is the caller graph for this function:

blend_n_colors()

wxColour Slic3r::GUI::blend_n_colors	(	const std::vector< wxColour > &	cols,
		const std::vector< double > &	weights )

{
    const size_t n = std::min(cols.size(), weights.size());
    std::vector<std::string> hex_colors;
    std::vector<int>         int_weights;
    hex_colors.reserve(n);
    int_weights.reserve(n);
    for (size_t i = 0; i < n; ++i) {
        hex_colors.push_back(to_hex(cols[i]));
        // Scale double weights (e.g. 0.5) to int (5000) for blend_color_multi;
        // only relative magnitude matters.
        int_weights.push_back(static_cast<int>(std::lround(weights[i] * 10000.0)));
    }
    wxColour blended(Slic3r::blend_color_multi(hex_colors, int_weights));
    return blended.IsOk() ? blended : wxColour(128, 128, 128);
}

References Slic3r::blend_color_multi(), and to_hex().

Referenced by Slic3r::GUI::MixedFilamentDialog::create_preview_panel(), Slic3r::GUI::MixedFilamentDialog::rebuild_recommendation_items(), and sample_gradient_ramp().

Here is the call graph for this function:

Here is the caller graph for this function:

body_palette()

ColorRGBA Slic3r::GUI::body_palette ( int body_idx )

static

{
    static const ColorRGBA kPalette[] = {
        ColorRGBA(0.86f, 0.66f, 0.20f, 1.0f),  // gold
        ColorRGBA(0.84f, 0.42f, 0.66f, 1.0f),  // rose
        ColorRGBA(0.45f, 0.78f, 0.42f, 1.0f),  // green
        ColorRGBA(0.86f, 0.45f, 0.40f, 1.0f),  // coral
        ColorRGBA(0.70f, 0.52f, 0.86f, 1.0f),  // violet
        ColorRGBA(0.90f, 0.70f, 0.35f, 1.0f),  // amber
    };
    const int n = int(sizeof(kPalette) / sizeof(kPalette[0]));
    return kPalette[((body_idx % n) + n) % n];
}

Referenced by Slic3r::GUI::DesignCanvas::body_color().

Here is the caller graph for this function:

bold()

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

static

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

Referenced by add_config_substitutions(), and Slic3r::GUI::PublishSettingsDialog::set_row_bold().

Here is the caller graph for this function:

bold_string()

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 */
}

bspline_degree()

int Slic3r::GUI::bspline_degree ( int n )

static

{ return n >= 4 ? 3 : (n >= 2 ? n - 1 : 0); }

References bspline_degree().

Referenced by bspline_degree(), and bspline_polyline().

Here is the call graph for this function:

Here is the caller graph for this function:

bspline_eval()

Vec2d Slic3r::GUI::bspline_eval ( const std::vector< Vec2d > & P, const std::vector< double > & U, int p, double u )

static

{
    const int n = int(P.size());
    if (u <= U[p])            return P.front();
    if (u >= U[n])            return P.back();   // U[n] == domain max (clamped)
    int k = p;
    while (k < n - 1 && U[k + 1] <= u) ++k;       // span: U[k] <= u < U[k+1]
    std::vector<Vec2d> d(p + 1);
    for (int j = 0; j <= p; ++j) d[j] = P[j + k - p];
    for (int r = 1; r <= p; ++r)
        for (int j = p; j >= r; --j) {
            const double denom = U[j + 1 + k - r] - U[j + k - p];
            const double a = denom > 1e-12 ? (u - U[j + k - p]) / denom : 0.0;
            d[j] = (1.0 - a) * d[j - 1] + a * d[j];
        }
    return d[p];
}

References bspline_eval(), and Slic3r::P.

Referenced by bspline_eval(), and bspline_polyline().

Here is the call graph for this function:

Here is the caller graph for this function:

bspline_knots()

std::vector< double > Slic3r::GUI::bspline_knots ( int n, int p )

static

{
    std::vector<double> U;                     // full knot vector, length n+p+1
    const int interior = n - p - 1;
    for (int i = 0; i <= p; ++i) U.push_back(0.0);
    for (int i = 1; i <= interior; ++i) U.push_back(double(i));
    const double last = double(interior + 1);
    for (int i = 0; i <= p; ++i) U.push_back(last);
    return U;
}

References bspline_knots().

Referenced by bspline_knots(), and bspline_polyline().

Here is the call graph for this function:

Here is the caller graph for this function:

bspline_polyline()

std::vector< Vec2d > Slic3r::GUI::bspline_polyline ( const std::vector< Vec2d > & ctrl, int samples = 0 )

static

{
    const int n = int(ctrl.size());
    if (n < 2) return ctrl;
    const int p = bspline_degree(n);
    const std::vector<double> U = bspline_knots(n, p);
    const double umax = double(n - p);
    if (samples <= 0) samples = std::max(24, 14 * (n - 1));
    std::vector<Vec2d> out; out.reserve(samples + 1);
    for (int i = 0; i <= samples; ++i)
        out.push_back(bspline_eval(ctrl, U, p, umax * double(i) / double(samples)));
    return out;
}

References bspline_degree(), bspline_eval(), bspline_knots(), and bspline_polyline().

Referenced by bspline_polyline(), entity_pick_dist(), Slic3r::GUI::DesignSketchTool::entity_polyline(), and Slic3r::GUI::DesignSketchTool::render().

Here is the call graph for this function:

Here is the caller graph for this function:

build_plate_tilt_up_direction()

Vec3d Slic3r::GUI::build_plate_tilt_up_direction

(

)

{
    const DynamicPrintConfig &cfg    = wxGetApp().preset_bundle->printers.get_edited_preset().config;
    const auto               *opt_x  = cfg.option<ConfigOptionFloat>("build_plate_tilt_x");
    const auto               *opt_y  = cfg.option<ConfigOptionFloat>("build_plate_tilt_y");
    const double              tilt_x = opt_x != nullptr ? opt_x->value : 0.;
    const double              tilt_y = opt_y != nullptr ? opt_y->value : 0.;
    if (tilt_x == 0. && tilt_y == 0.)
        return Vec3d::UnitZ();
    return Vec3d(std::tan(Geometry::deg2rad(tilt_y)), std::tan(Geometry::deg2rad(tilt_x)), 1.).normalized();
}

References build_plate_tilt_up_direction(), Slic3r::Geometry::deg2rad(), Slic3r::ConfigBase::option(), and Slic3r::ConfigOptionSingle< T >::value.

Referenced by build_plate_tilt_up_direction(), Slic3r::GUI::GLGizmoPainterBase::get_tilt_up_direction(), Slic3r::GLVolumeCollection::render(), Slic3r::GUI::Bed3D::render_gravity_arrow(), Slic3r::GUI::GLGizmoFdmSupports::select_facets_by_angle(), and wxDECLARE_EVENT().

Here is the call graph for this function:

Here is the caller graph for this function:

bump_texture_library_generation()

void Slic3r::GUI::bump_texture_library_generation

(

)

{
    g_library_generation.fetch_add(1);
}

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

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::ColourPicker::BUILD(), Slic3r::GUI::AMSDryCtrWin::create_button(), Slic3r::GUI::KBShortcutsDialog::create_page(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), anonymous_namespace{GLGizmoEmboss.cpp}::draw_button(), Slic3r::GUI::GLGizmoEmboss::draw_font_list_line(), Slic3r::GUI::GLGizmoSVG::draw_rotation(), Slic3r::GUI::GLGizmoSVG::draw_size(), Slic3r::GUI::HistoryWindow::enbale_action_buttons(), Slic3r::GUI::KBShortcutsDialog::fill_pages(), RammingPanel::get_parameters(), Slic3r::GUI::ObjectLayers::msw_rescale(), Slic3r::GUI::FilamentPickerDialog::OnButtonPaint(), Slic3r::GUI::GLGizmoEmboss::revertible(), Slic3r::GUI::MediaFilePanel::SwitchStorage(), Slic3r::GUI::ObjectLayers::sys_color_changed(), and Slic3r::GUI::AMSDryCtrWin::update_button_size().

Here is the call graph for this function:

Here is the caller graph for this function:

button_with_pos()

bool Slic3r::GUI::button_with_pos	(	ImTextureID	user_texture_id,
		const ImVec2 &	size,
		const ImVec2 &	pos,
		const ImVec2 &	uv0,
		const ImVec2 &	uv1,
		int	frame_padding,
		const ImVec4 &	bg_col,
		const ImVec4 &	tint_col,
		const ImVec2 &	margin )

{
 
    ImGuiContext &g      = *GImGui;
    ImGuiWindow * window = g.CurrentWindow;
    if (window->SkipItems) return false;
 
    // Default to using texture ID as ID. User can still push string/integer prefixes.
    ImGui::PushID((void *) (intptr_t) user_texture_id);
    const ImGuiID id = window->GetID("#image");
    ImGui::PopID();
 
    const ImVec2 padding = (frame_padding >= 0) ? ImVec2((float) frame_padding, (float) frame_padding) : g.Style.FramePadding;
 
    const ImRect bb(pos, pos + size + padding * 2 + margin * 2);
 
    bool hovered, held;
    bool pressed = ImGui::ButtonBehavior(bb, id, &hovered, &held);
 
    // Render
    const ImU32 col = ImGui::GetColorU32((held && hovered) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);
    ImGui::RenderNavHighlight(bb, id);
 
    const float border_size = g.Style.FrameBorderSize;
    if (border_size > 0.0f) {
        window->DrawList->AddRect(bb.Min + ImVec2(1, 1), bb.Max + ImVec2(1, 1), col, g.Style.FrameRounding, 0, border_size);
        window->DrawList->AddRect(bb.Min, bb.Max, col, g.Style.FrameRounding, 0, border_size);
    }
 
    if (bg_col.w > 0.0f) window->DrawList->AddRectFilled(bb.Min + padding, bb.Max - padding, ImGui::GetColorU32(bg_col));
    window->DrawList->AddImage(user_texture_id, bb.Min + padding + margin, bb.Max - padding - margin, uv0, uv1, ImGui::GetColorU32(tint_col));
 
    return pressed;
}

References ImRect.

Referenced by Slic3r::GUI::IMSlider::draw_ticks().

Here is the caller graph for this function:

cad_escape_level()

CadLevel Slic3r::GUI::cad_escape_level ( const CadInteractionState & s )

constexpr

{
    if (s.value_field_open) return CadLevel::Transient;
    if (s.gesture_active)   return CadLevel::Gesture;
    if (s.tool_armed)       return CadLevel::Tool;
    return CadLevel::Idle;
}

References Gesture, Slic3r::GUI::CadInteractionState::gesture_active, Idle, Tool, Slic3r::GUI::CadInteractionState::tool_armed, Transient, and Slic3r::GUI::CadInteractionState::value_field_open.

Referenced by Slic3r::GUI::DesignPanel::escape_level().

Here is the caller graph for this function:

calc_angle()

std::optional< float > Slic3r::GUI::calc_angle

(

const Selection &

selection

)

Calculate up vector angle.

Parameters

selection

Calculation of angle is for selected one volume

Returns

{
    const GLVolume *gl_volume = selection.get_first_volume();
    assert(gl_volume != nullptr);
    if (gl_volume == nullptr)
        return {};
 
    Transform3d to_world = gl_volume->world_matrix();
    const ModelVolume *volume = get_model_volume(*gl_volume, selection.get_model()->objects);
    assert(volume != nullptr);
    assert(volume->emboss_shape.has_value());
    if (volume == nullptr || !volume->emboss_shape.has_value() || !volume->emboss_shape->fix_3mf_tr)
        return Emboss::calc_up(to_world, UP_LIMIT);
 
    // exist fix matrix and must be applied before calculation
    to_world = to_world * volume->emboss_shape->fix_3mf_tr->inverse();
    return Emboss::calc_up(to_world, UP_LIMIT);
}

References Slic3r::Emboss::calc_up(), Slic3r::ModelVolume::emboss_shape, Slic3r::GUI::Selection::get_first_volume(), Slic3r::GUI::Selection::get_model(), get_model_volume(), Slic3r::Model::objects, UP_LIMIT, and Slic3r::GLVolume::world_matrix().

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoSVG::draw_mirroring(), Slic3r::GUI::GLGizmoSVG::draw_rotation(), anonymous_namespace{TextLines.cpp}::its_create_torus(), Slic3r::GUI::GLGizmoEmboss::on_mouse_for_translate(), Slic3r::GUI::GLGizmoSVG::on_mouse_for_translate(), Slic3r::GUI::GLGizmoEmboss::set_volume_by_selection(), Slic3r::GUI::GLGizmoSVG::set_volume_by_selection(), Slic3r::GUI::GLGizmoEmboss::volume_transformation_changed(), and Slic3r::GUI::GLGizmoSVG::volume_transformation_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_color_distance() [1/2]

float Slic3r::GUI::calc_color_distance	(	RGBA	c1,
		RGBA	c2 )

{
    float lab[2][3];
    RGB2Lab(c1[0], c1[1], c1[2], &lab[0][0], &lab[0][1], &lab[0][2]);
    RGB2Lab(c2[0], c2[1], c2[2], &lab[1][0], &lab[1][1], &lab[1][2]);
 
    return DeltaE76(lab[0][0], lab[0][1], lab[0][2], lab[1][0], lab[1][1], lab[1][2]);
}

References DeltaE76(), and RGB2Lab().

Here is the call graph for this function:

calc_color_distance() [2/2]

float Slic3r::GUI::calc_color_distance	(	wxColour	c1,
		wxColour	c2 )

{
    float lab[2][3];
    RGB2Lab(c1.Red(), c1.Green(), c1.Blue(), &lab[0][0], &lab[0][1], &lab[0][2]);
    RGB2Lab(c2.Red(), c2.Green(), c2.Blue(), &lab[1][0], &lab[1][1], &lab[1][2]);
 
    return DeltaE76(lab[0][0], lab[0][1], lab[0][2], lab[1][0], lab[1][1], lab[1][2]);
}

References DeltaE76(), and RGB2Lab().

Referenced by Slic3r::DevMappingUtil::ams_filament_mapping(), convert_obj_cluster_colors(), and draw_mixed_gradient_plot().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_distance() [1/2]

std::optional< float > Slic3r::GUI::calc_distance	(	const GLVolume &	gl_volume,
		const RaycastManager &	raycaster,
		const RaycastManager::ISkip *	condition,
		const std::optional< Slic3r::Transform3d > &	fix )

                                                                                     {
    Transform3d w = gl_volume.world_matrix();
    if (fix.has_value())
        w = w * fix->inverse();
    Vec3d p = w.translation();
    Vec3d dir = -get_z_base(w);
    auto hit_opt = raycaster.closest_hit(p, dir, condition);
    if (!hit_opt.has_value())
        return {};
 
    const RaycastManager::Hit &hit = *hit_opt;
    // NOTE: hit.squared_distance is in volume space not world
 
    const Transform3d &tr = raycaster.get_transformation(hit.tr_key);
    Vec3d hit_world = tr * hit.position;
    Vec3d p_to_hit = hit_world - p;
    double distance_sq = p_to_hit.squaredNorm();
 
    // too small distance is calculated as zero distance
    if (distance_sq < ::surface_distance_sq.min)
        return {};
 
    // check maximal distance
    const BoundingBoxf3& bb = gl_volume.bounding_box();
    double max_squared_distance = std::max(std::pow(2 * bb.size().z(), 2), ::surface_distance_sq.max);
    if (distance_sq > max_squared_distance)
        return {};   
    
    // calculate sign
    float sign = (p_to_hit.dot(dir) > 0)? 1.f : -1.f;
 
    // distiguish sign
    return sign * static_cast<float>(sqrt(distance_sq));
}

References Slic3r::GLVolume::bounding_box(), Slic3r::GUI::RaycastManager::closest_hit(), Slic3r::GUI::RaycastManager::get_transformation(), Slic3r::get_z_base(), Slic3r::GUI::RaycastManager::SurfacePoint< T >::position, Slic3r::BoundingBox3Base< PointType >::size(), Slic3r::GUI::RaycastManager::Hit::tr_key, and Slic3r::GLVolume::world_matrix().

Here is the call graph for this function:

calc_distance() [2/2]

std::optional< float > Slic3r::GUI::calc_distance	(	const GLVolume &	gl_volume,
		RaycastManager &	raycaster,
		GLCanvas3D &	canvas )

Calculate distance by ray to surface of object in emboss direction.

Parameters

gl_volume	Define embossed volume
raycaster	Way to cast rays to object
canvas	Contain model

Returns

Calculated distance from surface

{
    const ModelObject *object = get_model_object(gl_volume, canvas.get_model()->objects);
    assert(object != nullptr);
    if (object == nullptr)
        return {};
 
    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 {};
 
    if (volume->is_the_only_one_part())
        return {};
 
    if (!volume->emboss_shape.has_value())
        return {};
        
    RaycastManager::AllowVolumes condition = create_condition(object->volumes, volume->id());
    RaycastManager::Meshes meshes = create_meshes(canvas, condition);
    raycaster.actualize(*instance, &condition, &meshes);
    return calc_distance(gl_volume, raycaster, &condition, volume->emboss_shape->fix_3mf_tr);
}

References Slic3r::GUI::RaycastManager::actualize(), calc_distance(), create_condition(), create_meshes(), Slic3r::ModelVolume::emboss_shape, Slic3r::GUI::GLCanvas3D::get_model(), get_model_instance(), get_model_object(), get_model_volume(), Slic3r::ObjectBase::id(), Slic3r::ModelVolume::is_the_only_one_part(), Slic3r::Model::objects, and Slic3r::ModelObject::volumes.

Referenced by calc_distance(), Slic3r::GUI::GLGizmoSVG::on_mouse_for_translate(), Slic3r::GUI::GLGizmoEmboss::set_volume_by_selection(), Slic3r::GUI::GLGizmoSVG::set_volume_by_selection(), and anonymous_namespace{SurfaceDrag.cpp}::start_dragging().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_gray()

float Slic3r::GUI::calc_gray ( wxColour color )

inline

{
    return 0.299 * (float) color.Red() + 0.587 * (float) color.Green() + 0.114 * (float) color.Blue();
}

References calc_gray().

Referenced by Slic3r::GUI::SliceInfoPopup::SliceInfoPopup(), and calc_gray().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_scale()

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().

Referenced by anonymous_namespace{SurfaceDrag.cpp}::get_volume_transformation().

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, objects);
    Vec3d point = to_world.translation();
    Vec3d dir = -get_z_base(to_world);
    // ray in direction of text projection(from volume zero to z-dir)
    std::optional<RaycastManager::Hit> hit_opt = raycast_manager.closest_hit(point, dir, &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;
}

References Slic3r::GUI::RaycastManager::actualize(), Slic3r::GUI::RaycastManager::closest(), Slic3r::GUI::RaycastManager::closest_hit(), EPSILON, Slic3r::GUI::Selection::get_model(), get_model_instance(), get_model_volume(), get_selected_gl_volume(), Slic3r::GUI::RaycastManager::get_transformation(), Slic3r::get_z_base(), Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, Slic3r::Model::objects, Slic3r::GUI::RaycastManager::ClosePoint::point, Slic3r::GUI::RaycastManager::SurfacePoint< T >::position, Slic3r::GUI::RaycastManager::Hit::squared_distance, Slic3r::GUI::RaycastManager::ClosePoint::tr_key, Slic3r::GUI::RaycastManager::Hit::tr_key, and world_matrix_fixed().

Referenced by Slic3r::GUI::Emboss::start_update_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_md5()

std::string Slic3r::GUI::calculate_md5 ( const std::string & input )

static

{
    unsigned char digest[MD5_DIGEST_LENGTH];
    std::string   md5;
 
    EVP_MD_CTX *mdContext = EVP_MD_CTX_new();
    EVP_DigestInit(mdContext, EVP_md5());
    EVP_DigestUpdate(mdContext, input.c_str(), input.length());
    EVP_DigestFinal(mdContext, digest, nullptr);
    EVP_MD_CTX_free(mdContext);
 
    char hexDigest[MD5_DIGEST_LENGTH * 2 + 1];
    for (int i = 0; i < MD5_DIGEST_LENGTH; ++i) { sprintf(hexDigest + (i * 2), "%02x", digest[i]); }
    hexDigest[MD5_DIGEST_LENGTH * 2] = '\0';
 
    md5 = std::string(hexDigest);
    return md5;
}

Referenced by get_filament_id().

Here is the caller graph for this function:

calib_temp_dir()

const std::string & Slic3r::GUI::calib_temp_dir ( )

static

{
    static const std::string dir = temporary_dir() + "/calib";
    return dir;
}

References Slic3r::temporary_dir().

Referenced by calib_temp_file(), Slic3r::GUI::CalibUtils::send_to_print(), and Slic3r::GUI::CalibUtils::send_to_print().

Here is the call graph for this function:

Here is the caller graph for this function:

calib_temp_file()

std::string Slic3r::GUI::calib_temp_file ( const std::string & name )

static

{ return calib_temp_dir() + "/" + name; }

References calib_temp_dir().

Referenced by Slic3r::GUI::CalibUtils::process_and_store_3mf(), Slic3r::GUI::CalibUtils::send_to_print(), and Slic3r::GUI::CalibUtils::send_to_print().

Here is the call graph for this function:

Here is the caller graph for this function:

call_after_if_active()

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::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()

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(), Slic3r::ModelVolume::is_cut_connector(), Slic3r::ModelVolume::is_model_part(), and Slic3r::ModelObject::volumes.

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:

canvas_corner_height()

float Slic3r::GUI::canvas_corner_height ( )

static

{
    if (wxGetApp().show_3d_navigator())
        return NAVIGATOR_SIZE;
    const int buttons = wxGetApp().show_canvas_zoom_button() ? 3 : 2;
    return CANVAS_TOOLBAR_MARGIN + 2.f * CANVAS_TOOLBAR_PADDING + buttons * CANVAS_TOOLBAR_BUTTON + (buttons - 1) * CANVAS_TOOLBAR_SPACING;
}

References CANVAS_TOOLBAR_BUTTON, CANVAS_TOOLBAR_MARGIN, CANVAS_TOOLBAR_PADDING, CANVAS_TOOLBAR_SPACING, and NAVIGATOR_SIZE.

Referenced by Slic3r::GUI::GLCanvas3D::_render_plate_switcher().

Here is the caller graph for this function:

cap_favourites()

std::vector< std::string > Slic3r::GUI::cap_favourites	(	const std::vector< std::string > &	ids,
		size_t	limit )

{
    std::vector<std::string> out;
    out.reserve(std::min(ids.size(), limit));
    for (const auto& id : ids) {
        if (out.size() >= limit)
            break;
        if (std::find(out.begin(), out.end(), id) == out.end())
            out.push_back(id);
    }
    return out;
}

Referenced by Slic3r::GUI::ActionRegistry::favourite_ids(), and Slic3r::GUI::ActionRegistry::reorder_favourites().

Here is the caller graph for this function:

caseInsensitiveCompare()

bool Slic3r::GUI::caseInsensitiveCompare ( const std::string & a, const std::string & b )

static

                                                                           {
    std::string lowerA = a;
    std::string lowerB = b;
    std::transform(lowerA.begin(), lowerA.end(), lowerA.begin(), ::tolower);
    std::transform(lowerB.begin(), lowerB.end(), lowerB.begin(), ::tolower);
    return lowerA < lowerB;
}

Referenced by Slic3r::GUI::CreateFilamentPresetDialog::create_vendor_item().

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) {
            const auto v = boost::any_cast<unsigned char>(value);
            auto vec_new = std::make_unique<ConfigOptionBoolsNullable>(1, v);
            if (v == ConfigOptionBoolsNullable::nil_value()) {
                vec_new->set_at_to_nil(0);
            }
 
            config.option<ConfigOptionBoolsNullable>(opt_key)->set_at(vec_new.get(), 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 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)
            auto   vec_new = std::make_unique<ConfigOptionFloatOrPercent>(val, percent);
            config.option<ConfigOptionFloatsOrPercents>(opt_key)->set_at(vec_new.get(), opt_index, opt_index);
      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 coPercents:{
            auto vec_new = std::make_unique <ConfigOptionPercent>(boost::any_cast<double>(value));
      config.option<ConfigOptionPercents>(opt_key)->set_at(vec_new.get(), opt_index, opt_index);
      break;
    }
    case coFloats:{
            auto vec_new = std::make_unique<ConfigOptionFloat>(boost::any_cast<double>(value));
      config.option<ConfigOptionFloats>(opt_key)->set_at(vec_new.get(), 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") {
        config.option<ConfigOptionStrings>(opt_key)->values =
          boost::any_cast<std::vector<std::string>>(value);
      }
      else if (config.def()->get(opt_key)->gui_type == ConfigOptionDef::GUIType::plugin_picker) {
        if (value.type() == typeid(std::vector<std::string>)) {
          config.option<ConfigOptionStrings>(opt_key)->values =
            boost::any_cast<std::vector<std::string>>(value);
        } else {
          std::string str = boost::any_cast<std::string>(value);
          config.option<ConfigOptionStrings>(opt_key)->values = str.empty() ?
            std::vector<std::string>() : std::vector<std::string>{str};
        }
      }
      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{
                auto vec_new = std::make_unique<ConfigOptionString>(boost::any_cast<std::string>(value));
        config.option<ConfigOptionStrings>(opt_key)->set_at(vec_new.get(), opt_index, 0);
      }
      }
      break;
    case coBool:
      config.set_key_value(opt_key, new ConfigOptionBool(boost::any_cast<bool>(value)));
      break;
    case coBools:{
            auto vec_new = std::make_unique<ConfigOptionBool>(boost::any_cast<unsigned char>(value) != 0);
      config.option<ConfigOptionBools>(opt_key)->set_at(vec_new.get(), opt_index, 0);
      break;}
    case coInt:
      config.set_key_value(opt_key, new ConfigOptionInt(boost::any_cast<int>(value)));
      break;
    case coInts:{
            auto vec_new = std::make_unique<ConfigOptionInt>(boost::any_cast<int>(value));
      config.option<ConfigOptionInts>(opt_key)->set_at(vec_new.get(), 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;
    // BBS
    case coEnums:{
            auto vec_new = std::make_unique<ConfigOptionEnumsGeneric>(std::vector<int>{boost::any_cast<int>(value)});
      if (config.has(opt_key))
        config.option<ConfigOptionEnumsGeneric>(opt_key)->set_at(vec_new.get(), opt_index, 0);
      }
      break;
    case coPoint:{
      config.set_key_value(opt_key, new ConfigOptionPoint(boost::any_cast<Vec2d>(value)));
      }
      break;
    case coPoints:{
      if (opt_key == "bed_exclude_area" && boost::any_cast<std::string>(&value) != nullptr) {
        // Tab handles pasted volume syntax after this callback. Do not
        // deserialize it as points: failure would erase the saved area
        // before the user can accept or cancel the copy operation.
        break;
      }
      if (opt_key == "printable_area" || opt_key == "bed_exclude_area" || opt_key == "thumbnails" || opt_key == "wrapping_exclude_area" ) {
        config.option<ConfigOptionPoints>(opt_key)->values = boost::any_cast<std::vector<Vec2d>>(value);
        if (opt_key == "bed_exclude_area") {
          ConfigOptionPoints normalized(boost::any_cast<std::vector<Vec2d>>(value));
          config.option<ConfigOptionPoints>(opt_key)->deserialize(normalized.serialize());
        }
        break;
      }
            auto vec_new = std::make_unique<ConfigOptionPoint>(boost::any_cast<Vec2d>(value));
      config.option<ConfigOptionPoints>(opt_key)->set_at(vec_new.get(), 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::coEnums, Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coFloats, Slic3r::coFloatsOrPercents, Slic3r::coInt, Slic3r::coInts, Slic3r::ConfigOptionString, Slic3r::coNone, Slic3r::coPercent, Slic3r::coPercents, Slic3r::coPoint, Slic3r::coPoints, Slic3r::coString, Slic3r::coStrings, Slic3r::DynamicPrintConfig::def(), Slic3r::ConfigOptionDef::default_value, format_wxstr(), Slic3r::ConfigDef::get(), Slic3r::ConfigOptionDef::gui_flags, Slic3r::ConfigOptionDef::gui_type, Slic3r::ConfigOptionResolver::has(), Slic3r::ConfigOptionBoolsTempl< true >::nil_value(), Slic3r::ConfigOptionDef::nullable, Slic3r::DynamicConfig::opt_float(), Slic3r::ConfigBase::option(), Slic3r::ConfigOptionDef::plugin_picker, Slic3r::ConfigOptionPoints::serialize(), Slic3r::DynamicConfig::set_key_value(), and Slic3r::ConfigOptionDef::type.

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

Here is the call graph for this function:

Here is the caller graph for this function:

check_color_change()

bool Slic3r::GUI::check_color_change	(	PrintObject *	object,
		size_t	frst_layer_id,
		size_t	layers_cnt,
		bool	check_overhangs,
		std::function< bool(Layer *)>	break_condition )

{
    double prev_area = area(object->get_layer(frst_layer_id)->lslices);
 
    bool detected = false;
    for (size_t i = frst_layer_id + 1; i < layers_cnt; i++) {
        Layer *layer    = object->get_layer(i);
        double cur_area = area(layer->lslices);
 
        // check for overhangs
        if (check_overhangs && cur_area > prev_area && !equivalent_areas(prev_area, cur_area)) break;
 
        // Check percent of the area decrease.
        // This value have to be more than min_delta_area and more then 10%
        if ((prev_area - cur_area > min_delta_area()) && (cur_area / prev_area < 0.9)) {
            detected = true;
            if (break_condition(layer)) break;
        }
 
        prev_area = cur_area;
    }
    return detected;
}

References Slic3r::area(), equivalent_areas(), Slic3r::PrintObject::get_layer(), Slic3r::Layer::lslices, and min_delta_area().

Here is the call graph for this function:

check_dark_mode()

bool Slic3r::GUI::check_dark_mode

(

)

                       {
#if 0 //#ifdef _WIN32  // #ysDarkMSW - Allow it when we deside to support the sustem colors for application
    wxRegKey rk(wxRegKey::HKCU,
        "Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize");
    if (rk.Exists() && rk.HasValue("AppsUseLightTheme")) {
        long value = -1;
        rk.QueryValue("AppsUseLightTheme", &value);
        return value <= 0;
    }
#endif
    return wxSystemSettings::GetAppearance().IsDark();
}

Referenced by create_scaled_bitmap(), and Slic3r::GUI::GUI_App::dark_mode().

Here is the caller graph for this function:

check_nozzle_diameter_and_type()

bool Slic3r::GUI::check_nozzle_diameter_and_type ( const DynamicPrintConfig & full_config, wxString & error_msg )

static

{
    DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev) {
        error_msg = _L("Need select printer");
        return false;
    }
 
    MachineObject *obj = dev->get_selected_machine();
    if (obj == nullptr) {
        error_msg = _L("Need select printer");
        return false;
    }
 
    if (!Slic3r::GUI::wxGetApp().plater()->check_printer_initialized(obj))
        return false;
 
    // P1P/S
    if (obj->GetExtderSystem()->GetNozzleType(0) == NozzleType::ntUndefine)
        return true;
 
    if (!is_same_nozzle_type(full_config, obj, error_msg))
        return false;
 
    return true;
}

References _L, Slic3r::DeviceManager::get_selected_machine(), Slic3r::MachineObject::GetExtderSystem(), Slic3r::DevExtderSystem::GetNozzleType(), is_same_nozzle_type(), Slic3r::ntUndefine, and plater().

Referenced by Slic3r::GUI::CalibUtils::process_and_store_3mf().

Here is the call graph for this function:

Here is the caller graph for this function:

check_objects_after_cut()

void Slic3r::GUI::check_objects_after_cut ( const ModelObjectPtrs & objects )

static

{
    std::vector<std::string> err_objects_names;
    for (const ModelObject* object : objects) {
        std::vector<std::string> connectors_names;
        connectors_names.reserve(object->volumes.size());
        for (const ModelVolume* vol : object->volumes)
            if (vol->cut_info.is_connector)
                connectors_names.push_back(vol->name);
        const size_t connectors_count = connectors_names.size();
        sort_remove_duplicates(connectors_names);
        if (connectors_count != connectors_names.size())
            err_objects_names.push_back(object->name);
    }
    if (err_objects_names.empty())
        return;
 
    wxString names = from_u8(err_objects_names[0]);
    for (size_t i = 1; i < err_objects_names.size(); i++)
        names += ", " + from_u8(err_objects_names[i]);
    WarningDialog(wxGetApp().plater(), format_wxstr(_L_PLURAL("Object (%1%) has duplicated connectors. "
                                "Some connectors may be missing in slicing result.\n"
                                "Please report to the OrcaSlicer team in which scenario this issue happened.\n"
                                "Thank you.",
                                "Objects (%1%) have duplicated connectors. "
                                "Some connectors may be missing in slicing result.\n"
                                "Please report to the OrcaSlicer team in which scenario this issue happened.\n"
                                "Thank you.", unsigned(err_objects_names.size())), names)).ShowModal();
}

References _L_PLURAL, Slic3r::ModelVolume::cut_info, format_wxstr(), from_u8(), Slic3r::ModelVolume::CutInfo::is_connector, Slic3r::ModelVolume::name, plater(), Slic3r::GUI::DPIAware< P >::ShowModal(), and Slic3r::sort_remove_duplicates().

Referenced by Slic3r::GUI::GLGizmoCut3D::perform_cut().

Here is the call graph for this function:

Here is the caller graph for this function:

circle_polygon()

std::vector< Vec2d > Slic3r::GUI::circle_polygon ( const Vec2d & c, double r, int n = 48 )

static

{
    std::vector<Vec2d> v; v.reserve(n);
    for (int i = 0; i < n; ++i) {
        const double a = 2.0 * M_PI * double(i) / double(n);
        v.push_back(Vec2d(c.x() + r * std::cos(a), c.y() + r * std::sin(a)));
    }
    return v;
}

References circle_polygon(), and M_PI.

Referenced by circle_polygon(), Slic3r::GUI::DesignSketchTool::entity_polyline(), and Slic3r::GUI::DesignSketchTool::render().

Here is the call graph for this function:

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::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::angle(), Slic3r::GUI::GLModel::Geometry::format, Slic3r::normal(), Slic3r::GUI::GLModel::Geometry::P3N3, PI, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::resolution(), 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:

circumcircle()

bool Slic3r::GUI::circumcircle ( const Vec2d & a, const Vec2d & b, const Vec2d & c, Vec2d & center, double & radius )

static

{
    const double d = 2.0 * (a.x() * (b.y() - c.y()) +
                            b.x() * (c.y() - a.y()) +
                            c.x() * (a.y() - b.y()));
    if (std::abs(d) < 1e-9)
        return false;
    const double a2 = a.squaredNorm(), b2 = b.squaredNorm(), c2 = c.squaredNorm();
    const double ux = (a2 * (b.y() - c.y()) + b2 * (c.y() - a.y()) + c2 * (a.y() - b.y())) / d;
    const double uy = (a2 * (c.x() - b.x()) + b2 * (a.x() - c.x()) + c2 * (b.x() - a.x())) / d;
    center = Vec2d(ux, uy);
    radius = (a - center).norm();
    return true;
}

References Slic3r::center(), and circumcircle().

Referenced by circumcircle(), Slic3r::GUI::DesignSketchTool::make_three_point_arc(), and Slic3r::GUI::DesignSketchTool::make_three_point_circle().

Here is the call graph for this function:

Here is the caller graph for this function:

classify_code_lines()

std::vector< std::pair< std::string, bool > > Slic3r::GUI::classify_code_lines ( const std::string & msg )

static

{
    std::vector<std::string> lines;
    boost::split(lines, msg, boost::is_any_of("\n"));
    for (std::string &line : lines)
        if (!line.empty() && line.back() == '\r')
            line.pop_back();
 
    std::vector<std::pair<std::string, bool>> tagged;
    tagged.reserve(lines.size());
    for (size_t i = 0; i < lines.size(); ++i) {
        bool is_code = is_caret_line(lines[i]) || (i + 1 < lines.size() && is_caret_line(lines[i + 1]));
        tagged.emplace_back(std::move(lines[i]), is_code);
    }
    return tagged;
}

References is_caret_line().

Referenced by format_parser_error_html(), and measure_mixed_text().

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
    ImGuiWindow *window = ImGui::GetCurrentWindow();
    float cursor_x = ImGui::GetCursorPosX()
        - window->DC.GroupOffset.x 
        - window->DC.ColumnsOffset.x;
    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(), and priv::draw_transparent_icon().

Referenced by button(), Slic3r::GUI::GLGizmoEmboss::draw_bold_button(), anonymous_namespace{GLGizmoSVG.cpp}::draw_clickable(), Slic3r::GUI::GLGizmoEmboss::draw_italic_button(), and anonymous_namespace{GLGizmoSVG.cpp}::reset_button().

Here is the call graph for this function:

Here is the caller graph for this function:

cloud_navigation_is_top_level()

bool Slic3r::GUI::cloud_navigation_is_top_level ( const wxWebViewEvent & evt )

static

{
#ifdef __WXGTK__
    return evt.GetNavigationAction() == wxWEBVIEW_NAV_ACTION_USER;
#else
    return evt.IsTargetMainFrame();
#endif
}

Referenced by Slic3r::GUI::WebViewPanel::OnCloudWebViewEvent().

Here is the caller graph for this function:

cloud_page_url()

wxString Slic3r::GUI::cloud_page_url ( NetworkAgent * agent, const std::string & path )

static

{
    if (path.empty())
        return {};
    auto orca = get_orca_cloud_agent(agent);
    if (!orca)
        return {};
    std::string base = orca->get_cloud_base_url();
    while (!base.empty() && base.back() == '/')
        base.pop_back();
    if (base.empty())
        return {};
    return from_u8(base + path);
}

References from_u8(), and get_orca_cloud_agent().

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

Here is the call graph for this function:

Here is the caller graph for this function:

CMYW_CYAN()

const wxColour Slic3r::GUI::CMYW_CYAN ( 0 , 255 , 255  )

static

Referenced by Slic3r::GUI::ColorDecomposeDialog::compute_decomposition(), pure_color_for_base(), and standard_base_color_for().

Here is the caller graph for this function:

CMYW_MAGENTA()

const wxColour Slic3r::GUI::CMYW_MAGENTA ( 255 , 0 , 255  )

static

Referenced by pure_color_for_base(), and standard_base_color_for().

Here is the caller graph for this function:

CMYW_WHITE()

const wxColour Slic3r::GUI::CMYW_WHITE ( 255 , 255 , 255  )

static

Referenced by pure_color_for_base(), and standard_base_color_for().

Here is the caller graph for this function:

CMYW_YELLOW()

const wxColour Slic3r::GUI::CMYW_YELLOW ( 255 , 255 , 0  )

static

Referenced by Slic3r::GUI::ColorDecomposeDialog::compute_decomposition(), pure_color_for_base(), and standard_base_color_for().

Here is the caller graph for this function:

collect_ams_color_items()

std::vector< ColorPickerPopup::ColorItem > Slic3r::GUI::collect_ams_color_items ( DevFilaSystem * fila_system )

static

{
    std::vector<ColorPickerPopup::ColorItem> items;
    if (!fila_system) return items;
 
    for (const auto& ams_pair : fila_system->GetAmsList()) {
        DevAms* ams = ams_pair.second;
        if (!ams) continue;
 
        for (const auto& tray_pair : ams->GetTrays()) {
            DevAmsTray* tray = tray_pair.second;
            if (!tray || !tray->is_tray_info_ready()) continue;
 
            ColorPickerPopup::ColorItem item;
            for (const std::string& col : tray->cols) {
                item.colors.emplace_back(DevAmsTray::decode_color(col));
            }
            if (item.colors.empty() && !tray->color.empty()) {
                item.colors.emplace_back(DevAmsTray::decode_color(tray->color));
            }
            if (item.colors.empty()) continue;
 
            item.ctype = item.colors.size() > 1 ? tray->ctype : 2;
            items.emplace_back(std::move(item));
        }
    }
 
    return items;
}

References Slic3r::DevAmsTray::color, Slic3r::GUI::ColorPickerPopup::ColorItem::colors, Slic3r::DevAmsTray::cols, Slic3r::DevAmsTray::ctype, Slic3r::GUI::ColorPickerPopup::ColorItem::ctype, Slic3r::DevAmsTray::decode_color(), Slic3r::DevFilaSystem::GetAmsList(), Slic3r::DevAms::GetTrays(), and Slic3r::DevAmsTray::is_tray_info_ready().

Referenced by Slic3r::GUI::AMSMaterialsSetting::on_clr_picker().

Here is the call graph for this function:

Here is the caller graph for this function:

collect_imex_warnings()

std::vector< wxString > Slic3r::GUI::collect_imex_warnings ( PartPlate * plate )

static

{
    std::vector<wxString> warnings;
    if (!plate) return warnings;
 
    // Multi-material conflicts are now hard-blocked at slice time via
    // imex_multicolor_block_reason (Print::validate). The pre-slice nanny used to
    // emit a vague soft warning here, but the hard block surfaces a more
    // descriptive message at exactly the right moment, so the duplicate warning
    // was dropped. Bed-temp + filament-type checks below remain useful soft
    // warnings — they catch user configurations that *will* slice but produce
    // problematic gcode.
    // Resolved: a plate on Primary still slices in the process preset's mode, and these
    // bed-temperature and filament-type warnings are the only notice the user gets.
    const std::string mode = plate->get_effective_imex_mode();
    if (mode == kImexPrimaryMode) return warnings;
 
    PresetBundle* bundle = wxGetApp().preset_bundle;
    if (!bundle) return warnings;
 
    // The mode's tool roster, its declared primary, and which logical filament slot the
    // primary prints with all come from imex_resolve_routing() -- the same library call
    // Print::validate() makes for its hard block, so the sentence shown here and the refusal
    // shown at slice time cannot describe the plate differently. An unresolved mode, and a
    // mode the tools array is too short to cover, both yield an empty roster and no primary,
    // which is the same "nothing to warn about" answer the open-coded lookup gave.
    //
    // The pem source is the GUI's own (effective_physical_extruder_map on the live bundle);
    // Print::apply() normalises the slicer's copy through the same helper, so the two agree.
    const ConfigOptionInts pem = effective_physical_extruder_map(*bundle);
    const ImexRouting routing = imex_resolve_routing(bundle->printers.get_edited_preset().config,
                                                     mode, plate->get_extruders(true), pem);
 
    // Upper bound: filament_presets.size() is the practical limit, capped at MAXIMUM_EXTRUDER_NUMBER (64).
    // GUI-only: every warning below names a filament preset, so a tool with no preset to
    // name is one this dialog has nothing to say about. The slicer has no such limit --
    // it refuses the plate outright rather than describing it.
    const size_t max_tool = std::min(bundle->filament_presets.size(), MAXIMUM_EXTRUDER_NUMBER);
 
    std::vector<int> active_tools;
    const int primary_tool = routing.primary_phys;
    for (const auto& [phys_idx, role] : routing.tools) {
        (void)role;
        // parse_imex_active_tools already drops negative indices.
        if (max_tool == 0 || (size_t)phys_idx < max_tool)
            active_tools.push_back(phys_idx);
    }
 
    // Two or more tools is what makes a primary/secondary comparison meaningful; both checks
    // below are primary-vs-secondary. A single-tool roster is left to Print::validate.
    if (active_tools.size() < 2 || primary_tool < 0) return warnings;
    const DynamicPrintConfig& full_cfg = bundle->full_config();
    // Bed temps are per-plate-type; resolve the active plate's bed type to get the right key.
    const BedType bed_type = bundle->project_config.opt_enum<BedType>("curr_bed_type");
    const std::string bed_temp_key = get_bed_temp_key(bed_type);
    const auto* bed_temps = bed_temp_key.empty() ? nullptr : full_cfg.option<ConfigOptionInts>(bed_temp_key);
    const auto& filament_presets = bundle->filament_presets;
 
    // active_tools and primary_tool are PHYSICAL extruder indices (from
    // imex_mode_active_tools). filament_presets and bed_temps are indexed by LOGICAL
    // filament slot. For MMU/AFC layouts where multiple logical slots feed one
    // physical extruder, looking up filament_presets[physical_idx] returns the wrong
    // filament. Translate physical -> logical before indexing.
    //
    // Primary vs secondary use DIFFERENT translation rules:
    //   - Primary's filament: routing.primary_logical, the slot the plate's objects put on
    //     the primary's physical head. -1 there is exactly the condition Print::validate
    //     refuses the plate on (ImexRouting::primary_unrouted); this dialog runs first and
    //     still wants a filament to name, so it falls back to the printer's own routing.
    //   - Secondary's filament: per-plate imex_head_filament_map override (set via
    //     the IMEX ghost picker). No object owns a secondary in copy/mirror mode —
    //     the firmware duplicates the primary, so the override is the only source. Stays
    //     GUI-local: the slicer never has to name a secondary's filament.
    std::map<int, int> plate_head_map;
    if (auto* hfm = plate->config()->option<ConfigOptionString>("imex_head_filament_map"))
        plate_head_map = parse_imex_head_filament_map(hfm->value);
 
    auto logical_for_secondary = [&](int physical_idx) -> int {
        const int logical = resolve_filament_for_head(plate_head_map, pem, physical_idx);
        return logical >= 0 ? logical : physical_idx;
    };
 
    // Primary tool's bed temp and filament type (looked up by logical slot). Both lookups
    // are guarded against a negative slot: first_filament_for_physical_head() returns -1 for
    // a primary no logical filament reaches at all, and `-1 < size()` would otherwise index
    // in front of the array.
    const int primary_logical = routing.routes_to_primary()
                                    ? routing.primary_logical
                                    : first_filament_for_physical_head(pem, primary_tool);
    const int primary_bed_temp = (bed_temps && primary_logical >= 0 &&
                                  primary_logical < (int)bed_temps->values.size())
                                    ? bed_temps->values[primary_logical] : 0;
    std::string primary_display_type;
    if (primary_logical >= 0 && primary_logical < (int)filament_presets.size()) {
        Preset* p = bundle->filaments.find_preset(filament_presets[primary_logical]);
        if (p) p->get_filament_type(primary_display_type);
    }
    if (primary_display_type.empty()) primary_display_type = "unknown";
 
    for (size_t i = 0; i < active_tools.size(); ++i) {
        const int tool_idx = active_tools[i];
        if (tool_idx == primary_tool) continue;
 
        const int secondary_logical = logical_for_secondary(tool_idx);
 
        std::string secondary_display_type;
        if (secondary_logical < (int)filament_presets.size()) {
            Preset* p = bundle->filaments.find_preset(filament_presets[secondary_logical]);
            if (p) p->get_filament_type(secondary_display_type);
        }
        if (secondary_display_type.empty()) secondary_display_type = "unknown";
 
        // Check 1: bed temperature — primary wins, secondary may not get what it needs
        if (bed_temps && primary_bed_temp > 0 && secondary_logical < (int)bed_temps->values.size()) {
            const int secondary_bed_temp = bed_temps->values[secondary_logical];
            if (secondary_bed_temp > 0 && std::abs(secondary_bed_temp - primary_bed_temp) > 5) {
                warnings.push_back(wxString::Format(
                    _L("Bed temperature conflict: T%d (%s) sets the bed to %d℃ \u2014 "
                       "T%d (%s) requires %d℃. The primary tool controls the bed; "
                       "secondary tools print at whatever temperature it sets."),
                    primary_tool, primary_display_type, primary_bed_temp,
                    tool_idx, secondary_display_type, secondary_bed_temp));
            }
        }
 
        // Check 2: filament type mismatch
        if (primary_display_type != secondary_display_type &&
            primary_display_type != "unknown" && secondary_display_type != "unknown") {
            warnings.push_back(wxString::Format(
                _L("Filament type mismatch: T%d uses %s and T%d uses %s. "
                   "These materials have incompatible requirements and are not designed to print together."),
                primary_tool, primary_display_type,
                tool_idx, secondary_display_type));
        }
    }
 
    return warnings;
}

References _L, Slic3r::GUI::PartPlate::config(), Slic3r::Preset::config, Slic3r::effective_physical_extruder_map(), Slic3r::PresetBundle::filament_presets, Slic3r::PresetBundle::filaments, Slic3r::PresetCollection::find_preset(), Slic3r::first_filament_for_physical_head(), Slic3r::PresetBundle::full_config(), Slic3r::get_bed_temp_key(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::GUI::PartPlate::get_effective_imex_mode(), Slic3r::GUI::PartPlate::get_extruders(), Slic3r::Preset::get_filament_type(), Slic3r::imex_resolve_routing(), Slic3r::kImexPrimaryMode, MAXIMUM_EXTRUDER_NUMBER, Slic3r::DynamicConfig::opt_enum(), Slic3r::ConfigBase::option(), Slic3r::GUI::Plater::p, Slic3r::parse_imex_head_filament_map(), Slic3r::ImexRouting::primary_logical, Slic3r::ImexRouting::primary_phys, Slic3r::PresetBundle::printers, Slic3r::PresetBundle::project_config, Slic3r::resolve_filament_for_head(), Slic3r::ImexRouting::routes_to_primary(), Slic3r::ConfigOptionVector< int >::size(), and Slic3r::ImexRouting::tools.

Referenced by Slic3r::GUI::Plater::priv::on_action_slice_all(), and Slic3r::GUI::Plater::priv::on_action_slice_plate().

Here is the call graph for this function:

Here is the caller graph for this function:

collect_preset_color_items()

std::vector< ColorPickerPopup::ColorItem > Slic3r::GUI::collect_preset_color_items ( const std::string & filament_id )

static

{
    std::vector<ColorPickerPopup::ColorItem> items;
    if (filament_id.empty()) return items;
 
    auto* clr_query = GUI::wxGetApp().get_filament_color_code_query();
    if (!clr_query) return items;
 
    auto* agent = wxGetApp().getAgent();
    const std::string catalog_id = agent ? agent->from_orca_filament_id(filament_id) : filament_id;
    FilamentColorCodes* color_codes = clr_query->GetFilaInfoMap(wxString::FromUTF8(catalog_id));
    if (!color_codes || !color_codes->GetFilamentColor2CodeMap()) return items;
 
    std::set<std::string> seen;
    for (const auto& color_pair : *color_codes->GetFilamentColor2CodeMap()) {
        const FilamentColor& fila_color = color_pair.first;
        FilamentColorCode* color_code = color_pair.second;
        if (!color_code || fila_color.GetColors().empty()) continue;
 
        ColorPickerPopup::ColorItem item;
        item.ctype = fila_color.ColorCount() < 2 ? 2 :
            (fila_color.m_color_type == FilamentColor::ColorType::GRADIENT_CLR ? 0 : 1);
        item.name = color_code->GetFilaColorName();
 
        std::string key = std::to_string(item.ctype);
        for (const wxColour& color : fila_color.GetColors()) {
            item.colors.emplace_back(color);
            char rgba[9];
            std::snprintf(rgba, sizeof(rgba), "%02X%02X%02X%02X",
                static_cast<unsigned>(color.Red()), static_cast<unsigned>(color.Green()),
                static_cast<unsigned>(color.Blue()), static_cast<unsigned>(color.Alpha()));
            key += "|" + std::string(rgba);
        }
 
        if (item.colors.empty() || !seen.insert(key).second) continue;
        items.emplace_back(std::move(item));
    }
 
    return items;
}

References Slic3r::FilamentColor::ColorCount(), Slic3r::GUI::ColorPickerPopup::ColorItem::colors, Slic3r::GUI::ColorPickerPopup::ColorItem::ctype, Slic3r::FilamentColor::GetColors(), Slic3r::FilamentColorCode::GetFilaColorName(), Slic3r::FilamentColorCodes::GetFilamentColor2CodeMap(), Slic3r::FilamentColor::GRADIENT_CLR, Slic3r::FilamentColor::m_color_type, and Slic3r::GUI::ColorPickerPopup::ColorItem::name.

Referenced by Slic3r::GUI::AMSMaterialsSetting::on_clr_picker().

Here is the call graph for this function:

Here is the caller graph for this function:

COLOR_BG_CARD()

const wxColour Slic3r::GUI::COLOR_BG_CARD ( "#F8F8F8" )

static

Referenced by Slic3r::GUI::ColorDecomposeDialog::create_mode_card(), and Slic3r::GUI::ColorDecomposeDialog::update_mode_card_content().

Here is the caller graph for this function:

COLOR_BORDER_NORMAL()

const wxColour Slic3r::GUI::COLOR_BORDER_NORMAL ( "#EEEEEE" )

static

Referenced by Slic3r::GUI::ColorDecomposeDialog::create_mode_card().

Here is the caller graph for this function:

COLOR_BRAND()

const wxColour Slic3r::GUI::COLOR_BRAND ( "#009688" )

static

Referenced by Slic3r::GUI::ColorDecomposeDialog::create_mode_card().

Here is the caller graph for this function:

COLOR_DIVIDER()

const wxColour Slic3r::GUI::COLOR_DIVIDER ( "#EEEEEE" )

static

Referenced by create_h_divider().

Here is the caller graph for this function:

COLOR_LABEL_GREY()

const wxColour Slic3r::GUI::COLOR_LABEL_GREY ( "#ACACAC" )

static

Referenced by create_mode_group_label().

Here is the caller graph for this function:

COLOR_LABEL_MUTED()

const wxColour Slic3r::GUI::COLOR_LABEL_MUTED ( "#6B6A6A" )

static

Referenced by Slic3r::GUI::MixedFilamentDialog::create_material_selection(), Slic3r::GUI::MixedFilamentDialog::create_preview_panel(), Slic3r::GUI::MixedFilamentDialog::create_ratio_slider(), and Slic3r::GUI::MixedFilamentDialog::create_triangle_picker().

Here is the caller graph for this function:

color_string()

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(), Slic3r::GUI::DiffModel::AddPreset(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

COLOR_TEXT_DARK()

const wxColour Slic3r::GUI::COLOR_TEXT_DARK ( "#262E30" )

static

Referenced by Slic3r::GUI::ColorDecomposeDialog::create_mode_selection_section(), Slic3r::GUI::ColorDecomposeDialog::create_target_color_section(), and Slic3r::GUI::ColorDecomposeDialog::update_mode_card_content().

Here is the caller graph for this function:

colour_to_ams_string()

std::string Slic3r::GUI::colour_to_ams_string ( const wxColour & color )

static

{
    char col_buf[10];
    sprintf(col_buf, "%02X%02X%02X%02X", (int)color.Red(), (int)color.Green(), (int)color.Blue(), (int)color.Alpha());
    return col_buf;
}

Referenced by Slic3r::GUI::AMSMaterialsSetting::on_select_ok().

Here is the caller graph for this function:

combo_append_index()

int Slic3r::GUI::combo_append_index ( ComboBox * c, const wxString & label, int index )

static

{
    const int row = c->Append(label, wxNullBitmap);
    c->SetClientData(unsigned(row), reinterpret_cast<void*>(intptr_t(index)));
    return row;
}

References ComboBox::Append().

Referenced by Slic3r::GUI::DesignPanel::DesignPanel(), Slic3r::GUI::DesignPanel::load_feature_into_dialog(), Slic3r::GUI::DesignPanel::open_tool(), and Slic3r::GUI::DesignPanel::populate_sheet_body_choices().

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

commit_icon()

std::string Slic3r::GUI::commit_icon ( bool bodies )

static

{
    const std::string name = bodies ? "toolbar_add_plate_bodies" : "toolbar_add_plate";
    return dp_dark() ? name + "_dark" : name;
}

References dp_dark().

Referenced by Slic3r::GUI::DesignPanel::DesignPanel(), and Slic3r::GUI::DesignPanel::set_commit_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

compare_ascii_case_insensitive_natural()

int Slic3r::GUI::compare_ascii_case_insensitive_natural ( const std::string & lhs, const std::string & rhs )

inline

    {
        std::size_t li = 0;
        std::size_t ri = 0;
 
        while (li < lhs.size() && ri < rhs.size())
        {
            const unsigned char lc = static_cast<unsigned char>(lhs[li]);
            const unsigned char rc = static_cast<unsigned char>(rhs[ri]);
 
            if (std::isdigit(lc) && std::isdigit(rc))
            {
                const std::size_t lhs_digit_begin = li;
                const std::size_t rhs_digit_begin = ri;
                while (li < lhs.size() && std::isdigit(static_cast<unsigned char>(lhs[li])))
                    ++li;
                while (ri < rhs.size() && std::isdigit(static_cast<unsigned char>(rhs[ri])))
                    ++ri;
 
                const std::string_view lhs_run(lhs.data() + lhs_digit_begin, li - lhs_digit_begin);
                const std::string_view rhs_run(rhs.data() + rhs_digit_begin, ri - rhs_digit_begin);
                // why: digit runs compare numerically; leading zeros only break exact ties ("1" < "01").
                const std::string_view lhs_num = lhs_run.substr(std::min(lhs_run.find_first_not_of('0'), lhs_run.size()));
                const std::string_view rhs_num = rhs_run.substr(std::min(rhs_run.find_first_not_of('0'), rhs_run.size()));
                if (lhs_num.size() != rhs_num.size())
                    return lhs_num.size() < rhs_num.size() ? -1 : 1;
                if (const int cmp = lhs_num.compare(rhs_num); cmp != 0)
                    return cmp;
                // note: fewer-leading-zeros-first is our convention, not an industry standard (impls
                //   diverge here); it only matters as a deterministic total order for unstable std::sort.
                if (lhs_run.size() != rhs_run.size())
                    return lhs_run.size() < rhs_run.size() ? -1 : 1;
                continue;
            }
 
            const int lower_lhs = std::tolower(lc);
            const int lower_rhs = std::tolower(rc);
            if (lower_lhs != lower_rhs)
                return lower_lhs < lower_rhs ? -1 : 1;
 
            ++li;
            ++ri;
        }
 
        if (li == lhs.size() && ri == rhs.size())
            return 0;
        return li == lhs.size() ? -1 : 1;
    }

Referenced by compare_plugin_base_order(), compare_plugin_sort_key(), and compare_plugin_version().

Here is the caller graph for this function:

compare_plugin_base_order()

template<class PluginItem>

int Slic3r::GUI::compare_plugin_base_order	(	const PluginItem &	lhs,
		const PluginItem &	rhs )

    {
        if (const int cmp = compare_ascii_case_insensitive_natural(lhs.display_name, rhs.display_name); cmp != 0)
            return cmp;
        if (const int cmp = static_cast<int>(lhs.source) - static_cast<int>(rhs.source); cmp != 0)
            return cmp;
        if (const int cmp = static_cast<int>(lhs.status) - static_cast<int>(rhs.status); cmp != 0)
            return cmp;
        if (const int cmp = lhs.type_key.compare(rhs.type_key); cmp != 0)
            return cmp;
        return lhs.plugin_key.compare(rhs.plugin_key);
    }

References compare_ascii_case_insensitive_natural().

Here is the call graph for this function:

compare_plugin_sort_key()

template<class PluginItem>

int Slic3r::GUI::compare_plugin_sort_key	(	const PluginItem &	lhs,
		const PluginItem &	rhs,
		PluginSortKey	sort_key )

    {
        switch (sort_key)
        {
        case PluginSortKey::Status:
            // why: PluginStatus/PluginSource declare the dialog sort priority as their ordinal order.
            return static_cast<int>(lhs.status) - static_cast<int>(rhs.status);
        case PluginSortKey::Name:
            return compare_ascii_case_insensitive_natural(lhs.display_name, rhs.display_name);
        case PluginSortKey::Source:
            return static_cast<int>(lhs.source) - static_cast<int>(rhs.source);
        case PluginSortKey::Version:
            return compare_plugin_version(lhs.sort_version, rhs.sort_version);
        case PluginSortKey::None:
            // why: no primary key - every pair ties here so sort_plugin_items_for_dialog falls
            //   straight to the ascending base order (direction is irrelevant for the baseline).
            return 0;
        }
 
        return 0;
    }

References compare_ascii_case_insensitive_natural(), compare_plugin_version(), Name, None, Source, Status, and Version.

Here is the call graph for this function:

compare_plugin_version()

int Slic3r::GUI::compare_plugin_version ( const std::string & lhs, const std::string & rhs )

inline

    {
        const auto lhs_semver = Semver::parse(lhs);
        const auto rhs_semver = Semver::parse(rhs);
        if (lhs_semver && rhs_semver)
        {
            if (*lhs_semver < *rhs_semver) return -1;
            if (*rhs_semver < *lhs_semver) return 1;
            return 0;
        }
        return compare_ascii_case_insensitive_natural(lhs, rhs);
    }

References compare_ascii_case_insensitive_natural(), and Slic3r::Semver::parse().

Referenced by compare_plugin_sort_key().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_belt_back_transform()

Transform3d Slic3r::GUI::compute_belt_back_transform ( const PrintConfig & cfg )

static

{
    if (!cfg.belt_printer.value)
        return Transform3d::Identity();
 
    MachineFrameTransform mft;
    mft.init_from_config(cfg);
    const Transform3d mf_inv = mft.is_active() ? Transform3d(mft.transform().inverse())
                                               : Transform3d::Identity();
 
    // Forward G-code axis remap as an affine matrix (out_i = sign * in[r_i % 3], plus a
    // build-volume offset for Rev axes). This is the matrix form of the per-point
    // GCodeWriter::apply_axis_remap (row convention: each OUTPUT axis selects an input
    // axis + sign) and MUST stay in sync with it. The build-volume max matches what the
    // writer is fed in GCode.cpp (printable_area max + printable_height). (Follow-up:
    // precompute this matrix once in GCodeWriter and share it with apply_axis_remap to
    // remove the parallel encoding.)
    Transform3d ar = Transform3d::Identity();
    const int rr[3] = { int(cfg.gcode_remap_x.value), int(cfg.gcode_remap_y.value), int(cfg.gcode_remap_z.value) };
    if (rr[0] != 0 || rr[1] != 1 || rr[2] != 2) {
        BoundingBoxf bbox_bed(cfg.printable_area.values);
        const Vec3d vmax(bbox_bed.max.x(), bbox_bed.max.y(), cfg.printable_height.value);
        Matrix3d M = Matrix3d::Zero();
        Vec3d    t = Vec3d::Zero();
        for (int i = 0; i < 3; ++i) {
            const int axis = rr[i] % 3;
            if (rr[i] < 3)      M(i, axis) =  1.0;
            else if (rr[i] < 6) M(i, axis) = -1.0;
            else              { M(i, axis) = -1.0; t[i] = vmax[axis]; }
        }
        ar.linear()      = M;
        ar.translation() = t;
    }
    const Transform3d ar_inv = ar.inverse();
 
    return ar_inv * mf_inv;
}

References Slic3r::MachineFrameTransform::init_from_config(), Slic3r::MachineFrameTransform::is_active(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, and Slic3r::MachineFrameTransform::transform().

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

Here is the call graph for this function:

Here is the caller graph for this function:

concat()

std::vector< std::string > Slic3r::GUI::concat ( std::vector< std::string > const & l, std::vector< std::string > const & r )

static

{
    std::vector<std::string> t;
    bool l_is_sorted = std::is_sorted(l.begin(), l.end());
    bool r_is_sorted = std::is_sorted(r.begin(), r.end());
 
    if (l_is_sorted && r_is_sorted) {
        std::set_union(l.begin(), l.end(), r.begin(), r.end(), std::back_inserter(t));
        return t;
    }
 
    std::vector<std::string> l_sorted = l;
    std::vector<std::string> r_sorted = r;
    std::sort(l_sorted.begin(), l_sorted.end());
    std::sort(r_sorted.begin(), r_sorted.end());
    std::set_union(l_sorted.begin(), l_sorted.end(), r_sorted.begin(), r_sorted.end(), std::back_inserter(t));
    return t;
}

References concat().

Referenced by Slic3r::GUI::TabPrintLayer::TabPrintLayer(), Slic3r::GUI::TabPrintObject::TabPrintObject(), Slic3r::GUI::TabPrintPlate::TabPrintPlate(), concat(), Slic3r::GUI::TabPrintModel::on_value_change(), Slic3r::GUI::TabPrintPlate::on_value_change(), Slic3r::GUI::TabPrintModel::reload_config(), Slic3r::GUI::TabPrintModel::update_custom_dirty(), and Slic3r::GUI::TabPrintModel::update_model_config().

Here is the call graph for this function:

Here is the caller graph for this function:

concat_strings()

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()

const std::string Slic3r::GUI::CONFIG_UPDATE_WIKI_URL ( "" )

static

confirm_create_decompose_missing_components()

bool Slic3r::GUI::confirm_create_decompose_missing_components	(	wxWindow *	parent,
		const std::vector< DecomposeMissingComponent > &	missing )

{
    if (missing.empty())
        return true;
 
    static const char* config_key = "not_show_color_decompose_missing_component_tip";
    if (wxGetApp().app_config->get(config_key) == "1") {
        return true;
    }
 
    wxString missing_text;
    for (size_t i = 0; i < missing.size(); ++i) {
        if (i > 0)
            missing_text += _L(", ");
        missing_text += missing[i].display_name;
    }
 
    wxString message = wxString::Format(_L_PLURAL("The current filament list does not contain %s. A project filament required by "
                                                  "the mixed filament will be created automatically after decomposition.",
                                                  "The current filament list does not contain %s. Project filaments required by "
                                                  "the mixed filament will be created automatically after decomposition.",
                                                  missing.size()),
                                        missing_text);
 
    MessageDialog dlg(parent, message, _L("Tip"), wxOK | wxCANCEL | wxICON_INFORMATION);
    dlg.show_dsa_button();
    int res = dlg.ShowModal();
    if (res == wxID_OK && dlg.get_checkbox_state())
        wxGetApp().app_config->set(config_key, "1");
    return res == wxID_OK;
}

References _L, _L_PLURAL, Slic3r::GUI::MsgDialog::get_checkbox_state(), Slic3r::GUI::MsgDialog::show_dsa_button(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by Slic3r::GUI::Sidebar::decompose_filament_color().

Here is the call graph for this function:

Here is the caller graph for this function:

constraint_id()

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_start_dragging().

Here is the caller graph for this function:

constraint_reject_text()

wxString Slic3r::GUI::constraint_reject_text ( ConstraintReject reason, SketchConstraintType type )

static

{
    using T = SketchConstraintType;
    switch (reason) {
    case ConstraintReject::NeedOneEntity:        return _L("Pick an entity first");
    case ConstraintReject::NeedTwoEntities:      return _L("Pick two entities first");
    case ConstraintReject::NeedALine:            return _L("Horizontal and Vertical apply to a line");
    case ConstraintReject::NeedTwoLines:
        if (type == T::Angle)     return _L("Angle applies between two lines");
        if (type == T::Collinear) return _L("Collinear needs two lines");
        return _L("Parallel, perpendicular and equal length apply to two lines");
    case ConstraintReject::NeedTwoRounds:
        if (type == T::EqualRadius) return _L("Equal radius needs two circles or arcs");
        return _L("Concentric needs two circles or arcs");
    case ConstraintReject::NeedTangentPair:      return _L("Tangent needs a line and a circle/arc, or two circles/arcs");
    case ConstraintReject::NeedJoinablePoints:   return _L("This constraint needs two entities with a point to join");
    case ConstraintReject::NeedMeasurablePoints: return _L("This dimension needs two entities with a point to measure between");
    case ConstraintReject::NeedPointAndLine:     return _L("Midpoint needs a point and a line");
    case ConstraintReject::NeedTwoPointsOrLines:
        if (type == T::Symmetric) return _L("Symmetric needs two points or two lines + an axis");
        return _L("Symmetric needs two points or two lines");
    case ConstraintReject::NeedAxisLine:         return _L("Symmetric: pick two entities, then an axis line");
    case ConstraintReject::NeedRound:            return _L("Radius/Diameter needs a circle or arc");
    case ConstraintReject::Unsupported:          return _L("Unsupported constraint");
    case ConstraintReject::None:
    default:                                     return wxString();
    }
}

References _L, Slic3r::NeedALine, Slic3r::NeedAxisLine, Slic3r::NeedJoinablePoints, Slic3r::NeedMeasurablePoints, Slic3r::NeedOneEntity, Slic3r::NeedPointAndLine, Slic3r::NeedRound, Slic3r::NeedTangentPair, Slic3r::NeedTwoEntities, Slic3r::NeedTwoLines, Slic3r::NeedTwoPointsOrLines, Slic3r::NeedTwoRounds, Slic3r::None, and Slic3r::Unsupported.

Referenced by Slic3r::GUI::DesignPanel::apply_entity_constraint(), and Slic3r::GUI::DesignPanel::apply_live_constraint().

Here is the caller graph for this function:

construct_error_string()

bool Slic3r::GUI::construct_error_string ( ObjectFilamentResults & object_result, std::string & error_string )

static

{
    error_string.clear();
    if (!object_result.partly_outside_objects.empty()) {
        error_string += _u8L("Following objects are laid over the boundary of plate or exceeds the height limit:\n");
        for(auto& object: object_result.partly_outside_objects)
        {
            error_string += object->name;
            error_string += "\n";
        }
        error_string += _u8L("Please solve the problem by moving it totally on or off the plate, and confirming that the height is within the build volume.\n");
        return true;
    }
    return false;
}

References _u8L, and Slic3r::ObjectFilamentResults::partly_outside_objects.

Referenced by Slic3r::GUI::GLCanvas3D::check_volumes_outside_state(), and Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the caller graph for this function:

construct_extruder_unprintable_error()

std::pair< bool, bool > Slic3r::GUI::construct_extruder_unprintable_error ( ObjectFilamentResults & object_result, std::string & left_extruder_unprintable_text, std::string & right_extruder_unprintable_text )

static

{
    left_extruder_unprintable_text.clear();
    right_extruder_unprintable_text.clear();
    if (object_result.filaments.empty())
        return {false,false};
 
    const std::vector<std::string> nozzle_name_list = { _u8L("left nozzle"), _u8L("right nozzle") };
 
    std::vector<ObjectFilamentInfo> left_unprintable_objects;
    std::vector<ObjectFilamentInfo> right_unprintable_objects;
 
    std::vector<int> conflicted_filaments = object_result.filaments;
 
    auto mode = object_result.mode;
 
    for (auto& obj_filament : object_result.object_filaments) {
        bool found_left = false;
        bool found_right = false;
 
        if (mode == FilamentMapMode::fmmManual) {
            for (auto& elem : obj_filament.manual_filaments) {
                int extruder_id = elem.second;
                if (extruder_id == 1) {
                    found_left = true;
                }
                if (extruder_id == 2) {
                    found_right = true;
                }
            }
        }
        else {
            if (!obj_filament.auto_filaments.empty()) {
                found_left = true;
                found_right = true;
            }
        }
 
        if (found_left)
            left_unprintable_objects.emplace_back(obj_filament);
        if (found_right)
            right_unprintable_objects.emplace_back(obj_filament);
    }
 
    Preset &preset = GUI::wxGetApp().preset_bundle->printers.get_edited_preset();
    float   left_x_min = 0, left_x_max = 0, left_y_min = 0, left_y_max = 0, left_z_min = 0, left_z_max = 0;
    float   right_x_min = 0, right_x_max = 0, right_y_min = 0, right_y_max = 0, right_z_min = 0, right_z_max = 0;
    auto printable_height_option = preset.config.option<ConfigOptionFloatsNullable>("extruder_printable_height");
    if (printable_height_option && printable_height_option->values.size() == 2) {
        left_z_max = (float) printable_height_option->values[0];
        right_z_max = (float) printable_height_option->values[1];
    }
    std::vector<Pointfs> printable_areas = preset.config.option<ConfigOptionPointsGroups>("extruder_printable_area")->values;
    if (printable_areas.size() == 2 && printable_areas[0].size() == 4) {
        left_x_min = printable_areas[0][0][0];
        left_y_min = printable_areas[0][0][1];
        left_x_max = printable_areas[0][2][0];
        left_y_max = printable_areas[0][2][1];
 
        right_x_min = printable_areas[1][0][0];
        right_y_min = printable_areas[1][0][1];
        right_x_max = printable_areas[1][2][0];
        right_y_max = printable_areas[1][2][1];
    }
 
    std::vector<std::string> tips(2);
    for (size_t idx = 0; idx < tips.size(); ++idx) {
        const auto& unprintable_objs = idx == 0 ? left_unprintable_objects : right_unprintable_objects;
        auto& output_text = idx == 0 ? left_extruder_unprintable_text : right_extruder_unprintable_text;
        if (unprintable_objs.empty())
            continue;
        std::string nozzle_name = nozzle_name_list[idx];
        std::string model_prefix;
        if ((idx == 0 && left_unprintable_objects.size() > 1) || (idx == 1 && right_unprintable_objects.size() > 1))
            model_prefix = (boost::format(_u8L("The position or size of some models exceeds the %s's printable range.")) % nozzle_name).str();
        else
            model_prefix = (boost::format(_u8L("The position or size of the model %s exceeds the %s's printable range."))
                           %unprintable_objs.front().object->name % nozzle_name).str();
        tips[idx] += model_prefix;
 
        tips[idx] += (boost::format(_u8L(" Please check and adjust the part's position or size to fit the printable range:\n"))).str();
        if (idx == 0)
            tips[idx] += (boost::format(_u8L("Left nozzle: X:%1%-%2%, Y:%3%-%4%, Z:%5%-%6%\n"))
                         % format_number(left_x_min) % format_number(left_x_max) % format_number(left_y_min)
                         % format_number(left_y_max) % format_number(left_z_min) % format_number(left_z_max)).str();
        else
            tips[idx] += (boost::format(_u8L("Right nozzle: X:%1%-%2%, Y:%3%-%4%, Z:%5%-%6%"))
                         %format_number(right_x_min) %format_number(right_x_max) %format_number(right_y_min)
                         %format_number(right_y_max) %format_number(right_z_min) %format_number(right_z_max)).str();
        output_text = tips[idx];
    }
 
    return { !left_unprintable_objects.empty(),!right_unprintable_objects.empty() };
}

References _u8L, Slic3r::Preset::config, Slic3r::ObjectFilamentResults::filaments, Slic3r::fmmManual, format_number(), Slic3r::ObjectFilamentResults::mode, Slic3r::ObjectFilamentResults::object_filaments, and Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::GLCanvas3D::check_volumes_outside_state(), and Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the call graph for this function:

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.printable_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.printable_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.printable_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.printable_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.printable_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::BuildVolume::bounding_volume(), Slic3r::Geometry::Circle< Vector >::center, Slic3r::Circle, Slic3r::BuildVolume::circle(), Slic3r::BoundingBox3Base< PointType >::contains(), Slic3r::Convex, Slic3r::Custom, epsilon(), Slic3r::GUI::GLModel::get_bounding_box(), Slic3r::GUI::GLModel::get_geometry(), Slic3r::BoundingBox3Base< PointType >::inflated(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::BuildVolume::printable_height(), Slic3r::Geometry::Circle< Vector >::radius, Slic3r::Rectangle, Slic3r::sqr(), Slic3r::BuildVolume::type(), and Slic3r::unscaled().

Here is the call graph for this function:

context_bit()

uint8_t Slic3r::GUI::context_bit ( ShortcutContext context )

constexpr

{ return uint8_t(1u << unsigned(context)); }

Referenced by Slic3r::GUI::ShortcutCaptureDialog::ShortcutCaptureDialog(), Slic3r::GUI::ShortcutRegistry::lookup(), Slic3r::GUI::ShortcutRegistry::match(), Slic3r::GUI::ShortcutCaptureDialog::record(), and shortcuts_in().

Here is the caller graph for this function:

convert_face_colors()

void Slic3r::GUI::convert_face_colors ( const std::vector< std::array< std::size_t, 3 > > & src, std::vector< std::array< float, 3 > > & dst )

static

{
    dst.resize(src.size());
    for (size_t i = 0; i < src.size(); ++i)
        dst[i] = { src[i][0] / 255.f, src[i][1] / 255.f, src[i][2] / 255.f };
}

Referenced by Slic3r::GUI::TexturePreviewCanvas::set_face_colors(), and Slic3r::GUI::TexturePreviewCanvas::set_original_face_colors().

Here is the caller graph for this function:

convert_input()

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:

convert_newlines_to_br()

std::string Slic3r::GUI::convert_newlines_to_br ( const std::string & text )

static

                                                               {
    std::string result = text;
    size_t pos = 0;
    while ((pos = result.find('\n', pos)) != std::string::npos) {
        result.replace(pos, 1, "<br>");
        pos += 4;
    }
    return result;
}

Referenced by Slic3r::GUI::ProjectPanel::on_reload().

Here is the caller graph for this function:

convert_to_rgba()

RGBA Slic3r::GUI::convert_to_rgba

(

const wxColour &

color

)

{
    RGBA rgba;
    rgba[0] = std::clamp(color.Red() / 255.f, 0.f, 1.f);
    rgba[1] = std::clamp(color.Green() / 255.f, 0.f, 1.f);
    rgba[2] = std::clamp(color.Blue() / 255.f, 0.f, 1.f);
    rgba[3] = std::clamp(color.Alpha() / 255.f, 0.f, 1.f);
    return rgba;
}

convert_to_wxColour()

wxColour Slic3r::GUI::convert_to_wxColour

(

const RGBA &

color

)

{
    auto     r = std::clamp((int) (color[0] * 255.f), 0, 255);
    auto     g = std::clamp((int) (color[1] * 255.f), 0, 255);
    auto     b = std::clamp((int) (color[2] * 255.f), 0, 255);
    auto     a = std::clamp((int) (color[3] * 255.f), 0, 255);
    wxColour wx_color(r, g, b, a);
    return wx_color;
}

copy_file_gui()

CopyFileResult Slic3r::GUI::copy_file_gui	(	const std::string &	from,
		const std::string &	to,
		std::string &	error_message,
		const bool	with_check )

{
#ifdef WIN32
    //still has exceptions
    /*wxString src = from_u8(from);
    wxString dest = from_u8(to);
 
    bool result = CopyFile(src.wc_str(), dest.wc_str(), false);
    if (!result) {
        DWORD errCode = GetLastError();
        error_message = "Error: " + errCode;
        return FAIL_COPY_FILE;
    }
    return SUCCESS;*/
 
    wxString src = from_u8(from);
    wxString dest = from_u8(to);
    BOOL result;
    char* buff = nullptr;
    HANDLE handlesrc = nullptr;
    HANDLE handledst = nullptr;
    CopyFileResult ret = SUCCESS;
    DWORD size = 0;
    DWORD dwRead = 0, dwWrite = 0;
 
    handlesrc = CreateFile(src.wc_str(),
        GENERIC_READ,
        FILE_SHARE_READ,
        NULL,
        OPEN_EXISTING,
        FILE_ATTRIBUTE_TEMPORARY,
        0);
    if(handlesrc==INVALID_HANDLE_VALUE){
        error_message = "Error: open src file";
        ret = FAIL_COPY_FILE;
        goto __finished;
    }
 
    handledst=CreateFile(dest.wc_str(),
        GENERIC_WRITE,
        FILE_SHARE_READ,
        NULL,
        CREATE_ALWAYS,
        FILE_ATTRIBUTE_TEMPORARY,
        0);
    if(handledst==INVALID_HANDLE_VALUE){
        error_message = "Error: create dest file";
        ret = FAIL_COPY_FILE;
        goto __finished;
    }
 
    size = GetFileSize(handlesrc,NULL);
    buff = new char[size+1];
    result = ReadFile(handlesrc, buff, size, &dwRead, NULL);
    if (!result) {
        DWORD errCode = GetLastError();
        error_message = "Error: " + std::to_string(errCode);
        ret = FAIL_COPY_FILE;
        goto __finished;
    }
    buff[size]=0;
    result = WriteFile(handledst,buff,size,&dwWrite,NULL);
    if (!result) {
        DWORD errCode = GetLastError();
        error_message = "Error: " + std::to_string(errCode);
        ret = FAIL_COPY_FILE;
        goto __finished;
    }
 
__finished:
    if (handlesrc)
        CloseHandle(handlesrc);
    if (handledst)
        CloseHandle(handledst);
    if (buff)
        delete[] buff;
 
    return ret;
#else
    return copy_file(from, to, error_message, with_check);
#endif
}

References Slic3r::copy_file(), Slic3r::FAIL_COPY_FILE, from_u8(), and Slic3r::SUCCESS.

Here is the call graph for this function:

count_decompose_new_physical_filaments()

size_t Slic3r::GUI::count_decompose_new_physical_filaments	(	const ColorDecomposeResult &	result,
		const std::vector< std::string > &	physical_colors,
		const std::vector< std::string > &	physical_types,
		size_t	source_physical_idx,
		const std::vector< size_t > *	physical_config_indices )

{
    if (result.mode != DecomposeMode::CMYW && result.mode != DecomposeMode::RYBW)
        return 0;
 
    std::vector<size_t> fallback_indices;
    const std::vector<size_t>* indices = physical_config_indices;
    if (!indices) {
        fallback_indices.resize(physical_colors.size());
        for (size_t i = 0; i < fallback_indices.size(); ++i)
            fallback_indices[i] = i;
        indices = &fallback_indices;
    }
 
    size_t source_config_idx = size_t(-1);
    if (source_physical_idx < indices->size())
        source_config_idx = (*indices)[source_physical_idx];
 
    const std::string basic_type =
        decompose_basic_type_from_source(source_config_idx, source_physical_idx, physical_types);
 
    size_t missing_count = 0;
    for (const DecomposeComponent& comp : result.components) {
        if (comp.base_color == DecomposeBaseColor::None)
            continue;
        DecomposeOfficialComponent official_component =
            lookup_decompose_official_component(basic_type, comp.base_color, comp.colour);
        int existing_idx = find_existing_decompose_component(official_component, physical_colors,
                                                             *indices, source_config_idx);
        if (existing_idx <= 0)
            ++missing_count;
    }
    return missing_count;
}

References Slic3r::GUI::DecomposeComponent::base_color, Slic3r::GUI::DecomposeComponent::colour, Slic3r::GUI::ColorDecomposeResult::components, decompose_basic_type_from_source(), find_existing_decompose_component(), lookup_decompose_official_component(), Slic3r::GUI::ColorDecomposeResult::mode, and None.

Referenced by Slic3r::GUI::ColorDecomposeDialog::update_filament_limit_warning().

Here is the call graph for this function:

Here is the caller graph for this function:

create_checkbox() [1/3]

wxBoxSizer * Slic3r::GUI::create_checkbox ( wxWindow * parent, Preset * preset, wxString & preset_name, std::vector< std::pair<::CheckBox *, Preset * > > & preset_checkbox )

static

{
    wxBoxSizer *sizer    = new wxBoxSizer(wxHORIZONTAL);
    ::CheckBox *  checkbox = new ::CheckBox(parent);
    sizer->Add(checkbox, 0, 0, 0);
    preset_checkbox.push_back(std::make_pair(checkbox, preset));
    wxStaticText *preset_name_str = new wxStaticText(parent, wxID_ANY, preset_name);
    wxToolTip *   toolTip         = new wxToolTip(preset_name);
    preset_name_str->SetToolTip(toolTip);
    sizer->Add(preset_name_str, 0, wxLEFT, 5);
    return sizer;
}

References wxStaticText.

Referenced by Slic3r::GUI::CreateFilamentPresetDialog::create_filament_preset_item(), Slic3r::GUI::ExportConfigsDialog::select_curr_radiobox(), and Slic3r::GUI::CreatePrinterPresetDialog::update_presets_list().

Here is the caller graph for this function:

create_checkbox() [2/3]

wxBoxSizer * Slic3r::GUI::create_checkbox ( wxWindow * parent, std::string & compatible_printer, Preset * preset, std::unordered_map<::CheckBox *, std::pair< std::string, Preset * > > & ptinter_compatible_filament_preset )

static

{
    wxBoxSizer *sizer    = new wxBoxSizer(wxHORIZONTAL);
    ::CheckBox *checkbox = new ::CheckBox(parent);
    sizer->Add(checkbox, 0, 0, 0);
    ptinter_compatible_filament_preset[checkbox] = std::make_pair(compatible_printer, preset);
    wxStaticText *preset_name_str = new wxStaticText(parent, wxID_ANY, wxString::FromUTF8(compatible_printer));
    sizer->Add(preset_name_str, 0, wxLEFT, 5);
    return sizer;
}

References wxStaticText.

create_checkbox() [3/3]

wxBoxSizer * Slic3r::GUI::create_checkbox ( wxWindow * parent, wxString & preset_name, std::vector< std::pair<::CheckBox *, std::string > > & preset_checkbox )

static

{
    wxBoxSizer *sizer    = new wxBoxSizer(wxHORIZONTAL);
    ::CheckBox *checkbox = new ::CheckBox(parent);
    sizer->Add(checkbox, 0, 0, 0);
    preset_checkbox.push_back(std::make_pair(checkbox, into_u8(preset_name)));
    wxStaticText *preset_name_str = new wxStaticText(parent, wxID_ANY, preset_name);
    sizer->Add(preset_name_str, 0, wxLEFT, 5);
    return sizer;
}

References into_u8(), and wxStaticText.

Here is the call graph for this function:

create_color_swatch()

wxPanel * Slic3r::GUI::create_color_swatch ( wxWindow * parent, const wxColour & color, int size )

static

{
    auto* panel = new wxPanel(parent, wxID_ANY, wxDefaultPosition, wxSize(size, size));
    panel->SetBackgroundColour(color);
    panel->SetMinSize(wxSize(size, size));
    panel->SetBackgroundStyle(wxBG_STYLE_PAINT);
    panel->Bind(wxEVT_PAINT, [panel](wxPaintEvent&) {
        wxAutoBufferedPaintDC dc(panel);
        wxSize sz = panel->GetClientSize();
        wxColour c = panel->GetBackgroundColour();
        dc.SetPen(*wxTRANSPARENT_PEN);
        dc.SetBrush(wxBrush(c));
        dc.DrawRectangle(0, 0, sz.GetWidth(), sz.GetHeight());
        // Mirror sidebar (FilamentBitmapUtils::create_single_filament_bitmap):
        // gray border for near-white in light mode so white swatches stay
        // visible on a white background; light border for near-black in dark mode.
        const bool light_mode = !wxGetApp().dark_mode();
        if ((light_mode && c.Red() > 224 && c.Green() > 224 && c.Blue() > 224) ||
            (!light_mode && c.Red() < 45 && c.Green() < 45 && c.Blue() < 45)) {
            dc.SetBrush(*wxTRANSPARENT_BRUSH);
            dc.SetPen(wxPen(light_mode ? wxColour(130, 130, 128) : wxColour(207, 207, 207),
                            1, wxPENSTYLE_SOLID));
            dc.DrawRectangle(0, 0, sz.GetWidth(), sz.GetHeight());
        }
    });
    return panel;
}

Referenced by Slic3r::GUI::ColorDecomposeDialog::create_target_color_section(), and Slic3r::GUI::ColorDecomposeDialog::update_mode_card_content().

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_condition()

RaycastManager::AllowVolumes Slic3r::GUI::create_condition	(	const ModelVolumePtrs &	volumes,
		const ObjectID &	disallowed_volume_id )

Create condition to allowe only parts from volumes without one given.

Parameters

volumes	List of allowed volumes included one which is dissalowed and non parts
disallowed_volume_id	Disallowed volume

Returns

Condition

                                                                                                                  {
    std::vector<size_t> allowed_volumes_id;
    if (volumes.size() > 1) {
        allowed_volumes_id.reserve(volumes.size() - 1);
        for (const ModelVolume *v : volumes) {
            // drag only above part not modifiers or negative surface
            if (!v->is_model_part())
                continue;
 
            // skip actual selected object
            if (v->id() == disallowed_volume_id)
                continue;
 
            allowed_volumes_id.emplace_back(v->id().id);
        }
    }
    return RaycastManager::AllowVolumes(allowed_volumes_id);
}

Referenced by calc_distance(), and anonymous_namespace{SurfaceDrag.cpp}::start_dragging().

Here is the caller graph for this function:

create_dual_filament_bitmap()

wxBitmap Slic3r::GUI::create_dual_filament_bitmap ( const wxColour & color1, const wxColour & color2, const wxSize & size )

static

{
    BitmapDC bdc = init_bitmap_dc(size);
 
    int half_width = size.GetWidth() / 2;
 
    bdc.dc.SetBrush(wxBrush(color1));
    bdc.dc.DrawRectangle(0, 0, half_width, size.GetHeight());
 
    bdc.dc.SetBrush(wxBrush(color2));
    bdc.dc.DrawRectangle(half_width, 0, size.GetWidth() - half_width, size.GetHeight());
 
    bdc.dc.SelectObject(wxNullBitmap);
    return bdc.bitmap;
}

References Slic3r::GUI::BitmapDC::bitmap, Slic3r::GUI::BitmapDC::dc, and init_bitmap_dc().

Referenced by create_filament_bitmap().

Here is the call graph for this function:

Here is the caller graph for this function:

create_filament_bitmap()

wxBitmap Slic3r::GUI::create_filament_bitmap	(	const std::vector< wxColour > &	colors,
		const wxSize &	size,
		bool	force_gradient )

{
    if (colors.empty()) return wxNullBitmap;
 
    if (force_gradient && colors.size() >= 2) {
        return create_gradient_filament_bitmap(colors, size);
    }
 
    switch (colors.size()) {
        case 1: return create_single_filament_bitmap(colors[0], size);
        case 2: return create_dual_filament_bitmap(colors[0], colors[1], size);
        case 3: return create_triple_filament_bitmap(colors, size);
        case 4: return create_quadruple_filament_bitmap(colors, size);
        default: return create_gradient_filament_bitmap(colors, size);
    }
}

References create_dual_filament_bitmap(), create_gradient_filament_bitmap(), create_quadruple_filament_bitmap(), create_single_filament_bitmap(), and create_triple_filament_bitmap().

Referenced by Slic3r::GUI::FilamentPickerDialog::CreateColorBitmap(), Slic3r::GUI::FilamentPickerDialog::CreateColorGrid(), get_extruder_color_icon(), Slic3r::GUI::FilamentPickerDialog::UpdateCustomColorPreview(), and Slic3r::GUI::FilamentPickerDialog::UpdatePreview().

Here is the call graph for this function:

Here is the caller graph for this function:

create_freq_settings_popupmenu()

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 filaments_cnt = filaments_count();
 
    for (auto& category : bundle) {
        if (is_improper_category(category.first, filaments_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 == _("Quality")) {
                        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());
    }
}

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

Here is the call graph for this function:

create_gradient_filament_bitmap()

wxBitmap Slic3r::GUI::create_gradient_filament_bitmap ( const std::vector< wxColour > & colors, const wxSize & size )

static

{
    BitmapDC bdc = init_bitmap_dc(size);
 
    if (colors.size() == 1) {
        return create_single_filament_bitmap(colors[0], size);
    }
 
    // use segment gradient, make transition more natural
    wxDC& dc = bdc.dc;
    int total_width = size.GetWidth();
    int height = size.GetHeight();
 
    // calculate segment count
    int segment_count = colors.size() - 1;
    double segment_width = (double)total_width / segment_count;
 
    int left = 0;
    for (int i = 0; i < segment_count; i++) {
        int current_width = (int)segment_width;
 
        // handle last segment, ensure fully filled
        if (i == segment_count - 1) {
            current_width = total_width - left;
        }
 
        // avoid width exceed boundary
        if (left + current_width > total_width) {
            current_width = total_width - left;
        }
 
        if (current_width > 0) {
            auto rect = wxRect(left, 0, current_width, height);
            dc.GradientFillLinear(rect, colors[i], colors[i + 1], wxEAST);
            left += current_width;
        }
    }
 
    bdc.dc.SelectObject(wxNullBitmap);
    return bdc.bitmap;
}

References Slic3r::GUI::BitmapDC::bitmap, create_single_filament_bitmap(), Slic3r::GUI::BitmapDC::dc, and init_bitmap_dc().

Referenced by create_filament_bitmap().

Here is the call graph for this function:

Here is the caller graph for this function:

create_gradient_ramp_bitmap()

wxBitmap Slic3r::GUI::create_gradient_ramp_bitmap	(	const std::vector< wxColour > &	ramp,
		const wxSize &	size )

{
    if (ramp.empty()) return wxNullBitmap;
 
    BitmapDC bdc = init_bitmap_dc(size);
    if (!bdc.dc.IsOk()) return wxNullBitmap;
 
    fill_gradient_ramp_rect(bdc.dc, wxRect(0, 0, size.GetWidth(), size.GetHeight()), ramp);
 
    bdc.dc.SelectObject(wxNullBitmap);
    return bdc.bitmap;
}

References Slic3r::GUI::BitmapDC::bitmap, Slic3r::GUI::BitmapDC::dc, fill_gradient_ramp_rect(), and init_bitmap_dc().

Referenced by get_extruder_color_icon().

Here is the call graph for this function:

Here is the caller graph for this function:

create_h_divider()

wxPanel * Slic3r::GUI::create_h_divider ( wxWindow * parent, int fixed_width = -1 )

static

{
    const int h = parent->FromDIP(1);
    int w = fixed_width > 0 ? fixed_width : -1;
    auto* panel = new wxPanel(parent, wxID_ANY, wxDefaultPosition, wxSize(w, h));
    panel->SetMinSize(wxSize(w, h));
    if (fixed_width > 0)
        panel->SetMaxSize(wxSize(fixed_width, h));
    panel->SetBackgroundColour(StateColor::darkModeColorFor(COLOR_DIVIDER));
    return panel;
}

References COLOR_DIVIDER(), and StateColor::darkModeColorFor().

Referenced by Slic3r::GUI::ColorDecomposeDialog::build_ui(), Slic3r::GUI::ColorDecomposeDialog::create_mode_card(), and Slic3r::GUI::ColorDecomposeDialog::create_mode_selection_section().

Here is the call graph for this function:

Here is the caller graph for this function:

create_mesh()

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);
 
    TriangleMesh mesh;
    if (type_name == "Cube")
        // Sitting on the print bed, left front front corner at (0, 0).
        mesh = TriangleMesh(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 = TriangleMesh(its_make_cylinder(0.5 * 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 = TriangleMesh(its_make_sphere(0.5 * side, PI / 90));
    else if (type_name == "Slab")
        // Sitting on the print bed, left front front corner at (0, 0).
        mesh = TriangleMesh(its_make_cube(bb.size().x() * 1.5, bb.size().y() * 1.5, bb.size().z() * 0.5));
    else if (type_name == "Cone")
        mesh = TriangleMesh(its_make_cone(0.5 * side, side));
    else if (type_name == "Disc")
        mesh = TriangleMesh(its_make_cylinder(0.5 * side, 0.2f));
    else if (type_name == "Torus")
        mesh = TriangleMesh(its_make_torus(0.5 * side, 0.125 * side,(PI / 60)));
    return mesh;
}

References Slic3r::its_make_cone(), Slic3r::its_make_cube(), Slic3r::its_make_cylinder(), Slic3r::its_make_sphere(), Slic3r::its_make_torus(), 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::ObjectBase::id(), Slic3r::ObjectID::id, Slic3r::Model::objects, Slic3r::GUI::RaycastManager::AllowVolumes::skip(), Slic3r::GUI::SceneRaycaster::Volume, and Slic3r::GLVolumeCollection::volumes.

Referenced by calc_distance(), anonymous_namespace{EmbossJob.cpp}::start_create_volume_on_surface_job(), and anonymous_namespace{SurfaceDrag.cpp}::start_dragging().

Here is the call graph for this function:

Here is the caller graph for this function:

create_mixed_filament_from_result()

bool Slic3r::GUI::create_mixed_filament_from_result ( Sidebar * sidebar, const MixedFilamentResult & result, const std::vector< std::string > & color_strs )

static

{
    if (!sidebar || result.components.size() < 2 || result.ratios.size() < 2)
        return false;
    if (!dynamic_cast<Plater*>(sidebar->GetParent()))
        return false;
 
    size_t num_physical = sidebar->combos_filament().size();
    if (num_physical < 2)
        return false;
    if (wxGetApp().preset_bundle->filament_presets.size() >= size_t(EnforcerBlockerType::ExtruderMax))
        return false;
 
    auto& project_config = wxGetApp().preset_bundle->project_config;
    size_t total = wxGetApp().preset_bundle->filament_presets.size();
    size_t new_idx = total;
 
    std::string mixed_color = blend_mixed_color(result.components, result.ratios, color_strs);
    wxGetApp().preset_bundle->set_num_filaments(total + 1, mixed_color);
 
    auto* multi_colour_opt = project_config.option<ConfigOptionStrings>("filament_multi_colour");
    if (multi_colour_opt) {
        while (multi_colour_opt->values.size() <= new_idx) multi_colour_opt->values.push_back("");
        multi_colour_opt->values[new_idx] = mixed_color;
    }
 
    // set_num_filaments() above already grows these parallel arrays; the writes are still
    // size-guarded so a sizing bug degrades into a no-op rather than a heap overwrite.
    {
        auto* is_mixed_opt = project_config.option<ConfigOptionBools>("filament_is_mixed");
        while (is_mixed_opt->values.size() <= new_idx) is_mixed_opt->values.push_back(false);
        is_mixed_opt->values[new_idx] = true;
    }
 
    {
        auto* comp_opt = project_config.option<ConfigOptionStrings>("filament_mixed_components");
        while (comp_opt->values.size() <= new_idx) comp_opt->values.push_back(std::string{});
        comp_opt->values[new_idx] = format_mixed_components(result.components);
    }
    {
        auto* ratios_opt = project_config.option<ConfigOptionStrings>("filament_mixed_sublayer_ratios");
        while (ratios_opt->values.size() <= new_idx) ratios_opt->values.push_back(std::string{});
        ratios_opt->values[new_idx] = format_mixed_ratios(result.ratios);
    }
 
    if (!project_config.option("filament_mixed_gradient"))
        project_config.set_key_value("filament_mixed_gradient", new ConfigOptionBools({false}));
    if (!project_config.option("filament_mixed_gradient_range"))
        project_config.set_key_value("filament_mixed_gradient_range", new ConfigOptionStrings({""}) );
    if (!project_config.option("filament_mixed_gradient_curve"))
        project_config.set_key_value("filament_mixed_gradient_curve", new ConfigOptionStrings({""}) );
    if (!project_config.option("filament_mixed_gradient_per_part"))
        project_config.set_key_value("filament_mixed_gradient_per_part", new ConfigOptionBools({false}));
 
    {
        auto* grad_opt = project_config.option<ConfigOptionBools>("filament_mixed_gradient");
        while (grad_opt->values.size() <= new_idx) grad_opt->values.push_back(false);
        grad_opt->values[new_idx] = result.gradient_enabled;
    }
    {
        auto* grad_range_opt = project_config.option<ConfigOptionStrings>("filament_mixed_gradient_range");
        while (grad_range_opt->values.size() <= new_idx) grad_range_opt->values.push_back("");
        if (result.gradient_enabled && result.components.size() == 2) {
            const char* fmt = (result.gradient_direction == 0) ? "0.9000,0.1000" : "0.1000,0.9000";
            grad_range_opt->values[new_idx] = fmt;
        } else {
            grad_range_opt->values[new_idx] = "";
        }
    }
    {
        auto* grad_curve_opt = project_config.option<ConfigOptionStrings>("filament_mixed_gradient_curve");
        while (grad_curve_opt->values.size() <= new_idx) grad_curve_opt->values.push_back("");
        grad_curve_opt->values[new_idx] = serialize_mixed_gradient_curve_if_custom(result);
    }
    {
        auto* per_part_opt = project_config.option<ConfigOptionBools>("filament_mixed_gradient_per_part");
        while (per_part_opt->values.size() <= new_idx) per_part_opt->values.push_back(false);
        per_part_opt->values[new_idx] = result.gradient_enabled && result.per_part_gradient;
    }
 
    auto& presets = wxGetApp().preset_bundle->filament_presets;
    if (result.components[0] >= 1 && result.components[0] <= num_physical && presets.size() > new_idx)
        presets[new_idx] = presets[result.components[0] - 1];
 
    size_t filament_count = wxGetApp().preset_bundle->filament_presets.size();
    wxGetApp().plater()->get_partplate_list().on_filament_added(filament_count);
    wxGetApp().plater()->on_filament_count_change(filament_count);
    wxGetApp().get_tab(Preset::TYPE_PRINT)->update();
    wxGetApp().preset_bundle->export_selections(*wxGetApp().app_config);
 
    sidebar->update_mixed_filament_list();
    wxGetApp().plater()->update_project_dirty_from_presets();
    wxPostEvent(sidebar, SimpleEvent(EVT_SCHEDULE_BACKGROUND_PROCESS, sidebar));
    return true;
}

References blend_mixed_color(), Slic3r::GUI::Sidebar::combos_filament(), Slic3r::GUI::MixedFilamentResult::components, Slic3r::ExtruderMax, Slic3r::format_mixed_components(), Slic3r::format_mixed_ratios(), Slic3r::GUI::MixedFilamentResult::gradient_direction, Slic3r::GUI::MixedFilamentResult::gradient_enabled, Slic3r::GUI::MixedFilamentResult::per_part_gradient, Slic3r::GUI::MixedFilamentResult::ratios, serialize_mixed_gradient_curve_if_custom(), Slic3r::ConfigOptionVector< T >::size(), Slic3r::Preset::TYPE_PRINT, Slic3r::GUI::Sidebar::update_mixed_filament_list(), and Slic3r::ConfigOptionVector< T >::values.

Referenced by Slic3r::GUI::Sidebar::add_mixed_filament(), Slic3r::GUI::Plater::priv::apply_textured_mesh_import_result(), Slic3r::GUI::Sidebar::decompose_filament_color(), and Slic3r::GUI::Sidebar::ensure_mixed_filament().

Here is the call graph for this function:

Here is the caller graph for this function:

create_mode_group_label()

wxStaticText * Slic3r::GUI::create_mode_group_label ( wxWindow * parent, const wxString & text )

static

{
    auto* label = new wxStaticText(parent, wxID_ANY, text);
    label->SetFont(Label::Body_11);
    label->SetForegroundColour(StateColor::darkModeColorFor(COLOR_LABEL_GREY));
    return label;
}

References Label::Body_11, COLOR_LABEL_GREY(), StateColor::darkModeColorFor(), and wxStaticText.

Referenced by Slic3r::GUI::ColorDecomposeDialog::create_mode_selection_section().

Here is the call graph for this function:

Here is the caller graph for this function:

create_preset_tree()

wxBoxSizer * Slic3r::GUI::create_preset_tree ( wxWindow * parent, std::pair< std::string, std::vector< std::shared_ptr< Preset > > > printer_and_preset )

static

{
    wxTreeCtrl *treeCtrl = new wxTreeCtrl(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTR_DEFAULT_STYLE | wxNO_BORDER);
    wxColour    backgroundColor = parent->GetBackgroundColour();
    treeCtrl->SetBackgroundColour(backgroundColor);
 
    wxString     printer_name = wxString::FromUTF8(printer_and_preset.first);
    wxTreeItemId rootId       = treeCtrl->AddRoot(printer_name);
    int          row          = 1;
    for (std::shared_ptr<Preset> preset : printer_and_preset.second) {
        wxString     preset_name = wxString::FromUTF8(preset->name);
        wxTreeItemId childId1    = treeCtrl->AppendItem(rootId, preset_name);
        row++;
    }
 
    treeCtrl->Expand(rootId);
    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
    treeCtrl->SetMinSize(wxSize(-1, row * 22));
    treeCtrl->SetMaxSize(wxSize(-1, row * 22));
    sizer->Add(treeCtrl, 0, wxEXPAND | wxALL, 0);
 
    return sizer;
}

create_printer_webview_handler()

std::unique_ptr< PrinterWebViewHandler > Slic3r::GUI::create_printer_webview_handler

(

PrinterWebView &

owner

)

{
    auto     cfg = get_active_printer_config();
    if(cfg == nullptr) return nullptr;
    
    const auto host_type = cfg->option<ConfigOptionEnum<PrintHostType>>("host_type")->value;
    switch (host_type)
    {
        case PrintHostType::htElegooLink:
            return std::make_unique<ElegooPrinterWebViewHandler>(owner);
        default:
            return nullptr;
    }
}

References Slic3r::htElegooLink.

Referenced by Slic3r::GUI::PrinterWebView::load_url().

Here is the caller graph for this function:

create_quadruple_filament_bitmap()

wxBitmap Slic3r::GUI::create_quadruple_filament_bitmap ( const std::vector< wxColour > & colors, const wxSize & size )

static

{
    BitmapDC bdc = init_bitmap_dc(size);
 
    int half_width = (size.GetWidth() + 1) / 2;
    int half_height = (size.GetHeight() + 1) / 2;
 
    const int rects[4][4] = {
        {0, 0, half_width, half_height},                    // Top left
        {half_width, 0, size.GetWidth() - half_width, half_height},           // Top right
        {0, half_height, half_width, size.GetHeight() - half_height},         // Bottom left
        {half_width, half_height, size.GetWidth() - half_width, size.GetHeight() - half_height}  // Bottom right
    };
 
    for (int i = 0; i < 4; i++) {
        bdc.dc.SetBrush(wxBrush(colors[i]));
        bdc.dc.DrawRectangle(rects[i][0], rects[i][1], rects[i][2], rects[i][3]);
    }
 
    bdc.dc.SelectObject(wxNullBitmap);
    return bdc.bitmap;
}

References Slic3r::GUI::BitmapDC::bitmap, Slic3r::GUI::BitmapDC::dc, and init_bitmap_dc().

Referenced by create_filament_bitmap().

Here is the call graph for this function:

Here is the caller graph for this function:

create_select_filament_preset_checkbox()

wxBoxSizer * Slic3r::GUI::create_select_filament_preset_checkbox ( wxWindow * parent, std::string & compatible_printer, std::vector< Preset * > presets, std::unordered_map<::CheckBox *, std::pair< std::string, Preset * > > & machine_filament_preset )

static

{
    wxBoxSizer *horizontal_sizer = new wxBoxSizer(wxHORIZONTAL);
    wxBoxSizer *checkbox_sizer   = new wxBoxSizer(wxVERTICAL);
    ::CheckBox *checkbox         = new ::CheckBox(parent);
    checkbox_sizer->Add(checkbox, 0, wxEXPAND | wxRIGHT, 5);
 
    wxBoxSizer *combobox_sizer = new wxBoxSizer(wxVERTICAL);
    wxStaticText *machine_name_str = new wxStaticText(parent, wxID_ANY, wxString::FromUTF8(compatible_printer));
    ComboBox *    combobox        = new ComboBox(parent, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(200, 24), 0, nullptr, wxCB_READONLY);
    combobox->SetBackgroundColor(PRINTER_LIST_COLOUR);
    combobox->SetBorderColor(*wxWHITE);
    combobox->SetLabel(_L("Select filament preset"));
    combobox->Bind(wxEVT_COMBOBOX, [combobox, checkbox, presets, &machine_filament_preset, compatible_printer](wxCommandEvent &e) {
        combobox->SetLabelColor(*wxBLACK);
        wxString preset_name = combobox->GetStringSelection();
        checkbox->SetValue(true);
        for (Preset *preset : presets) {
            if (preset_name == wxString::FromUTF8(preset->name)) {
                machine_filament_preset[checkbox] = std::make_pair(compatible_printer, preset);
            }
        }
        e.Skip();
    });
    combobox_sizer->Add(machine_name_str, 0, wxEXPAND, 0);
    combobox_sizer->Add(combobox, 0, wxEXPAND | wxTOP, 5);
 
    wxArrayString choices;
    for (Preset *preset : presets) {
        choices.Add(wxString::FromUTF8(preset->name));
    }
    combobox->Set(choices);
 
    horizontal_sizer->Add(checkbox_sizer);
    horizontal_sizer->Add(combobox_sizer);
    return horizontal_sizer;
}

References _L, PRINTER_LIST_COLOUR, ComboBox::SetLabel(), CheckBox::SetValue(), and wxStaticText.

Referenced by Slic3r::GUI::CreateFilamentPresetDialog::get_filament_presets_by_machine().

Here is the call graph for this function:

Here is the caller graph for this function:

create_settings_popupmenu()

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() &&
            wxGetSelectedChoices(selections, _L("Select settings"), category_name, names) != -1) {
            for (auto sel : selections)
                category_options[sel].second = true;
        }
        return category_options;
    };
 
    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::category_name(), Slic3r::GUI::SettingsFactory::get_category_bitmap(), get_full_settings_hierarchy(), Slic3r::GUI::ObjectList::get_item_config(), Slic3r::ModelConfig::keys(), obj_list(), and plater().

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_single_filament_bitmap()

wxBitmap Slic3r::GUI::create_single_filament_bitmap ( const wxColour & color, const wxSize & size )

static

{
    // Check if color is transparent
    if (is_transparent_color(color)) {
        return create_transparent_bitmap(size);
    }
 
    BitmapDC bdc = init_bitmap_dc(size);
    if (!bdc.dc.IsOk()) return wxNullBitmap;
 
    bdc.dc.SetBackground(wxBrush(color));
    bdc.dc.Clear();
    bdc.dc.SetBrush(wxBrush(color));
    bdc.dc.DrawRectangle(0, 0, size.GetWidth(), size.GetHeight());
 
    // Add gray border for light colors (similar to wxExtensions.cpp logic) - only in light mode
    if (!wxGetApp().dark_mode() && color.Red() > 224 && color.Blue() > 224 && color.Green() > 224) {
        bdc.dc.SetPen(wxPen(wxColour(130, 130, 128), 1, wxPENSTYLE_SOLID));
        bdc.dc.SetBrush(*wxTRANSPARENT_BRUSH);
        bdc.dc.DrawRectangle(0, 0, size.GetWidth(), size.GetHeight());
    }
 
    // Add white border for dark colors - only in dark mode
    if(wxGetApp().dark_mode() && color.Red() < 45 && color.Blue() < 45 && color.Green() < 45) {
        bdc.dc.SetPen(wxPen(wxColour(207, 207, 207), 1, wxPENSTYLE_SOLID));
        bdc.dc.SetBrush(*wxTRANSPARENT_BRUSH);
        bdc.dc.DrawRectangle(0, 0, size.GetWidth(), size.GetHeight());
    }
 
    bdc.dc.SelectObject(wxNullBitmap);
    return bdc.bitmap;
}

References Slic3r::GUI::BitmapDC::bitmap, create_transparent_bitmap(), Slic3r::GUI::BitmapDC::dc, init_bitmap_dc(), and is_transparent_color().

Referenced by create_filament_bitmap(), and create_gradient_filament_bitmap().

Here is the call graph for this function:

Here is the caller graph for this function:

create_transparent_bitmap()

wxBitmap Slic3r::GUI::create_transparent_bitmap ( const wxSize & size )

static

                                                              {
    BitmapDC bdc = init_bitmap_dc(size);
    if (!bdc.dc.IsOk()) return wxNullBitmap;
 
    // Create checkerboard pattern
    wxColour light_gray(217, 217, 217);  // #D9D9D9
    wxColour white(255, 255, 255);
 
    bool is_dark_mode = wxGetApp().dark_mode();
 
    // Calculate parameters based on mode
    int start_pos = is_dark_mode ? 0 : 1;
    int end_width = is_dark_mode ? size.GetWidth() : size.GetWidth() - 1;
    int end_height = is_dark_mode ? size.GetHeight() : size.GetHeight() - 1;
    int square_size = std::max(6, std::min(end_width - start_pos, end_height - start_pos) / 8);
 
    // Draw checkerboard
    for (int x = start_pos; x < end_width; x += square_size) {
        for (int y = start_pos; y < end_height; y += square_size) {
            bool is_light = ((x / square_size) + (y / square_size)) % 2 == 0;
            bdc.dc.SetBrush(wxBrush(is_light ? white : light_gray));
 
            int width = std::min(square_size, size.GetWidth() - x);
            int height = std::min(square_size, size.GetHeight() - y);
            bdc.dc.DrawRectangle(x, y, width, height);
        }
    }
 
    // Add border only in light mode
    if (!is_dark_mode) {
        bdc.dc.SetPen(wxPen(wxColour(130, 130, 128), 1, wxPENSTYLE_SOLID));
        bdc.dc.SetBrush(*wxTRANSPARENT_BRUSH);
        bdc.dc.DrawRectangle(0, 0, size.GetWidth(), size.GetHeight());
    }
 
    bdc.dc.SelectObject(wxNullBitmap);
    return bdc.bitmap;
}

References Slic3r::GUI::BitmapDC::bitmap, Slic3r::GUI::BitmapDC::dc, and init_bitmap_dc().

Referenced by create_single_filament_bitmap().

Here is the call graph for this function:

Here is the caller graph for this function:

create_triple_filament_bitmap()

wxBitmap Slic3r::GUI::create_triple_filament_bitmap ( const std::vector< wxColour > & colors, const wxSize & size )

static

{
    BitmapDC bdc = init_bitmap_dc(size);
 
    int third_width = size.GetWidth() / 3;
    int remaining_width = size.GetWidth() - (third_width * 2);
 
    // Draw three vertical sections
    bdc.dc.SetBrush(wxBrush(colors[0]));
    bdc.dc.DrawRectangle(0, 0, third_width, size.GetHeight());
 
    bdc.dc.SetBrush(wxBrush(colors[1]));
    bdc.dc.DrawRectangle(third_width, 0, third_width, size.GetHeight());
 
    bdc.dc.SetBrush(wxBrush(colors[2]));
    bdc.dc.DrawRectangle(third_width * 2, 0, remaining_width, size.GetHeight());
 
    bdc.dc.SelectObject(wxNullBitmap);
    return bdc.bitmap;
}

References Slic3r::GUI::BitmapDC::bitmap, Slic3r::GUI::BitmapDC::dc, and init_bitmap_dc().

Referenced by create_filament_bitmap().

Here is the call graph for this function:

Here is the caller graph for this function:

custom_gcode_group_title()

wxString Slic3r::GUI::custom_gcode_group_title ( const Page * page, const t_config_option_key & opt_key )

static

{
    if (page)
        for (const auto& opt_group : page->m_optgroups)
            for (const auto& opt : opt_group->opt_map())
                if (opt.second.first == opt_key)
                    return opt_group->title;
    return from_u8(opt_key);
}

References from_u8(), and Slic3r::GUI::Page::m_optgroups.

Referenced by Slic3r::GUI::Tab::edit_custom_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

cut_model()

void Slic3r::GUI::cut_model ( Model & model, double z, ModelObjectCutAttributes attributes )

static

{
    size_t obj_idx = 0;
    size_t instance_idx = 0;
    if (!attributes.has(ModelObjectCutAttribute::KeepUpper) && !attributes.has(ModelObjectCutAttribute::KeepLower))
        return;
 
    auto* object = model.objects[0];
 
    const Vec3d instance_offset = object->instances[instance_idx]->get_offset();
    Cut         cut(object, instance_idx, Geometry::translation_transform(z * Vec3d::UnitZ() - instance_offset), attributes);
    const auto  new_objects = cut.perform_with_plane();
    model.delete_object(obj_idx);
 
    for (ModelObject *model_object : new_objects) {
        auto *object = model.add_object(*model_object);
        object->sort_volumes(true);
        std::string object_name = object->name.empty() ? fs::path(object->input_file).filename().string() : object->name;
        object->ensure_on_bed();
    }
}

References Slic3r::Model::add_object(), Slic3r::Model::delete_object(), Slic3r::enum_bitmask< option_type, typename >::has(), Slic3r::KeepLower, Slic3r::KeepUpper, Slic3r::Model::objects, Slic3r::Cut::perform_with_plane(), Slic3r::ModelObject::sort_volumes(), and Slic3r::Geometry::translation_transform().

Referenced by Slic3r::GUI::CalibUtils::calib_max_vol_speed(), Slic3r::GUI::CalibUtils::calib_retraction(), Slic3r::GUI::CalibUtils::calib_temptue(), and Slic3r::GUI::CalibUtils::calib_VFA().

Here is the call graph for this function:

Here is the caller graph for this function:

dash_polyline()

std::vector< std::vector< Vec2d > > Slic3r::GUI::dash_polyline ( const std::vector< Vec2d > & pts, bool closed, double dash, double gap )

static

{
    std::vector<std::vector<Vec2d>> out;
    if (pts.size() < 2 || dash <= 0.0 || gap <= 0.0) return out;
    const size_t segs = closed ? pts.size() : pts.size() - 1;
    bool   on   = true;      // start on a dash, so a short entity is still visible
    double left = dash;      // distance remaining in the current dash/gap
    std::vector<Vec2d> cur;
    if (on) cur.push_back(pts[0]);
    for (size_t i = 0; i < segs; ++i) {
        const Vec2d a = pts[i], b = pts[(i + 1) % pts.size()];
        double seg = (b - a).norm();
        if (seg < 1e-12) continue;
        const Vec2d dir = (b - a) / seg;
        double t = 0.0;
        while (seg - t > left) {
            t += left;
            const Vec2d p = a + dir * t;
            if (on) { cur.push_back(p); out.push_back(cur); cur.clear(); }
            else    { cur.clear(); cur.push_back(p); }
            on   = !on;
            left = on ? dash : gap;
        }
        left -= (seg - t);
        if (on) cur.push_back(b);
    }
    if (on && cur.size() >= 2) out.push_back(cur);
    return out;
}

References dash_polyline().

Referenced by dash_polyline(), and Slic3r::GUI::DesignSketchTool::render().

Here is the call graph for this function:

Here is the caller graph for this function:

dataview_remove_insets()

void Slic3r::GUI::dataview_remove_insets

(

wxDataViewCtrl *

dv

)

                                                {
    NSScrollView* scrollview = (NSScrollView*) ((wxCocoaDataViewControl*)dv->GetDataViewPeer())->GetWXWidget();
    NSOutlineView* outlineview = scrollview.documentView;
    [outlineview setIntercellSpacing: NSMakeSize(0.0, 1.0)];
    if (@available(macOS 11, *)) {
        [outlineview setStyle:NSTableViewStylePlain];
    }
}

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

Here is the caller graph for this function:

debugged()

bool Slic3r::GUI::debugged

(

)

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

decode()

std::string Slic3r::GUI::decode ( std::string const & extra, std::string const & path = {} )

static

                                                                        {}) {
    char const* p = extra.data();
    char const* e = p + extra.length();
    while (p + 4 < e) {
        boost::uint16_t len = ((boost::uint16_t)p[2]) | ((boost::uint16_t)p[3] << 8);
        if (p[0] == '\x75' && p[1] == '\x70' && len >= 5 && p + 4 + len < e && p[4] == '\x01') {
            return std::string(p + 9, p + 4 + len);
        }
        else {
            p += 4 + len;
        }
    }
    return Slic3r::decode_path(path.c_str());
}

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

Here is the caller graph for this function:

decode_color()

wxColour Slic3r::GUI::decode_color ( const std::string & color )

static

{
    std::array<int, 3> ret = {0, 0, 0};
    const char *       c   = color.data() + 1;
    if (color.size() == 7 && color.front() == '#') {
        for (size_t j = 0; j < 3; ++j) {
            int digit1 = hex_digit_to_int(*c++);
            int digit2 = hex_digit_to_int(*c++);
            if (digit1 == -1 || digit2 == -1) break;
 
            ret[j] = float(digit1 * 16 + digit2);
        }
    }
    return wxColour(ret[0], ret[1], ret[2]);
}

References hex_digit_to_int().

Referenced by Slic3r::GUI::SliceInfoPopup::SliceInfoPopup(), decode_color_to_float_array(), Slic3r::GUI::ModelNode::get_bitmap(), Slic3r::GUI::TickCodeInfo::get_color_for_tick(), Slic3r::GUI::PartPlate::get_imex_head_filament_color(), Slic3r::GUI::ObjectTablePanel::init_filaments_and_colors(), Slic3r::GUI::anonymous_namespace{ColorPickerDialog.cpp}::parse_color(), Slic3r::GUI::GLGizmoTextureDisplacement::rank_mixes(), and Slic3r::GUI::PartPlate::update_exclusion_volume_preview_models().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_color_to_float_array()

ColorRGBA Slic3r::GUI::decode_color_to_float_array ( const std::string color )

static

{
    ColorRGBA ret = ColorRGBA::BLACK();
    decode_color(color, ret);
    return ret;
}

References Slic3r::ColorRGBA::BLACK(), and decode_color().

Referenced by Slic3r::GUI::NotificationManager::PopNotification::PopNotification(), Slic3r::GUI::IMSlider::draw_colored_band(), Slic3r::GUI::ImGuiWrapper::push_confirm_button_style(), Slic3r::GUI::ImGuiWrapper::push_radio_style(), Slic3r::GUI::IMSlider::render_add_menu(), and Slic3r::GUI::IMSlider::render_edit_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

decompose_base_color_display()

wxString Slic3r::GUI::decompose_base_color_display

(

DecomposeBaseColor

color

)

{
    switch (color) {
    case DecomposeBaseColor::Cyan:    return _L("Cyan");
    case DecomposeBaseColor::Magenta: return _L("Magenta");
    case DecomposeBaseColor::Yellow:  return _L("Yellow");
    case DecomposeBaseColor::White:   return _L("White");
    case DecomposeBaseColor::Red:     return _L("Red");
    case DecomposeBaseColor::Green:   return _L("Green");
    case DecomposeBaseColor::Blue:    return _L("Blue");
    default:                          return wxString();
    }
}

References _L, Blue, Cyan, Green, Magenta, Red, White, and Yellow.

Referenced by prepare_decompose_mixed_result().

Here is the caller graph for this function:

decompose_base_color_en()

const char * Slic3r::GUI::decompose_base_color_en

(

DecomposeBaseColor

color

)

{
    switch (color) {
    case DecomposeBaseColor::Cyan:    return "Cyan";
    case DecomposeBaseColor::Magenta: return "Magenta";
    case DecomposeBaseColor::Yellow:  return "Yellow";
    case DecomposeBaseColor::White:   return "White";
    case DecomposeBaseColor::Red:     return "Red";
    case DecomposeBaseColor::Green:   return "Green";
    case DecomposeBaseColor::Blue:    return "Blue";
    default:                          return "";
    }
}

References Blue, Cyan, Green, Magenta, Red, White, and Yellow.

Referenced by lookup_decompose_official_component().

Here is the caller graph for this function:

decompose_basic_filament_id()

std::string Slic3r::GUI::decompose_basic_filament_id

(

const std::string &

basic_type

)

{
    // The result becomes DecomposeOfficialComponent::filament_id, which the rest of this file
    // reads as one of our OF ids (translating back before it compares against the printer's
    // ids), so translate on the way out; kDecompose*FilamentId itself stays the printer-side
    // literal. The only place that would carry it further, project_config's "filament_id", is
    // dead code: that key is not in PresetBundle's s_project_options.
    const std::string printer_filament_id = basic_type == kDecomposePetgBasicType ? kDecomposePetgFilamentId : kDecomposePlaFilamentId;
    auto* agent = wxGetApp().getAgent();
    return agent ? agent->to_orca_filament_id(printer_filament_id) : printer_filament_id;
}

References kDecomposePetgBasicType, kDecomposePetgFilamentId, and kDecomposePlaFilamentId.

Referenced by lookup_decompose_official_component().

Here is the caller graph for this function:

decompose_basic_type_from_source()

std::string Slic3r::GUI::decompose_basic_type_from_source	(	size_t	source_config_idx,
		size_t	source_physical_idx,
		const std::vector< std::string > &	physical_types )

{
    auto& project_config = wxGetApp().preset_bundle->project_config;
    if (auto* filament_id_opt = project_config.option<ConfigOptionStrings>("filament_id")) {
        if (source_config_idx < filament_id_opt->values.size()) {
            // Dead in practice: "filament_id" is not in PresetBundle's s_project_options, so this
            // option() lookup (create=false) always returns null and the block never runs. Kept as
            // found, with the translation the values would need: they would be our OF ids, and the
            // two constants are the printer's own ids.
            auto* agent = wxGetApp().getAgent();
            const std::string& orca_filament_id = filament_id_opt->values[source_config_idx];
            const std::string  printer_filament_id = agent ? agent->from_orca_filament_id(orca_filament_id) : orca_filament_id;
            if (printer_filament_id == kDecomposePetgFilamentId)
                return kDecomposePetgBasicType;
            if (printer_filament_id == kDecomposePlaFilamentId)
                return kDecomposePlaBasicType;
        }
    }
 
    if (source_physical_idx < physical_types.size()) {
        const std::string& type = physical_types[source_physical_idx];
        if (type == kDecomposePetgShortType || type == kDecomposePetgBasicType)
            return kDecomposePetgBasicType;
        if (type == kDecomposePlaShortType || type == kDecomposePlaBasicType)
            return kDecomposePlaBasicType;
    }
    return kDecomposePlaBasicType;
}

References kDecomposePetgBasicType, kDecomposePetgFilamentId, kDecomposePetgShortType, kDecomposePlaBasicType, kDecomposePlaFilamentId, and kDecomposePlaShortType.

Referenced by count_decompose_new_physical_filaments(), and prepare_decompose_mixed_result().

Here is the caller graph for this function:

decompose_normalize_color_hex()

std::string Slic3r::GUI::decompose_normalize_color_hex

(

std::string

color

)

{
    if (color.size() >= 7)
        color = color.substr(0, 7);
    std::transform(color.begin(), color.end(), color.begin(), [](unsigned char c) {
        return static_cast<char>(std::toupper(c));
    });
    return color;
}

Referenced by find_existing_decompose_component(), lookup_decompose_official_component(), texture_normalize_color_hex(), and Slic3r::GUI::ColorDecomposeDialog::try_build_single_base_result().

Here is the caller graph for this function:

def_text_color()

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

static

{
    wxColour def_colour = wxGetApp().get_label_clr_default();//wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
    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:

delete_filament_preset_by_name()

bool Slic3r::GUI::delete_filament_preset_by_name ( std::string delete_preset_name, std::string & selected_preset_name )

static

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("select preset, name %1%") % delete_preset_name;
    if (delete_preset_name.empty()) return false;
 
    // Find an alternate preset to be selected after the current preset is deleted.
    PresetCollection &m_presets = wxGetApp().preset_bundle->filaments;
    if (delete_preset_name == selected_preset_name) {
        const std::deque<Preset> &presets     = m_presets.get_presets();
        size_t                    idx_current = m_presets.get_idx_selected();
 
        // Find the visible preset.
        size_t idx_new = idx_current;
        if (idx_current > presets.size()) idx_current = presets.size();
        if (idx_current < 0) idx_current = 0;
        if (idx_new < presets.size())
            for (; idx_new < presets.size() && (presets[idx_new].name == delete_preset_name || !presets[idx_new].is_visible); ++idx_new)
                ;
        if (idx_new == presets.size())
            for (idx_new = idx_current - 1; idx_new > 0 && (presets[idx_new].name == delete_preset_name || !presets[idx_new].is_visible); --idx_new)
                ;
        selected_preset_name = presets[idx_new].name;
        BOOST_LOG_TRIVIAL(info) << boost::format("cause by delete current ,choose the next visible, idx %1%, name %2%") % idx_new % selected_preset_name;
    }
 
    try {
        // BBS delete preset
        Preset *need_delete_preset = m_presets.find_preset(delete_preset_name);
        if (!need_delete_preset) BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" can't find delete preset and name: %1%") % delete_preset_name;
        if (!need_delete_preset->setting_id.empty()) {
            BOOST_LOG_TRIVIAL(info) << "delete preset = " << need_delete_preset->name << ", setting_id = " << need_delete_preset->setting_id;
            wxGetApp().delete_preset_from_cloud(need_delete_preset->setting_id, need_delete_preset->file);
        } else {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" can't preset setting id is empty and name: %1%") % delete_preset_name;
        }
        if (m_presets.get_edited_preset().name == delete_preset_name) {
            m_presets.discard_current_changes();
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("delete preset dirty and cancelled");
        }
        m_presets.delete_preset(need_delete_preset->name);
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " preset has been delete from filaments, and preset name is: " << delete_preset_name;
    } catch (const std::exception &ex) {
        // FIXME add some error reporting!
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("found exception when delete: %1% and preset name: %%") % ex.what() % delete_preset_name;
        return false;
    }
 
    return true;
}

References Slic3r::PresetCollection::delete_preset(), Slic3r::PresetCollection::discard_current_changes(), Slic3r::Preset::file, Slic3r::PresetCollection::find_preset(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::PresetCollection::get_idx_selected(), Slic3r::PresetCollection::get_presets(), Slic3r::Preset::name, and Slic3r::Preset::setting_id.

Referenced by Slic3r::GUI::EditFilamentPresetDialog::create_dialog_buttons(), and Slic3r::GUI::EditFilamentPresetDialog::delete_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_negative_sign()

void Slic3r::GUI::delete_negative_sign

(

Vec3d &

value

)

                                        {
    for (size_t i = 0; i < value.size(); i++) {
        if (abs(value[i]) < 0.001)
            value[i] = 0.f;
    }
}

Referenced by Slic3r::GUI::GizmoObjectManipulation::update_settings_value().

Here is the caller graph for this function:

deserialize_nozzle_config()

std::map< int, std::vector< DevNozzle > > Slic3r::GUI::deserialize_nozzle_config ( const std::string & config_str )

static

{
    std::map<int, std::vector<DevNozzle>> nozzle_cfg_map;
    if (config_str.empty()) return nozzle_cfg_map;
 
    std::vector<std::string> extruder_parts;
    boost::split(extruder_parts, config_str, boost::is_any_of("|"));
 
    auto get_nozzles_from_string = [](const std::string& part_str) -> std::vector<DevNozzle> {
        std::vector<DevNozzle> nozzles;
        std::vector<std::string> parts;
        boost::split(parts, part_str, boost::is_any_of(";"));
        for (const auto &part : parts) {
            std::vector<std::string> values;
            boost::split(values, part, boost::is_any_of(","));
            if (values.size() == 2) {
                DevNozzle nozzle;
                nozzle.m_diameter = std::stof(values[0]);
                nozzle.m_nozzle_flow = static_cast<NozzleFlowType>(std::stoi(values[1]));
                nozzles.push_back(nozzle);
            }
        }
        return nozzles;
    };
 
    if (extruder_parts.size() != 2) {
        auto nozzles = get_nozzles_from_string(config_str);
        nozzle_cfg_map[MAIN_EXTRUDER_ID] = nozzles;
        nozzle_cfg_map[DEPUTY_EXTRUDER_ID] = { DevNozzle() };
        return nozzle_cfg_map;
    }
 
    if (!extruder_parts[0].empty()) {
        auto nozzles = get_nozzles_from_string(extruder_parts[0]);
        nozzle_cfg_map[DEPUTY_EXTRUDER_ID] = nozzles;
    }
    if (!extruder_parts[1].empty()) {
        auto nozzles = get_nozzles_from_string(extruder_parts[1]);
        nozzle_cfg_map[MAIN_EXTRUDER_ID] = nozzles;
    }
 
    return nozzle_cfg_map;
}

References DEPUTY_EXTRUDER_ID, Slic3r::empty(), Slic3r::DevNozzle::m_diameter, Slic3r::DevNozzle::m_nozzle_flow, and MAIN_EXTRUDER_ID.

Referenced by Slic3r::GUI::Sidebar::priv::get_nozzle_options().

Here is the call graph for this function:

Here is the caller graph for this function:

deserialize_nozzle_option()

std::optional< NozzleOption > Slic3r::GUI::deserialize_nozzle_option ( const std::string & option_str )

static

                                                                                        {
    if (option_str.empty()) return std::nullopt;
 
    std::vector<std::string> parts;
    boost::split(parts, option_str, boost::is_any_of("|"));
    if (parts.size() != 2) return std::nullopt;
 
    NozzleOption option;
    option.diameter = parts[0];
 
    std::vector<std::string> extruder_parts;
    boost::split(extruder_parts, parts[1], boost::is_any_of(";"));
 
    for (const auto& extruder_part : extruder_parts) {
        if (extruder_part.empty()) continue;
 
        std::vector<std::string> extruder_data;
        boost::split(extruder_data, extruder_part, boost::is_any_of(":"));
        if (extruder_data.size() != 2) continue;
 
        int extruder_id = std::stoi(extruder_data[0]);
        std::unordered_map<NozzleVolumeType, int> stats;
 
        std::vector<std::string> stat_parts;
        boost::split(stat_parts, extruder_data[1], boost::is_any_of(","));
 
        for (const auto& stat_part : stat_parts) {
            std::vector<std::string> kv;
            boost::split(kv, stat_part, boost::is_any_of("#"));
            if (kv.size() == 2) {
                NozzleVolumeType type = static_cast<NozzleVolumeType>(std::stoi(kv[0]));
                int count = std::stoi(kv[1]);
                stats[type] = count;
            }
        }
 
        option.extruder_nozzle_stats[extruder_id] = stats;
    }
 
    return option;
}

References count, Slic3r::GUI::NozzleOption::diameter, and Slic3r::GUI::NozzleOption::extruder_nozzle_stats.

Referenced by Slic3r::GUI::Sidebar::priv::get_nozzle_options().

Here is the caller graph for this function:

design_idle_face_color()

ColorRGBA Slic3r::GUI::design_idle_face_color ( )

inline

{
    return ColorRGBA(0.72f, 0.76f, 0.80f, 0.14f);
}

Referenced by Slic3r::GUI::DesignSketchTool::render().

Here is the caller graph for this function:

design_selection_color()

ColorRGBA Slic3r::GUI::design_selection_color ( float alpha = 1.0f )

inline

{
    return ColorRGBA(0.20f, 0.85f, 1.00f, alpha);
}

Referenced by Slic3r::GUI::DesignCanvas::reload(), Slic3r::GUI::DesignSketchTool::render(), Slic3r::GUI::DesignSketchTool::render_face_outline(), and Slic3r::GUI::DesignSketchTool::render_solid_highlight().

Here is the caller graph for this function:

desktop_open_any_folder()

void Slic3r::GUI::desktop_open_any_folder

(

const std::string &

path

)

{
    // Execute command to open a file explorer, platform dependent.
 
#ifdef _WIN32
    const wxString widepath = from_u8(path);
    ::wxExecute(L"explorer /select," + widepath, wxEXEC_ASYNC, nullptr);
#elif __APPLE__
    openFolderForFile(from_u8(path));
#else
 
    // Orca#6449: Open containing dir instead of opening the file directly.
    std::string new_path = path;
    boost::filesystem::path p(new_path);
    if (!fs::is_directory(p)) {
        new_path = p.parent_path().string();
    }
    const char* argv[] = {"xdg-open", new_path.data(), nullptr};
 
    // Check if we're running in an AppImage container, if so, we need to remove AppImage's env vars,
    // because they may mess up the environment expected by the file manager.
    // Mostly this is about LD_LIBRARY_PATH, but we remove a few more too for good measure.
    if (wxGetEnv("APPIMAGE", nullptr)) {
        // We're running from AppImage
        wxEnvVariableHashMap env_vars;
        wxGetEnvMap(&env_vars);
 
        env_vars.erase("APPIMAGE");
        env_vars.erase("APPDIR");
        env_vars.erase("LD_LIBRARY_PATH");
        env_vars.erase("LD_PRELOAD");
        env_vars.erase("UNION_PRELOAD");
 
        wxExecuteEnv exec_env;
        exec_env.env = std::move(env_vars);
 
        wxString owd;
        if (wxGetEnv("OWD", &owd)) {
            // This is the original work directory from which the AppImage image was run,
            // set it as CWD for the child process:
            exec_env.cwd = std::move(owd);
        }
 
        ::wxExecute(argv, wxEXEC_ASYNC, nullptr, &exec_env);
    } else {
        // Looks like we're NOT running from AppImage, we'll make no changes to the environment.
        ::wxExecute(argv, wxEXEC_ASYNC, nullptr, nullptr);
    }
#endif
}

References from_u8(), L, and openFolderForFile().

Referenced by Slic3r::GUI::MediaFilePanel::doAction(), Slic3r::GUI::GUI_App::handle_web_request(), and Slic3r::GUI::PluginsDialog::open_plugin_folder().

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

(

)

{
  // Execute command to open a file explorer, platform dependent.
  const auto path = data_dir();
#ifdef _WIN32
    const wxString widepath = from_u8(path);
    const wchar_t *argv[] = { L"explorer", widepath.GetData(), nullptr };
    ::wxExecute(argv, wxEXEC_ASYNC, nullptr);
#elif __APPLE__
    const char *argv[] = { "open", path.data(), nullptr };
    ::wxExecute(argv, wxEXEC_ASYNC, nullptr);
#else
    const char *argv[] = { "xdg-open", path.data(), nullptr };
 
    // Check if we're running in an AppImage container, if so, we need to remove AppImage's env vars,
    // because they may mess up the environment expected by the file manager.
    // Mostly this is about LD_LIBRARY_PATH, but we remove a few more too for good measure.
    if (wxGetEnv("APPIMAGE", nullptr)) {
      // We're running from AppImage
      wxEnvVariableHashMap env_vars;
      wxGetEnvMap(&env_vars);
 
      env_vars.erase("APPIMAGE");
      env_vars.erase("APPDIR");
      env_vars.erase("LD_LIBRARY_PATH");
      env_vars.erase("LD_PRELOAD");
      env_vars.erase("UNION_PRELOAD");
 
      wxExecuteEnv exec_env;
      exec_env.env = std::move(env_vars);
 
      wxString owd;
      if (wxGetEnv("OWD", &owd)) {
        // This is the original work directory from which the AppImage image was run,
        // set it as CWD for the child process:
        exec_env.cwd = std::move(owd);
      }
 
      ::wxExecute(argv, wxEXEC_ASYNC, nullptr, &exec_env);
    } else {
      // Looks like we're NOT running from AppImage, we'll make no changes to the environment.
      ::wxExecute(argv, wxEXEC_ASYNC, nullptr, nullptr);
    }
#endif
}

References Slic3r::data_dir(), from_u8(), and L.

Referenced by Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), and Slic3r::GUI::MainFrame::generate_help_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

desktop_open_project_attachment()

bool Slic3r::GUI::desktop_open_project_attachment	(	wxWindow *	parent,
		const boost::filesystem::path &	path )

{
    // The auxiliary path is UTF-8, which is what boost::filesystem reads a narrow string as.
    const boost::filesystem::path aux_root(wxGetApp().plater()->model().get_auxiliary_file_temp_path());
    boost::system::error_code ec;
    if (!is_absolute_path_within_root(path, aux_root) || !boost::filesystem::is_regular_file(path, ec))
        return false;
 
    // Attachments come with the project and carry no download mark, so the desktop would open them without a warning.
    if (!is_safe_to_open_file_name(path.filename().string())) {
        MessageDialog dlg(parent,
                          wxString::Format(_L("\"%s\" is not a plain document, image or model file. Opening it may run it as a "
                                              "program or script on this computer.\n\n"
                                              "Only open attachments from projects you trust. Open it anyway?"),
                                           from_path(path.filename())),
                          _L("Open attachment"), wxICON_WARNING | wxYES_NO);
        if (dlg.ShowModal() != wxID_YES)
            return false;
    }
    return wxLaunchDefaultApplication(from_path(path), 0);
}

References _L, from_path(), Slic3r::is_absolute_path_within_root(), Slic3r::is_safe_to_open_file_name(), plater(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by Slic3r::GUI::AuFile::on_dclick(), and Slic3r::GUI::ProjectPanel::OnScriptMessage().

Here is the call graph for this function:

Here is the caller graph for this function:

determine_load_type()

LoadType Slic3r::GUI::determine_load_type	(	std::string	filename,
		std::string	override_setting = "" )

{
    std::string setting;
 
    if (override_setting != "") {
        setting = override_setting;
    } else {
        setting = wxGetApp().app_config->get(SETTING_PROJECT_LOAD_BEHAVIOUR);
    }
 
    if (setting == OPTION_PROJECT_LOAD_BEHAVIOUR_LOAD_GEOMETRY) {
        return LoadType::LoadGeometry;
    } else if (setting == OPTION_PROJECT_LOAD_BEHAVIOUR_ALWAYS_ASK) {
        ProjectDropDialog dlg(filename);
        if (dlg.ShowModal() == wxID_OK) {
            int      choice    = dlg.get_action();
            LoadType load_type = static_cast<LoadType>(choice);
            wxGetApp().app_config->set("import_project_action", std::to_string(choice));
 
            // BBS: jump to plater panel
            wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
            return load_type;
        }
 
        return LoadType::Unknown; // Cancel
    } else {
        return LoadType::OpenProject;
    }
}

References Slic3r::GUI::ProjectDropDialog::get_action(), LoadGeometry, OpenProject, OPTION_PROJECT_LOAD_BEHAVIOUR_ALWAYS_ASK, OPTION_PROJECT_LOAD_BEHAVIOUR_LOAD_GEOMETRY, SETTING_PROJECT_LOAD_BEHAVIOUR, Slic3r::GUI::DPIAware< P >::ShowModal(), TAB_ID_PREPARE, and Unknown.

Referenced by Slic3r::GUI::Plater::load_project(), and Slic3r::GUI::Plater::open_3mf_file().

Here is the call graph for this function:

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 Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::GLModel::Geometry::P3N3, PI, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::resolution(), and Slic3r::GUI::GLModel::Geometry::Triangles.

Here is the call 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
}

display_edge_tol()

double Slic3r::GUI::display_edge_tol ( const TopoDS_Shape & shape )

static

{
    Bnd_Box box;
    BRepBndLib::Add(shape, box);
    return std::max(1e-3 * (box.IsVoid() ? 1.0 : std::sqrt(box.SquareExtent())), 0.005);
}

References display_edge_tol().

Referenced by display_edge_tol(), Slic3r::GUI::DesignSketchTool::make_face_highlight(), and Slic3r::GUI::DesignSketchTool::refresh_body_edges().

Here is the call graph for this function:

Here is the caller graph for this function:

do_local_z_move()

void Slic3r::GUI::do_local_z_move	(	Selection &	selection,
		double	relative_move )

Translation along local z Axis (emboss direction).

Parameters

selection	Selected volume for translate
relative_move	Relative move along emboss direction

                                                                 {
    assert(!selection.is_empty());
    if (selection.is_empty()) return;
 
    selection.setup_cache();
    auto selection_translate_fnc = [&selection, relative_move]() {
        Vec3d translate = Vec3d::UnitZ() * relative_move;
        selection.translate(translate, TransformationType::Local);
    };
    selection_transform(selection, selection_translate_fnc);
}

References Slic3r::GUI::Selection::is_empty(), Slic3r::GUI::TransformationType::Local, selection_transform(), Slic3r::GUI::Selection::setup_cache(), Slic3r::GUI::Selection::translate(), and Slic3r::translate().

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoSVG::draw_distance(), and anonymous_namespace{GLGizmoEmboss.cpp}::fix_transformation().

Here is the call graph for this function:

Here is the caller graph for this function:

do_local_z_rotate()

void Slic3r::GUI::do_local_z_rotate	(	Selection &	selection,
		double	relative_angle )

Rotation around z Axis(emboss direction).

Parameters

selection	Selected volume for rotation
relative_angle	Relative angle to rotate around emboss direction

                                                                    {
    assert(!selection.is_empty());
    if(selection.is_empty()) return;
 
    bool is_single_volume = selection.volumes_count() == 1;
    assert(is_single_volume);
    if (!is_single_volume) return;
 
    // Fix angle for mirrored volume
    bool is_mirrored = false;
    const GLVolume* gl_volume = selection.get_first_volume();
    if (gl_volume != nullptr) {
        const ModelInstance *instance = get_model_instance(*gl_volume, selection.get_model()->objects);
        bool is_instance_mirrored = (instance != nullptr)? has_reflection(instance->get_matrix()) : false;
        if (is_embossed_object(selection)) {
                is_mirrored = is_instance_mirrored;
        } else {
            const ModelVolume *volume = get_model_volume(*gl_volume, selection.get_model()->objects);
            if (volume != nullptr)
                is_mirrored = is_instance_mirrored != has_reflection(volume->get_matrix());
        }
    }
    if (is_mirrored)
        relative_angle *= -1;
 
    selection.setup_cache();
    auto selection_rotate_fnc = [&selection, &relative_angle](){
        selection.rotate(Vec3d(0., 0., relative_angle), get_drag_transformation_type(selection));
    };
    selection_transform(selection, selection_rotate_fnc);
}

References get_drag_transformation_type(), Slic3r::GUI::Selection::get_first_volume(), Slic3r::ModelInstance::get_matrix(), Slic3r::ModelVolume::get_matrix(), Slic3r::GUI::Selection::get_model(), get_model_instance(), get_model_volume(), Slic3r::has_reflection(), Slic3r::GUI::Selection::is_empty(), Slic3r::Model::objects, Slic3r::GUI::Selection::rotate(), selection_transform(), Slic3r::GUI::Selection::setup_cache(), and Slic3r::GUI::Selection::volumes_count().

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoSVG::draw_rotation(), and anonymous_namespace{GLGizmoEmboss.cpp}::fix_transformation().

Here is the call graph for this function:

Here is the caller graph for this function:

dots()

wxString Slic3r::GUI::dots ( "..." , wxConvUTF8  )

static

Referenced by Slic3r::GUI::InputIpAddressDialog::InputIpAddressDialog(), Slic3r::GUI::anonymous_namespace{SceneBenchmark.cpp}::SceneBenchmarkDialog::SceneBenchmarkDialog(), Slic3r::GUI::TroubleshootDialog::TroubleshootDialog(), Slic3r::GUI::MenuFactory::append_menu_item_export_drc(), Slic3r::GUI::MenuFactory::append_menu_item_export_stl(), Slic3r::GUI::MenuFactory::append_menu_item_replace_all_with_stl(), Slic3r::GUI::MenuFactory::append_menu_item_replace_with_stl(), Slic3r::GUI::MenuFactory::append_menu_items_instance_manipulation(), Slic3r::GUI::PluginConfigField::BUILD(), Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings(), Slic3r::GUI::Tab::compatible_widget_create(), Slic3r::GUI::TabPrinter::create_bed_shape_widget(), Slic3r::GUI::PreferencesDialog::create_item_downloads(), Slic3r::GUI::PreferencesDialog::create_items(), Slic3r::GUI::Tab::create_preset_tab(), Slic3r::GUI::ColourPicker::draw_bmp_btn(), Slic3r::GUI::GLGizmoSVG::draw_filename(), 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::GUI_App::on_init_inner(), Slic3r::GUI::MainFrame::open_menubar_item(), Slic3r::GUI::GUI_App::recreate_GUI(), Slic3r::GUI::anonymous_namespace{SceneBenchmark.cpp}::SceneBenchmarkDialog::set_status(), and Slic3r::GUI::PluginConfigField::update_button_label().

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, 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::LayerRangeEditor::LayerRangeEditor(), 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::ConfigOptionsGroup::get_config_value2(), get_formatted_tooltip_text(), Slic3r::GUI::BedShape::get_full_name_with_params(), get_string_value(), Slic3r::GUI::Field::get_value_by_opt_type(), and Slic3r::GUI::Choice::set_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

dp_ctl_text()

wxColour Slic3r::GUI::dp_ctl_text ( )

static

{ return dp_tok(TokCtlText); }

References dp_tok(), and TokCtlText.

Referenced by Slic3r::GUI::DesignPanel::DesignPanel(), Slic3r::GUI::DesignPanel::apply_dof_status(), Slic3r::GUI::DesignPanel::on_clear_expr(), Slic3r::GUI::DesignPanel::on_set_expr(), Slic3r::GUI::DesignPanel::open_tool(), and Slic3r::GUI::DesignPanel::refresh_constrain_dof().

Here is the call graph for this function:

Here is the caller graph for this function:

dp_dark()

bool Slic3r::GUI::dp_dark ( )

static

{ return wxGetApp().dark_mode(); }

Referenced by Slic3r::GUI::DesignPanel::DesignPanel(), commit_icon(), dp_tok(), and Slic3r::GUI::DesignPanel::on_sys_color_changed().

Here is the caller graph for this function:

dp_item_dim()

wxColour Slic3r::GUI::dp_item_dim ( )

static

{ return dp_tok(TokItemDim); }

References dp_tok(), and TokItemDim.

Referenced by Slic3r::GUI::DesignPanel::refresh_parts(), Slic3r::GUI::DesignPanel::refresh_pinned(), and Slic3r::GUI::DesignPanel::refresh_tree().

Here is the call graph for this function:

Here is the caller graph for this function:

dp_item_text()

wxColour Slic3r::GUI::dp_item_text ( )

static

{ return dp_tok(TokItemText); }

References dp_tok(), and TokItemText.

Referenced by Slic3r::GUI::DesignPanel::refresh_parts(), Slic3r::GUI::DesignPanel::refresh_pinned(), and Slic3r::GUI::DesignPanel::refresh_tree().

Here is the call graph for this function:

Here is the caller graph for this function:

dp_panel_bg()

wxColour Slic3r::GUI::dp_panel_bg ( )

static

{ return dp_tok(TokPanelBg); }

References dp_tok(), and TokPanelBg.

Referenced by Slic3r::GUI::DesignPanel::DesignPanel(), and style_sidebar_icon_btn().

Here is the call graph for this function:

Here is the caller graph for this function:

dp_pick_trace()

void Slic3r::GUI::dp_pick_trace ( const char * fmt, ... )

static

{
    if (!dp_pick_trace_on()) return;
    va_list ap; va_start(ap, fmt);
    std::fputs("[pick] ", stderr);
    std::vfprintf(stderr, fmt, ap);
    std::fputc('\n', stderr);
    va_end(ap);
    std::fflush(stderr);
}

References dp_pick_trace(), and dp_pick_trace_on().

Referenced by dp_pick_trace(), Slic3r::GUI::DesignSketchTool::handle_solid_click(), Slic3r::GUI::DesignSketchTool::hit_display_sketch(), Slic3r::GUI::DesignSketchTool::on_mouse_impl(), Slic3r::GUI::DesignSketchTool::pick_bodies_in_rectangle(), and Slic3r::GUI::DesignSketchTool::resolve_solid_pick().

Here is the call graph for this function:

Here is the caller graph for this function:

dp_pick_trace_on()

bool Slic3r::GUI::dp_pick_trace_on ( )

static

{
    static const bool on = ::getenv("ORCA_CAD_PICK_TRACE") != nullptr;
    return on;
}

References dp_pick_trace_on().

Referenced by dp_pick_trace(), dp_pick_trace_on(), and Slic3r::GUI::DesignSketchTool::hit_display_sketch().

Here is the call graph for this function:

Here is the caller graph for this function:

dp_retheme()

wxColour Slic3r::GUI::dp_retheme ( const wxColour & c, bool to_dark )

static

{
    for (const DpToken& t : kDpTokens)
        if (c == (to_dark ? t.light : t.dark))
            return to_dark ? t.dark : t.light;
    return c;
}

References kDpTokens.

Referenced by Slic3r::GUI::DesignPanel::on_sys_color_changed().

Here is the caller graph for this function:

dp_ribbon_bg()

wxColour Slic3r::GUI::dp_ribbon_bg ( )

static

{ return dp_tok(TokRibbonBg); }

References dp_tok(), and TokRibbonBg.

Referenced by Slic3r::GUI::DesignPanel::DesignPanel(), and Slic3r::GUI::DesignPanel::set_active_tool_btn().

Here is the call graph for this function:

Here is the caller graph for this function:

dp_ribbon_hover()

wxColour Slic3r::GUI::dp_ribbon_hover ( )

static

{ return dp_tok(TokRibbonHover); }

References dp_tok(), and TokRibbonHover.

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

Here is the call graph for this function:

Here is the caller graph for this function:

dp_sec_text()

wxColour Slic3r::GUI::dp_sec_text ( )

static

{ return dp_tok(TokSecText); }

References dp_tok(), and TokSecText.

Referenced by Slic3r::GUI::DesignPanel::DesignPanel(), Slic3r::GUI::DesignPanel::on_clear_expr(), Slic3r::GUI::DesignPanel::on_set_expr(), Slic3r::GUI::DesignPanel::open_tool(), and Slic3r::GUI::DesignPanel::rebuild_constraint_list().

Here is the call graph for this function:

Here is the caller graph for this function:

dp_tok()

wxColour Slic3r::GUI::dp_tok ( DpTok t )

static

{ return dp_dark() ? kDpTokens[t].dark : kDpTokens[t].light; }

References dp_dark(), and kDpTokens.

Referenced by dp_ctl_text(), dp_item_dim(), dp_item_text(), dp_panel_bg(), dp_ribbon_bg(), dp_ribbon_hover(), and dp_sec_text().

Here is the call graph for this function:

Here is the caller graph for this function:

dr_yaxis()

Vec3d Slic3r::GUI::dr_yaxis ( const Vec3d & axis, const Vec3d & ref )

static

{
    Vec3d y = axis.cross(ref);
    if (y.norm() < 1e-9) return ref;
    y.normalize();
    return y;
}

References dr_yaxis().

Referenced by dr_yaxis(), Slic3r::GUI::DesignSketchTool::drag_draft_arc(), Slic3r::GUI::DesignSketchTool::hit_test_draft_handle(), and Slic3r::GUI::DesignSketchTool::render_draft_gizmo().

Here is the call graph for this function:

Here is the caller graph for this function:

dragging_rotate_gizmo()

void Slic3r::GUI::dragging_rotate_gizmo	(	double	gizmo_angle,
		std::optional< float > &	current_angle,
		std::optional< float > &	start_angle,
		Selection &	selection )

On dragging rotate gizmo func Transform GLVolume from selection.

Parameters

gizmo_angle	GLGizmoRotate::get_angle()
current_angle	In/Out current angle visible in UI
start_angle	Cache for start dragging angle
selection	Selected only Actual embossed volume

{
    if (!start_angle.has_value())
        // create cache for initial angle
        start_angle = current_angle.value_or(0.f);
 
    gizmo_angle -= PI / 2; // Grabber is upward
 
    double new_angle = gizmo_angle + *start_angle;
 
    const GLVolume *gl_volume = selection.get_first_volume();
    assert(gl_volume != nullptr);
    if (gl_volume == nullptr)
        return;
 
    bool is_volume_mirrored   = has_reflection(gl_volume->get_volume_transformation().get_matrix());
    bool is_instance_mirrored = has_reflection(gl_volume->get_instance_transformation().get_matrix());
    if (is_volume_mirrored != is_instance_mirrored)
        new_angle = -gizmo_angle + *start_angle;
 
    // move to range <-M_PI, M_PI>
    Geometry::to_range_pi_pi(new_angle);
 
    const Transform3d* fix = get_fix_transformation(selection);
    double z_rotation = (fix!=nullptr) ? (new_angle - current_angle.value_or(0.f)) : // relative angle
                                         gizmo_angle; // relativity is keep by selection cache
 
    auto selection_rotate_fnc = [z_rotation, &selection]() {
        selection.rotate(Vec3d(0., 0., z_rotation), get_drag_transformation_type(selection));
    };
    selection_transform(selection, selection_rotate_fnc);
 
    // propagate angle into property
    current_angle = static_cast<float>(new_angle);
 
    // do not store zero
    if (is_approx(*current_angle, 0.f))
        current_angle.reset();
}

References get_drag_transformation_type(), Slic3r::GUI::Selection::get_first_volume(), Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::GLVolume::get_volume_transformation(), Slic3r::has_reflection(), Slic3r::is_approx(), PI, Slic3r::GUI::Selection::rotate(), selection_transform(), and Slic3r::Geometry::to_range_pi_pi().

Referenced by Slic3r::GUI::GLGizmoEmboss::on_mouse_for_rotation(), and Slic3r::GUI::GLGizmoSVG::on_mouse_for_rotation().

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;
 
    // Orca: Align icon center vertically
    ImGuiWindow  *window      = ImGui::GetCurrentWindow();
    ImGuiContext &g           = *GImGui;
    float         cursor_y    = window->DC.CursorPos.y;
    float         line_height = ImGui::GetTextLineHeight() + g.Style.FramePadding.y * 2;
    int           offset_y    = (line_height - s.y) / 2; // Make sure its int otherwise it will be pixelated
    window->DC.CursorPos.y += offset_y;
 
    ImGui::Image(id, s, icon.tl, icon.br, tint_col, border_col);
 
    // Reset offset
    window->DC.CursorPosPrevLine.y = cursor_y;
}

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

Referenced by button(), clickable(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoEmboss::draw_bold_button(), Slic3r::GUI::GLGizmoSVG::draw_filename(), anonymous_namespace{GLGizmoSVG.cpp}::draw_filled(), Slic3r::GUI::GLGizmoEmboss::draw_italic_button(), anonymous_namespace{GLGizmoSVG.cpp}::draw_side_outline(), Slic3r::GUI::GLGizmoEmboss::draw_text_input(), priv::draw_transparent_icon(), Slic3r::GUI::UVEditorCanvas::render(), Slic3r::GUI::DesignSketchTool::render_face_outline(), Slic3r::GUI::GCodeViewer::render_markers(), Slic3r::GUI::GLGizmoTextureDisplacement::render_preview_mesh(), and Slic3r::GUI::GLGizmoEmboss::revertible().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_mixed_gradient_plot()

void Slic3r::GUI::draw_mixed_gradient_plot	(	wxDC &	raw_dc,
		const wxSize &	canvas,
		const std::vector< MixedGradientCurve > &	curves,
		const std::vector< wxPoint2DDouble > &	anchors,
		const MixedGradientTheme &	theme )

{
    // Draw into an internal opaque buffer so wxGCDC text/curves anti-alias against a solid
    // background (never a transparent one), then blit the finished image onto the caller's
    // buffered paint DC. wxGCDC cannot wrap a generic wxDC&, so the buffer is always a
    // wxMemoryDC -- the one type wxGCDC accepts on every platform.
    if (canvas.x <= 0 || canvas.y <= 0)
        return;
    const wxRect rc = mixed_gradient_plot_rect(canvas);
    if (rc.width <= 0 || rc.height <= 0)
        return;
 
    wxBitmap buf(canvas);
    wxMemoryDC memdc(buf);
    memdc.SetBackground(wxBrush(theme.background));
    memdc.Clear();
    wxGCDC dc(memdc);
    wxGraphicsContext* gc = dc.GetGraphicsContext();
 
    // 10x10 light grid (10 lines including outer borders, 9 equal divisions).
    dc.SetPen(wxPen(theme.grid, 1));
    for (int i = 0; i <= kGridDivisions; ++i) {
        const int x = rc.x + rc.width  * i / kGridDivisions;
        const int y = rc.y + rc.height * i / kGridDivisions;
        dc.DrawLine(x, rc.y, x, rc.y + rc.height);
        dc.DrawLine(rc.x, y, rc.x + rc.width, y);
    }
 
    // Set the label font first so text width measurements drive arrow / label placement.
    wxFont label_font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
    label_font.SetPointSize(std::max(7, label_font.GetPointSize() - 1));
    dc.SetFont(label_font);
 
    const wxString axis_y_title = _L("Material Ratio");
    const wxString axis_x_title = _L("Model Height");
    const wxString pct_text     = wxT("100%");
    const wxSize   x_title_sz   = dc.GetTextExtent(axis_x_title);
    const wxSize   y_title_sz   = dc.GetTextExtent(axis_y_title);
 
    wxFont strong_font = label_font;
    strong_font.SetWeight(wxFONTWEIGHT_SEMIBOLD);
    dc.SetFont(strong_font);
    const wxSize pct_text_sz = dc.GetTextExtent(pct_text);
    dc.SetFont(label_font);
 
    // Axes (grey 700) with filled triangle arrows. Y-axis extends above the plot top to the
    // canvas top edge; X-axis extends past the plot right toward the canvas right edge.
    const int arrow_half = dip_px(kAxisArrowHalf);
    const int arrow_len  = dip_px(kAxisArrowLen);
    dc.SetPen(wxPen(theme.axis, kStrokeAxis));
    dc.SetBrush(wxBrush(theme.axis));
 
    const int y_axis_x           = rc.x;
    const int y_title_pct_gap    = dip_px(1);
    const int y_title_bottom_pad = dip_px(2);
    const int y_title_y = std::max(0, rc.y - y_title_sz.y - y_title_pct_gap - pct_text_sz.y - y_title_bottom_pad);
    const int y_arrow_tip_y = y_title_y;
    const int y_arrow_ty    = y_arrow_tip_y + arrow_len;
    dc.DrawLine(y_axis_x, y_arrow_ty, y_axis_x, rc.y + rc.height);
    {
        wxPoint tri[3] = {
            wxPoint(y_axis_x,              y_arrow_tip_y),
            wxPoint(y_axis_x - arrow_half, y_arrow_ty),
            wxPoint(y_axis_x + arrow_half, y_arrow_ty),
        };
        dc.DrawPolygon(3, tri);
    }
 
    const int x_axis_y      = rc.y + rc.height;
    const int x_label_gap   = dip_px(4);
    const int x_edge_pad    = dip_px(6);
    const int x_arrow_ideal = rc.x + rc.width + dip_px(10);
    const int x_arrow_max   = canvas.x - x_title_sz.x - x_label_gap - x_edge_pad - arrow_len;
    const int x_arrow_tx    = std::max(rc.x + rc.width + arrow_len, std::min(x_arrow_ideal, x_arrow_max));
    const int x_arrow_tip_x = x_arrow_tx + arrow_len;
    const int x_title_x     = x_arrow_tip_x + x_label_gap;
    dc.DrawLine(rc.x, x_axis_y, x_arrow_tx, x_axis_y);
    {
        wxPoint tri[3] = {
            wxPoint(x_arrow_tip_x,          x_axis_y),
            wxPoint(x_arrow_tx,             x_axis_y - arrow_half),
            wxPoint(x_arrow_tx,             x_axis_y + arrow_half),
        };
        dc.DrawPolygon(3, tri);
    }
 
    // Labels: "Material Ratio" and the leading "100%" share the same left x; the trailing
    // "Model Height" follows the X-axis arrow tip (already clamped to make room).
    const int label_left_x = y_axis_x + dip_px(10);
    dc.SetTextForeground(theme.label);
    dc.DrawText(axis_y_title, label_left_x, y_title_y);
 
    dc.SetFont(strong_font);
    dc.SetTextForeground(theme.label_strong);
    dc.DrawText(pct_text, label_left_x, y_title_y + y_title_sz.y + y_title_pct_gap);
 
    dc.DrawText(pct_text, rc.x + rc.width - pct_text_sz.x, x_axis_y);
    dc.SetFont(label_font);
    dc.SetTextForeground(theme.label);
    dc.DrawText(axis_x_title, x_title_x, x_axis_y - x_title_sz.y / 2);
 
    if (!gc)
        return;
 
    // Outline only when the curve colour is perceptually close to the background; otherwise the
    // plain filament colour reads fine and the extra stroke would look heavy.
    auto needs_outline = [&](const wxColour& c) {
        return calc_color_distance(c, theme.background) < kBgSimilarThreshold;
    };
 
    // Only the geometry goes through the graphics context: dc.DrawLines() takes integer wxPoint
    // and would quantize the curve back to whole pixels. The pen is still set on the dc, which
    // forwards it here while keeping its own cached state in sync for later dc drawing.
    auto draw_polyline = [&](const MixedGradientCurve& curve) {
        if (curve.points.size() < 2)
            return;
        dc.SetPen(wxPen(curve.colour, dip_px(curve.stroke_dip)));
        gc->StrokeLines(curve.points.size(), curve.points.data());
    };
 
    for (const MixedGradientCurve& curve : curves) {
        if (needs_outline(curve.colour))
            draw_polyline({curve.points, theme.outline, curve.stroke_dip + kOutlineExtraDip});
        draw_polyline(curve);
    }
 
    // Control points: hollow circle with axis-colour border, theme-aware fill, drawn with a
    // sub-pixel centre so the ring stays centred on the curve.
    if (!anchors.empty()) {
        const double r = dip_px(kPointRadius);
        dc.SetPen(wxPen(theme.axis, 1));
        dc.SetBrush(wxBrush(theme.point_fill));
        for (const wxPoint2DDouble& p : anchors)
            gc->DrawEllipse(p.m_x - r, p.m_y - r, r * 2, r * 2);
    }
 
    memdc.SelectObject(wxNullBitmap);
    raw_dc.DrawBitmap(buf, 0, 0);
}

References _L, Slic3r::GUI::MixedGradientTheme::axis, Slic3r::GUI::MixedGradientTheme::background, calc_color_distance(), Slic3r::GUI::MixedGradientTheme::grid, Slic3r::GUI::MixedGradientTheme::label, Slic3r::GUI::MixedGradientTheme::label_strong, mixed_gradient_plot_rect(), Slic3r::GUI::MixedGradientTheme::outline, and Slic3r::GUI::MixedGradientTheme::point_fill.

Referenced by Slic3r::GUI::PublishSettingsDialog::add_mixed_visual(), and Slic3r::GUI::GradientCurveEditor::on_paint().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_mixed_ratio_blend_bar()

void Slic3r::GUI::draw_mixed_ratio_blend_bar	(	wxDC &	dc,
		const wxRect &	rect,
		const wxColour &	first,
		const wxColour &	second,
		double	second_fraction )

{
    if (rect.width <= 0 || rect.height <= 0)
        return;
    for (int x = 0; x < rect.width; ++x) {
        const double t = rect.width > 1 ? double(x) / rect.width : 0.0;
        const wxColour c = lerp_blend(first, second, 1.0 - t);
        dc.SetPen(wxPen(c));
        dc.DrawLine(rect.x + x, rect.y, rect.x + x, rect.y + rect.height);
    }
 
    // Fixed in both themes, like the triangle picker's drag handle: the divider is drawn over
    // blended filament colour, so it has to keep its contrast against data rather than chrome.
    const int div_x = rect.x + static_cast<int>(second_fraction * rect.width);
    dc.SetPen(wxPen(wxColour(80, 80, 80), dip_px(4)));
    dc.DrawLine(div_x, rect.y, div_x, rect.y + rect.height);
    dc.SetPen(wxPen(*wxWHITE, dip_px(2)));
    dc.DrawLine(div_x, rect.y, div_x, rect.y + rect.height);
}

Referenced by Slic3r::GUI::PublishSettingsDialog::add_mixed_visual(), and Slic3r::GUI::MixedFilamentDialog::create_ratio_slider().

Here is the caller graph for this function:

draw_mixed_ratio_segments()

void Slic3r::GUI::draw_mixed_ratio_segments	(	wxDC &	dc,
		const wxRect &	rect,
		const std::vector< wxColour > &	colours,
		const std::vector< double > &	shares )

{
    const size_t n = std::min(colours.size(), shares.size());
    if (n == 0 || rect.width <= 0 || rect.height <= 0)
        return;
    std::vector<double> norm = shares;
    double total = 0.0;
    for (double s : norm)
        total += s;
    if (total <= 0.0) {
        norm.assign(n, 1.0 / n);
        total = 1.0;
    }
    auto share_to_px = [&](double share_sum) { return rect.x + int(std::lround(share_sum / total * double(rect.width))); };
    int x0 = rect.x;
    std::vector<wxRect> segs(n);
    for (size_t i = 0; i < n; ++i) {
        int x1 = rect.x + rect.width;
        if (i + 1 < n)
            x1 = share_to_px(std::accumulate(norm.begin(), norm.begin() + i + 1, 0.0));
        segs[i] = wxRect(x0, rect.y, std::max(1, x1 - x0), rect.height);
        x0      = segs[i].GetRight() + 1;
    }
    for (size_t i = 0; i < n; ++i) {
        dc.SetPen(*wxTRANSPARENT_PEN);
        dc.SetBrush(wxBrush(colours[i]));
        dc.DrawRectangle(segs[i]);
    }
    dc.SetBrush(*wxTRANSPARENT_BRUSH);
    dc.SetPen(wxPen(StateColor::darkModeColorFor(wxColour("#ACACAC")), 1));
    dc.DrawRectangle(rect);
}

References StateColor::darkModeColorFor().

Referenced by Slic3r::GUI::PublishSettingsDialog::add_mixed_visual().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_mixed_triangle_labels()

void Slic3r::GUI::draw_mixed_triangle_labels	(	wxDC &	dc,
		const wxSize &	size,
		const std::array< double, 3 > &	weights,
		const MixedTriangleTheme &	theme )

{
    const std::array<TriPoint, 3> v = mixed_triangle_vertices(size, kTriangleMarginDip);
    dc.SetFont(::Label::Body_12);
    dc.SetTextForeground(theme.label);
 
    // "Ratio" title, sitting above the top vertex.
    const wxString title = _L("Ratio");
    dc.DrawText(title, dip_px(2), std::max(0, int(v[0].y - dc.GetTextExtent(title).GetHeight() - dip_px(4))));
 
    for (int i = 0; i < 3; ++i) {
        const wxString text = wxString::Format("%d%%", int(std::lround(weights[i] * 100.0)));
        const wxSize tsz    = dc.GetTextExtent(text);
        int lx = int(v[i].x - tsz.GetWidth() / 2.0);
        int ly = (i == 0) ? int(v[i].y - tsz.GetHeight() - dip_px(4)) : int(v[i].y + dip_px(3));
        ly = std::clamp(ly, 0, size.GetHeight() - tsz.GetHeight());
        lx = std::clamp(lx, 0, size.GetWidth() - tsz.GetWidth());
        dc.DrawText(text, lx, ly);
    }
}

References _L, Label::Body_12, Slic3r::GUI::MixedTriangleTheme::label, and mixed_triangle_vertices().

Referenced by Slic3r::GUI::PublishSettingsDialog::add_mixed_visual().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_mixed_triangle_picker()

void Slic3r::GUI::draw_mixed_triangle_picker	(	wxDC &	dc,
		const wxSize &	size,
		const std::array< wxColour, 3 > &	colours,
		const std::array< double, 3 > &	weights,
		const MixedTriangleTheme &	theme )

{
    if (size.GetWidth() <= 0 || size.GetHeight() <= 0)
        return;
    const std::array<TriPoint, 3> v = mixed_triangle_vertices(size, kTriangleMarginDip);
 
    dc.SetBrush(wxBrush(theme.background));
    dc.SetPen(*wxTRANSPARENT_PEN);
    dc.DrawRectangle(0, 0, size.GetWidth(), size.GetHeight());
 
    const wxColour& c0 = colours[0];
    const wxColour& c1 = colours[1];
    const wxColour& c2 = colours[2];
    const TriCacheKey key{size.GetWidth(), size.GetHeight(),
                          c0.Red(), c0.Green(), c0.Blue(),
                          c1.Red(), c1.Green(), c1.Blue(),
                          c2.Red(), c2.Green(), c2.Blue(),
                          theme.background.Red(), theme.background.Green(), theme.background.Blue(),
                          theme.outline.Red(), theme.outline.Green(), theme.outline.Blue()};
 
    wxBitmap& bmp = tri_cache()[key];
    if (!bmp.IsOk()) {
        bmp = wxBitmap(size.GetWidth(), size.GetHeight(), 24);
        wxMemoryDC mdc(bmp);
        mdc.SetBrush(wxBrush(theme.background));
        mdc.SetPen(*wxTRANSPARENT_PEN);
        mdc.DrawRectangle(0, 0, size.GetWidth(), size.GetHeight());
 
        const int min_y = int(std::min({v[0].y, v[1].y, v[2].y}));
        const int max_y = int(std::max({v[0].y, v[1].y, v[2].y}));
        const int min_x = int(std::min({v[0].x, v[1].x, v[2].x}));
        const int max_x = int(std::max({v[0].x, v[1].x, v[2].x}));
        for (int py = min_y; py <= max_y; ++py) {
            for (int px = min_x; px <= max_x; ++px) {
                const TriPoint p = {double(px), double(py)};
                if (!tri_contains(p, v[0], v[1], v[2]))
                    continue;
                double w0, w1, w2;
                tri_barycentric(p, v[0], v[1], v[2], w0, w1, w2);
                unsigned char mr, mg, mb;
                if (w0 + w1 > 1e-6) {
                    float t01 = float(w1 / (w0 + w1));
                    Slic3r::filament_mixer_lerp(c0.Red(), c0.Green(), c0.Blue(), c1.Red(), c1.Green(), c1.Blue(), t01, &mr, &mg, &mb);
                    Slic3r::filament_mixer_lerp(mr, mg, mb, c2.Red(), c2.Green(), c2.Blue(), float(w2), &mr, &mg, &mb);
                } else {
                    mr = c2.Red(); mg = c2.Green(); mb = c2.Blue();
                }
                mdc.SetPen(wxPen(wxColour(mr, mg, mb)));
                mdc.DrawPoint(px, py);
            }
        }
 
        mdc.SetPen(wxPen(theme.outline, 1));
        mdc.SetBrush(*wxTRANSPARENT_BRUSH);
        const wxPoint pts[3] = {{int(v[0].x), int(v[0].y)}, {int(v[1].x), int(v[1].y)}, {int(v[2].x), int(v[2].y)}};
        mdc.DrawPolygon(3, pts);
        mdc.SelectObject(wxNullBitmap);
 
        // Keep the cache from growing without bound across DPI/size changes.
        if (tri_cache().size() > 6) {
            auto& cache = tri_cache();
            cache.erase(cache.begin());
        }
    }
    dc.DrawBitmap(bmp, 0, 0);
 
    // Published-ratio marker (read-only twin of the editor's drag handle).
    const double w0 = weights[0], w1 = weights[1], w2 = weights[2];
    const int hx = int(w0 * v[0].x + w1 * v[1].x + w2 * v[2].x);
    const int hy = int(w0 * v[0].y + w1 * v[1].y + w2 * v[2].y);
    dc.SetBrush(*wxWHITE_BRUSH);
    dc.SetPen(wxPen(theme.ring, dip_px(2)));
    dc.DrawCircle(hx, hy, dip_px(5));
}

References Slic3r::GUI::MixedTriangleTheme::background, Slic3r::filament_mixer_lerp(), mixed_triangle_vertices(), Slic3r::GUI::MixedTriangleTheme::outline, Slic3r::GUI::MixedTriangleTheme::ring, tri_barycentric(), and tri_contains().

Referenced by Slic3r::GUI::PublishSettingsDialog::add_mixed_visual(), and Slic3r::GUI::MixedFilamentDialog::create_triangle_picker().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_title()

void Slic3r::GUI::draw_title ( wxDC & dc, wxPoint pos, const wxString & text, const wxColour * color, int width )

static

{
    wxString multiline_text;
    if (width > 0 && dc.GetTextExtent(text).x > width) {
        multiline_text = text;
 
        size_t idx = size_t(-1);
        size_t start = 0;
        for (size_t i = 0; i < multiline_text.Len(); i++)
        {
            if (multiline_text[i] == ' ')
            {
                if (dc.GetTextExtent(multiline_text.SubString(start, i)).x < width)
                    idx = i;
                else {
                    if (idx == size_t(-1))
                        idx = i;
                    multiline_text[idx] = '\n';
                    start = idx + 1;
                    idx = size_t(-1);
                }
            }
        }
        if (idx != size_t(-1))
            multiline_text[idx] = '\n';
    }
 
    if (!text.IsEmpty()) {
        const wxString& out_text = multiline_text.IsEmpty() ? text : multiline_text;
        wxCoord text_width, text_height;
        dc.GetMultiLineTextExtent(out_text, &text_width, &text_height);
 
        wxColour old_clr = dc.GetTextForeground();
        wxFont old_font = dc.GetFont();
        dc.SetTextForeground(color ? *color :
#ifdef _WIN32
            wxGetApp().get_label_clr_default());
#else
            wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT));
#endif /* _WIN32 */
        dc.DrawText(out_text, pos);
        dc.SetTextForeground(old_clr);
        dc.SetFont(old_font);
 
        if (width < 1)
            width = text_width;
    }
}

Referenced by Slic3r::GUI::OG_CustomCtrl::OnPaint().

Here is the caller graph for this function:

drawn_last_frame()

bool Slic3r::GUI::drawn_last_frame ( const ImGuiWindow * popup )

static

{
    return popup != nullptr && (ImGui::GetCurrentContext()->WithinFrameScope ? popup->WasActive : popup->Active);
}

Referenced by Slic3r::GUI::ImGuiWrapper::close_top_popup(), and Slic3r::GUI::ImGuiWrapper::modal_popup_open().

Here is the caller graph for this function:

DrawRoundedRect()

void Slic3r::GUI::DrawRoundedRect	(	float	x,
		float	y,
		float	width,
		float	height,
		float	radius,
		const ColorRGB &	color,
		int	segments = 16 )

{
    glColor3f(color.r(), color.g(), color.b());
 
    // 1. Draw center rectangle
    glBegin(GL_QUADS);
    glVertex2f(x + radius, y + radius);
    glVertex2f(x + width - radius, y + radius);
    glVertex2f(x + width - radius, y + height - radius);
    glVertex2f(x + radius, y + height - radius);
    glEnd();
 
    // 2. Draw side rectangles (excluding corners)
    glBegin(GL_QUADS);
    // Left
    glVertex2f(x, y + radius);
    glVertex2f(x + radius, y + radius);
    glVertex2f(x + radius, y + height - radius);
    glVertex2f(x, y + height - radius);
 
    // Right
    glVertex2f(x + width - radius, y + radius);
    glVertex2f(x + width, y + radius);
    glVertex2f(x + width, y + height - radius);
    glVertex2f(x + width - radius, y + height - radius);
 
    // Top
    glVertex2f(x + radius, y + height - radius);
    glVertex2f(x + width - radius, y + height - radius);
    glVertex2f(x + width - radius, y + height);
    glVertex2f(x + radius, y + height);
 
    // Bottom
    glVertex2f(x + radius, y);
    glVertex2f(x + width - radius, y);
    glVertex2f(x + width - radius, y + radius);
    glVertex2f(x + radius, y + radius);
    glEnd();
 
    // 3. Draw corners
    auto drawCorner = [&](float cx, float cy, float startAngle) {
        glBegin(GL_TRIANGLE_FAN);
        glVertex2f(cx, cy);
        for (int i = 0; i <= segments; ++i) {
            float angle = startAngle + (M_PI * 0.5f) * (float)i / segments;
            glVertex2f(cx + cosf(angle) * radius, cy + sinf(angle) * radius);
        }
        glEnd();
    };
 
    drawCorner(x + radius, y + radius, M_PI);             // bottom-left
    drawCorner(x + width - radius, y + radius, 1.5f * M_PI); // bottom-right
    drawCorner(x + width - radius, y + height - radius, 0.0f); // top-right
    drawCorner(x + radius, y + height - radius, 0.5f * M_PI); // top-left
}

References Slic3r::angle(), Slic3r::ColorRGB::b(), Slic3r::ColorRGB::g(), GL_QUADS, GL_TRIANGLE_FAN, glBegin, glColor3f, glEnd, glVertex2f, M_PI, and Slic3r::ColorRGB::r().

Referenced by Slic3r::GUI::SkipPartCanvas::Render().

Here is the call graph for this function:

Here is the caller graph for this function:

drop_unchanged_added_entries()

void Slic3r::GUI::drop_unchanged_added_entries ( std::vector< std::string > & options, const DynamicPrintConfig & current, const Preset * reference )

static

{
    if (reference == nullptr)
        return;
    // deep_diff() lists a key's entries one after another, so serialize each key's vectors once.
    std::string              serialized_key;
    std::vector<std::string> cur_values;
    std::string              ref_first;
    options.erase(std::remove_if(options.begin(), options.end(), [&](const std::string &opt) {
        const auto pos = opt.find('#');
        if (pos == std::string::npos)
            return false;
        const std::string key = opt.substr(0, pos);
        const size_t      idx = size_t(std::atoi(opt.c_str() + pos + 1));
        auto ref = dynamic_cast<const ConfigOptionVectorBase *>(reference->config.option(key));
        auto cur = dynamic_cast<const ConfigOptionVectorBase *>(current.option(key));
        if (ref == nullptr || cur == nullptr || idx < ref->size() || ref->size() == 0 || idx >= cur->size())
            return false;
        if (key != serialized_key) {
            serialized_key = key;
            cur_values     = cur->vserialize();
            ref_first      = ref->vserialize().front();
        }
        return cur_values[idx] == ref_first;
    }), options.end());
}

Referenced by Slic3r::GUI::TabPrinter::update_custom_dirty().

Here is the caller graph for this function:

ellipse_axes()

void Slic3r::GUI::ellipse_axes ( const Vec2d & center, const Vec2d & major_end, const Vec2d & minor_pt, double & a, double & b, double & phi )

static

{
    const Vec2d maj = major_end - center;
    a   = std::max(maj.norm(), 1e-6);
    phi = std::atan2(maj.y(), maj.x());
    const Vec2d n(-std::sin(phi), std::cos(phi));        // minor-axis direction
    b   = std::min(std::abs((minor_pt - center).dot(n)), a);
}

References Slic3r::center(), Slic3r::dot(), and ellipse_axes().

Referenced by ellipse_axes(), Slic3r::GUI::DesignSketchTool::make_ellipse(), and Slic3r::GUI::DesignSketchTool::make_ellipse_arc().

Here is the call graph for this function:

Here is the caller graph for this function:

ellipse_param_of()

double Slic3r::GUI::ellipse_param_of ( const Vec2d & center, double a, double b, double phi, const Vec2d & q )

static

{
    const Vec2d d = q - center;
    const double cu = std::cos(phi), su = std::sin(phi);
    const double u =  d.x() * cu + d.y() * su;            // along major
    const double v = -d.x() * su + d.y() * cu;            // along minor
    return std::atan2(v / std::max(b, 1e-9), u / std::max(a, 1e-9));
}

References Slic3r::center(), and ellipse_param_of().

Referenced by Slic3r::GUI::DesignSketchTool::drag_ellipsearc_handle(), ellipse_param_of(), and Slic3r::GUI::DesignSketchTool::make_ellipse_arc().

Here is the call graph for this function:

Here is the caller graph for this function:

ellipse_point()

Vec2d Slic3r::GUI::ellipse_point ( const Vec2d & c, double a, double b, double phi, double t )

static

{
    const double cu = std::cos(phi), su = std::sin(phi);
    const double x = a * std::cos(t), y = b * std::sin(t);
    return Vec2d(c.x() + x * cu - y * su, c.y() + x * su + y * cu);
}

References ellipse_point().

Referenced by Slic3r::GUI::DesignSketchTool::drag_ellipsearc_handle(), ellipse_point(), ellipse_polyline(), Slic3r::GUI::DesignSketchTool::make_ellipse_arc(), Slic3r::GUI::DesignSketchTool::render_live_quotes(), Slic3r::GUI::DesignSketchTool::set_ellipse_axis(), Slic3r::GUI::DesignSketchTool::set_ellipsearc_sweep(), and Slic3r::GUI::DesignSketchTool::set_handle().

Here is the call graph for this function:

Here is the caller graph for this function:

ellipse_polyline()

std::vector< Vec2d > Slic3r::GUI::ellipse_polyline ( const Vec2d & c, double a, double b, double phi, double t0, double t1, int n = 48 )

static

{
    std::vector<Vec2d> v; v.reserve(n + 1);
    for (int i = 0; i <= n; ++i)
        v.push_back(ellipse_point(c, a, b, phi, t0 + (t1 - t0) * double(i) / double(n)));
    return v;
}

References ellipse_point(), and ellipse_polyline().

Referenced by ellipse_polyline(), and Slic3r::GUI::DesignSketchTool::entity_polyline().

Here is the call graph for this function:

Here is the caller graph for this function:

empty_tray_config()

DynamicPrintConfig Slic3r::GUI::empty_tray_config ( )

static

{
    DynamicPrintConfig config;
    config.set_key_value("filament_id", new ConfigOptionStrings{""});
    config.set_key_value("tag_uid", new ConfigOptionStrings{""});
    config.set_key_value("filament_type", new ConfigOptionStrings{""});
    config.set_key_value("tray_name", new ConfigOptionStrings{""});
    config.set_key_value("filament_colour", new ConfigOptionStrings{""});
    config.set_key_value("filament_exist", new ConfigOptionBools{false});
    return config;
}

References Slic3r::DynamicConfig::set_key_value().

Referenced by Slic3r::GUI::CalibrationPresetPage::sync_ams_info(), and Slic3r::GUI::CalibrationPresetPage::update_multi_extruder_filament_combobox().

Here is the call graph for this function:

Here is the caller graph for this function:

en_format()

wxString Slic3r::GUI::en_format ( double v, int digits = 2 )

static

{
    char fmt[16];
    std::snprintf(fmt, sizeof(fmt), "%%.%df", digits);
    char buf[64];
    std::snprintf(buf, sizeof(buf), fmt, v);
    for (char* c = buf; *c; ++c) if (*c == ',') *c = '.';
    return wxString::FromUTF8(buf);
}

Referenced by Slic3r::GUI::DesignPanel::constraint_label(), and Slic3r::GUI::DesignPanel::request_value().

Here is the caller graph for this function:

en_parse()

bool Slic3r::GUI::en_parse ( const wxString & text, double & out )

static

{
    wxString t(text);
    t.Replace(wxT(","), wxT("."));
    return t.ToCDouble(&out);
}

Referenced by Slic3r::GUI::DesignPanel::confirm_value().

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
}

end_menu()

void Slic3r::GUI::end_menu

(

)

{
    ImGui::EndMenu();
}

Referenced by Slic3r::GUI::IMSlider::render_add_menu(), and Slic3r::GUI::IMSlider::render_edit_menu().

Here is the caller graph for this function:

ensure_belt_purge_tower()

bool Slic3r::GUI::ensure_belt_purge_tower	(	Model &	model,
		PartPlateList &	partplate_list,
		ObjectList *	obj_list,
		std::vector< BeltPurgeSignature > &	sigs )

{
    auto is_prism = [](const ModelObject *mo) {
        const ConfigOption *opt = mo->config.option("belt_purge_tower_object");
        return opt != nullptr && opt->getBool();
    };
 
    // Every plate gets its own prism. A prism belongs to the plate it lies on; one
    // that lies on no plate is stale.
    const int plate_count = partplate_list.get_plate_count();
    sigs.resize(size_t(plate_count));
    std::vector<std::vector<int>> prisms_by_plate(static_cast<size_t>(plate_count));
    std::vector<int>              stale_prisms;
    for (int i = 0; i < (int) model.objects.size(); ++i)
        if (is_prism(model.objects[i])) {
            const int plate_idx = model.objects[i]->instances.empty() ? -1 : partplate_list.find_instance(i, 0);
            if (plate_idx >= 0 && plate_idx < plate_count)
                prisms_by_plate[size_t(plate_idx)].push_back(i);
            else
                stale_prisms.push_back(i);
        }
 
    // Deletes prism objects, keeping the sidebar and part plates in sync
    // (same primitives as Plater::priv::remove(), minus scene update — the
    // caller refreshes the scene). Highest index first, so the others stay valid.
    auto remove_prisms = [&](std::vector<int> idxs) {
        std::sort(idxs.begin(), idxs.end());
        for (auto it = idxs.rbegin(); it != idxs.rend(); ++it) {
            model.delete_object(size_t(*it));
            partplate_list.notify_instance_removed(*it, -1);
            obj_list->delete_object_from_list(size_t(*it));
        }
    };
    auto all_prisms = [&]() {
        std::vector<int> all = stale_prisms;
        for (const auto &v : prisms_by_plate)
            all.insert(all.end(), v.begin(), v.end());
        return all;
    };
 
    // Cheap early-out for non-belt printers: only belt printers ever get a belt
    // purge tower, and this runs on every background-process tick — so avoid the
    // full_config() merge below unless this is actually a belt printer. (Also
    // tidies up a stale prism if the user switched away from a belt printer.)
    {
        const auto *belt_pre = wxGetApp().preset_bundle->printers.get_edited_preset().config.option<ConfigOptionBool>("belt_printer");
        if (belt_pre == nullptr || !belt_pre->value) {
            std::fill(sigs.begin(), sigs.end(), BeltPurgeSignature{});
            const std::vector<int> all = all_prisms();
            if (all.empty())
                return false;
            remove_prisms(all);
            return true;
        }
    }
 
    // Read every sizing input from the MERGED full config — the exact same
    // config the backend slices with (BackgroundSlicingProcess::apply uses
    // preset_bundle->full_config()). Reading from the individual presets caused
    // GUI/backend mismatches: e.g. purge_in_prime_tower or a populated
    // flush_volumes_matrix present in the merged config but false/empty in the
    // preset the GUI happened to read, so the tower was sized for the small
    // prime_volume instead of the real color-change flush and could not absorb
    // it. The three names below alias the one merged config so the rest of the
    // function is unchanged.
    const DynamicPrintConfig  full_cfg       = wxGetApp().preset_bundle->full_config();
    const DynamicPrintConfig &printer_config = full_cfg;
    const DynamicPrintConfig &print_config   = full_cfg;
    const DynamicPrintConfig &project_config = full_cfg;
 
    const auto *belt_opt = printer_config.option<ConfigOptionBool>("belt_printer");
    const bool  belt     = belt_opt != nullptr && belt_opt->value;
    // Belt purge tower is its own type, gated by the belt-only printer option
    // enable_belt_purge_tower (not the classic process enable_prime_tower).
    const bool  prime_tower_enabled = printer_config.has("enable_belt_purge_tower") && printer_config.opt_bool("enable_belt_purge_tower");
    const auto *seq_opt   = print_config.option<ConfigOptionEnum<PrintSequence>>("print_sequence");
    const bool  by_object = seq_opt != nullptr && seq_opt->value == PrintSequence::ByObject;
 
    // Mixed filament slots are expanded to their physical components below.
    std::vector<unsigned char> is_mixed;
    std::vector<std::string>   comp_strs;
    if (const auto *o = full_cfg.option<ConfigOptionBools>("filament_is_mixed"))
        is_mixed = o->values;
    if (const auto *o = full_cfg.option<ConfigOptionStrings>("filament_mixed_components"))
        comp_strs = o->values;
 
    const double gap     = 1.0;
    const double layer_h = print_config.has("layer_height") ? print_config.opt_float("layer_height") : 0.2;
 
    // Belt geometry. The rotation axis is the gantry tilt axis; the belt
    // travels along the *other* horizontal axis (X-rotation -> belt along Y,
    // the CR-30 default). The purge prism is a long bar laid along the belt
    // travel direction, beside the parts. For no/Z rotation we fall back to
    // vertical slicing geometry (theta = 90 deg).
    const auto *axis_opt  = printer_config.option<ConfigOptionEnum<BeltRotationAxis>>("belt_slice_rotation");
    const auto *angle_opt = printer_config.option<ConfigOptionFloat>("belt_slice_rotation_angle");
    const BeltRotationAxis rot = axis_opt != nullptr ? axis_opt->value : BeltRotationAxis::X;
    const bool   belt_is_y = (rot != BeltRotationAxis::Y); // X / None / Z -> belt along Y
    double       theta     = M_PI / 2.;
    if ((rot == BeltRotationAxis::X || rot == BeltRotationAxis::Y) && angle_opt != nullptr && std::abs(angle_opt->value) > EPSILON)
        theta = std::clamp(Geometry::deg2rad(std::abs(angle_opt->value)), Geometry::deg2rad(5.), M_PI / 2.);
    const double sin_t = std::sin(theta);
    const double cot_t = std::cos(theta) / sin_t;
 
    // NOTE: both purge_in_prime_tower and single_extruder_multi_material are
    // PRINTER options (Preset.cpp s_Preset_printer_options) — read them from the
    // printer preset. Reading purge_in_prime_tower from the print preset returns
    // has()==false, collapsing use_matrix to false and sizing the tower for the
    // small prime_volume instead of the real color-change flush. This must match
    // the backend Print::_plan_belt_purge() which reads both from the merged config.
    const bool use_matrix = (printer_config.has("purge_in_prime_tower") && printer_config.opt_bool("purge_in_prime_tower"))
        && (printer_config.has("single_extruder_multi_material") && printer_config.opt_bool("single_extruder_multi_material"));
    const double prime_volume     = print_config.has("prime_volume") ? print_config.opt_float("prime_volume") : 45.;
    const double printable_height = printer_config.has("printable_height") ? printer_config.opt_float("printable_height") : 250.;
 
    // The bed (printable_area) is plate-local but model instances live in the
    // plate's world frame, so the plate origin is added to every bed coordinate.
    const double inset = 1.;
    BoundingBoxf bed_ext;
    if (const auto *bed_opt = printer_config.option<ConfigOptionPoints>("printable_area");
        bed_opt != nullptr && !bed_opt->values.empty())
        bed_ext = get_extents(bed_opt->values);
 
    // What each plate needs, decided before anything is deleted or created.
    struct Plan
    {
        bool               wanted = false;
        BeltPurgeSignature sig;
        int                n_islands = 1;
        double             w_sub = 0., length = 0., height = 0.;
        Vec3d              center = Vec3d::Zero();
    };
    std::vector<Plan> plans(static_cast<size_t>(plate_count));
 
    for (int plate_idx = 0; plate_idx < plate_count; ++plate_idx) {
        Plan      &plan  = plans[size_t(plate_idx)];
        PartPlate *plate = partplate_list.get_plate(plate_idx);
 
        // Filaments used and bounding extent of the non-prism objects on this
        // plate (1-based filament ids; volume extruder 0 = object default).
        std::set<int> filaments;
        double        x_min = std::numeric_limits<double>::max();
        double        x_max = -std::numeric_limits<double>::max();
        double        y_min = std::numeric_limits<double>::max();
        double        y_max = -std::numeric_limits<double>::max();
        double        z_max = 0.;
        bool          have_objects = false;
        if (belt && plate != nullptr) {
            for (int obj_idx = 0; obj_idx < (int) model.objects.size(); ++obj_idx) {
                const ModelObject *mo = model.objects[obj_idx];
                if (is_prism(mo))
                    continue;
                int obj_extruder = 1;
                if (const ConfigOption *opt = mo->config.option("extruder"); opt != nullptr && opt->getInt() > 0)
                    obj_extruder = opt->getInt();
                bool any_instance_on_plate = false;
                for (int inst_idx = 0; inst_idx < (int) mo->instances.size(); ++inst_idx) {
                    if (!plate->contain_instance_totally(obj_idx, inst_idx))
                        continue;
                    any_instance_on_plate = true;
                    const BoundingBoxf3 bb = mo->instance_bounding_box(inst_idx);
                    x_min = std::min(x_min, bb.min.x());
                    x_max = std::max(x_max, bb.max.x());
                    y_min = std::min(y_min, bb.min.y());
                    y_max = std::max(y_max, bb.max.y());
                    z_max = std::max(z_max, bb.max.z());
                }
                if (!any_instance_on_plate)
                    continue;
                have_objects = true;
                for (const ModelVolume *mv : mo->volumes)
                    for (int e : mv->get_extruders())
                        filaments.insert(e > 0 ? e : obj_extruder);
            }
        }
 
        // A mixed filament slot is VIRTUAL: it never reaches a nozzle. At slice time
        // ToolOrdering::resolve_mixed_filaments() replaces it with its physical
        // components, so the toolchanges the prism has to absorb are between those
        // components, not to the mixed slot itself. Counting the slot as a filament
        // of its own therefore over-provisions the prism by one island per mixed slot
        // -- the "extra purge tower" -- and, when every component is already used by
        // another object, by an island that can never be reached at all.
        //
        // Expand here with the same helper the backend uses (Print.cpp's sequential
        // path), so the GUI sizes the prism against the same filament set the slicer
        // will actually produce. No-op when no filament is mixed.
        if (has_any_mixed_filament(is_mixed)) {
            std::vector<unsigned int> zero_based;
            zero_based.reserve(filaments.size());
            for (int f : filaments)
                if (f > 0)
                    zero_based.push_back((unsigned int) (f - 1));
            zero_based = expand_mixed_filaments(zero_based, is_mixed, comp_strs);
            filaments.clear();
            for (unsigned int f : zero_based)
                filaments.insert((int) f + 1);
        }
 
        plan.wanted = belt && prime_tower_enabled && !by_object && have_objects && filaments.size() > 1;
        if (!plan.wanted)
            continue;
 
        // --- Sizing -----------------------------------------------------------
        const int    n_islands = std::max(1, (int) filaments.size() - 1);
        // Every disconnected island needs at least 1 mm of printable width. Honor
        // the configured total width whenever possible, but never let the island
        // layout silently grow past the footprint used for placement.
        const double min_width = n_islands + (n_islands - 1) * gap;
        const double width     = std::max(min_width,
            print_config.has("belt_purge_tower_width") ? print_config.opt_float("belt_purge_tower_width") : 35.);
        const double printable_width = width - (n_islands - 1) * gap;
 
        // Parts' extent along the belt-travel axis and the lateral (across-belt) axis.
        const double belt_min = belt_is_y ? y_min : x_min;
        const double belt_max = belt_is_y ? y_max : x_max;
        const double lat_min  = belt_is_y ? x_min : y_min;
        const double lat_max  = belt_is_y ? x_max : y_max;
 
        // Worst-case purge volume of one layer: up to (filament count - 1)
        // toolchanges, each needing the worst flush matrix entry (mirrors the
        // volume selection in Print::_plan_belt_purge()).
        double max_flush = prime_volume;
        if (use_matrix) {
            const size_t extruder_nums = wxGetApp().preset_bundle->get_printer_extruder_count();
            const std::vector<double> matrix = get_flush_volumes_matrix(
                project_config.option<ConfigOptionFloats>("flush_volumes_matrix")->values, 0, extruder_nums);
            const auto * multi_opt = project_config.option<ConfigOptionFloats>("flush_multiplier");
            const double multiplier = multi_opt != nullptr && !multi_opt->values.empty() ? multi_opt->get_at(0) : 1.;
            const int    n_total    = (int) (std::sqrt(double(matrix.size())) + 0.5);
            double       m          = 0.;
            for (int i : filaments)
                for (int j : filaments)
                    if (i != j && i <= n_total && j <= n_total)
                        m = std::max(m, matrix[size_t(i - 1) * n_total + size_t(j - 1)]);
            if (m > 0.)
                max_flush = m * multiplier;
        }
        const double v_layer = double(filaments.size() - 1) * max_flush;
 
        // Height from the per-layer purge demand. A tilted slicing plane cuts a
        // printable_width x (height/sin) rectangle out of the bars, so one layer
        // slab absorbs printable_width * (height/sin) * layer_height of purge. Solve for the height that
        // holds the worst-case per-layer purge, with eta (infill/perimeter packing)
        // and a safety margin for the tilt ramps / grid-alignment slop, plus a
        // minimum so the tower is a real printable body rather than a sliver.
        const double eta    = 0.85;
        const double safety = 1.6;
        double       height = safety * v_layer * sin_t / (printable_width * layer_h * eta);
        height = std::clamp(height, 8.0, std::max(8.0, printable_height));
 
        // --- Idempotence (input-keyed) ----------------------------------------
        auto q = [](double v) { return std::lround(v * 10.0); }; // 0.1 mm quantization
        BeltPurgeSignature &new_sig = plan.sig;
        new_sig.valid          = true;
        new_sig.filament_count = (int) filaments.size();
        new_sig.key[0] = q(width);
        new_sig.key[1] = q(layer_h);
        new_sig.key[2] = q(height);
        new_sig.key[3] = q(belt_min);
        new_sig.key[4] = q(belt_max);
        new_sig.key[5] = q(lat_min);
        new_sig.key[6] = q(z_max);
        new_sig.key[7] = static_cast<long>(rot);
        new_sig.key[8] = std::lround(theta * 10000.0);
        new_sig.key[9] = q(lat_max);
        const Vec3d plate_origin = plate->get_origin();
        new_sig.key[10] = q(plate_origin.x());
        new_sig.key[11] = q(plate_origin.y());
        if (bed_ext.defined) {
            new_sig.key[12] = q(bed_ext.max.x());
            new_sig.key[13] = q(bed_ext.max.y());
        }
 
        // --- Position ----------------------------------------------------------
        // Belt-travel axis. With the mesh rotated by theta before slicing, a machine
        // point (y,z) maps to slicing-Z = y*sin(theta) + z*cos(theta). The parts
        // occupy slicing-Z in [y_min*sin, y_max*sin + z_max*cos], and the bar's
        // FULL-cross-section region (the part not in a triangular end ramp) spans
        // slicing-Z [belt_start*sin + H*cos, belt_end*sin]. Covering the parts'
        // whole band needs belt_start <= y_min - H*cot (bar's own leading ramp) and
        // belt_end >= y_max + z_max*cot (parts' top features print further up the
        // belt). The trailing z_max*cot term dominates the bar's own ramp.
        //
        // Along the belt the bar stops at the end of the plate: a longer bar cannot be
        // printed, and the cross-sections it loses there are reported by the purge
        // planner when the parts' last layers then purge more than the bar holds.
        const double margin            = 5.;
        const double ramp_compensation = height / sin_t;
        const double belt_origin  = plate_origin[belt_is_y ? 1 : 0];
        double       belt_end     = belt_max + margin + ramp_compensation + z_max * cot_t;   // + parts' top-feature belt reach
        if (bed_ext.defined)
            belt_end = std::min(belt_end, belt_origin + (belt_is_y ? bed_ext.max.y() : bed_ext.max.x()) - inset);
        const double belt_start   = std::max(belt_origin, std::min(belt_min - ramp_compensation, belt_end - 10.)); // leading ramp, toward belt origin
        const double length       = std::max(belt_end - belt_start, 10.);
        belt_end                  = belt_start + length;
        const double belt_center  = 0.5 * (belt_start + belt_end);
 
        // Across-belt: flush against the bed's maximum edge, inset by half the bar
        // width so the bar's far edge sits on the boundary and the whole bar stays
        // on the bed. lat_min/lat_max come from instance_bounding_box (world frame).
        const double lat_origin   = plate_origin[belt_is_y ? 0 : 1];
        double       lat_center   = lat_max + 5. + 0.5 * width; // fallback: just past the parts
        if (bed_ext.defined) {
            const double bed_lat_max = belt_is_y ? bed_ext.max.x() : bed_ext.max.y();
            lat_center = lat_origin + bed_lat_max - inset - 0.5 * width;
        }
 
        plan.n_islands = n_islands;
        plan.w_sub     = (width - (n_islands - 1) * gap) / n_islands;
        plan.length    = length;
        plan.height    = height;
        plan.center    = Vec3d(belt_is_y ? lat_center : belt_center,
                               belt_is_y ? belt_center : lat_center,
                               0.5 * height);
    }
 
    // --- Decide ---------------------------------------------------------------
    // A plate whose prism exists and matches its recorded inputs is left alone, so
    // subsequent ticks are no-ops until the parts/config actually change.
    std::vector<int> to_delete = stale_prisms;
    std::vector<int> to_create;
    for (int plate_idx = 0; plate_idx < plate_count; ++plate_idx) {
        const Plan             &plan     = plans[size_t(plate_idx)];
        const std::vector<int> &existing = prisms_by_plate[size_t(plate_idx)];
        BeltPurgeSignature     &sig      = sigs[size_t(plate_idx)];
        if (!plan.wanted) {
            sig = BeltPurgeSignature{};
            to_delete.insert(to_delete.end(), existing.begin(), existing.end());
        } else if (existing.size() == 1 && model.objects[size_t(existing.front())]->instances.size() == 1 && plan.sig == sig) {
            continue;
        } else {
            to_delete.insert(to_delete.end(), existing.begin(), existing.end());
            to_create.push_back(plate_idx);
        }
    }
    if (to_delete.empty() && to_create.empty())
        return false;
 
    remove_prisms(to_delete);
 
    // --- (Re)create -----------------------------------------------------------
    // Build the prism as N DISCONNECTED sub-bars side by side across the belt,
    // N = (filaments - 1) = the worst-case number of toolchanges on one layer.
    // Why: mark_wiping_extrusions overrides whole extrusion-entity COLLECTIONS,
    // and each disconnected island slices into its own infill collection. With a
    // single solid box there is one collection per layer, so the FIRST toolchange
    // on a layer grabs the entire collection (consuming all of it for one swap)
    // and any further swaps on that layer find nothing left and go unabsorbed
    // (the classic wipe tower hides this by spilling leftover into the real
    // tower; the belt prism has no fallback). One island per simultaneous swap
    // lets each swap claim its own island. Total lateral footprint stays `width`
    // (each island width/N wide, separated by a small gap), so per-layer capacity
    // per island ~= max_flush, matching the height sizing.
    // Minimal gap between sub-bars: they must stay just-separated so the slicer
    // keeps them as distinct islands (hence distinct infill collections, one per
    // simultaneous swap). Zero gap would union them into one collection and
    // reintroduce the multi-swap-per-layer absorption bug; a hair over ~2 line
    // widths also keeps gap-fill from bridging them. 1 mm is about as close as
    // they can butt up while staying individually purgeable.
    for (int plate_idx : to_create) {
        const Plan &plan = plans[size_t(plate_idx)];
 
        TriangleMesh prism_mesh;
        for (int i = 0; i < plan.n_islands; ++i) {
            const double lat_off = i * (plan.w_sub + gap);
            // Box dims: lateral = w_sub, along-belt = length, vertical = height.
            TriangleMesh box = belt_is_y ? make_cube(plan.w_sub, plan.length, plan.height)   // X = lateral, Y = belt
                                         : make_cube(plan.length, plan.w_sub, plan.height);  // X = belt,    Y = lateral
            box.translate(belt_is_y ? Vec3f((float) lat_off, 0.f, 0.f) : Vec3f(0.f, (float) lat_off, 0.f));
            prism_mesh.merge(box);
        }
 
        ModelObject *new_object = model.add_object();
        new_object->name        = _u8L("Belt Purge Tower");
        new_object->add_instance();
        ModelVolume *new_volume = new_object->add_volume(std::move(prism_mesh));
        new_volume->name        = new_object->name;
 
        auto &cfg = new_object->config;
        cfg.set_key_value("belt_purge_tower_object", new ConfigOptionBool(true));
        cfg.set_key_value("flush_into_objects", new ConfigOptionBool(true));
        cfg.set_key_value("extruder", new ConfigOptionInt(1));
        // Sacrificial solid prism: one wall, no shells, dense rectilinear infill —
        // every extrusion is overriddable, so the absorbed volume matches the
        // cross-section x layer-height estimate used for the height above.
        cfg.set_key_value("wall_loops", new ConfigOptionInt(1));
        cfg.set_key_value("top_shell_layers", new ConfigOptionInt(0));
        cfg.set_key_value("bottom_shell_layers", new ConfigOptionInt(0));
        cfg.set_key_value("sparse_infill_density", new ConfigOptionPercent(100));
        cfg.set_key_value("sparse_infill_pattern", new ConfigOptionEnum<InfillPattern>(ipRectilinear));
        cfg.set_key_value("enable_support", new ConfigOptionBool(false));
        cfg.set_key_value("brim_type", new ConfigOptionEnum<BrimType>(btNoBrim));
        cfg.set_key_value("seam_slope_type", new ConfigOptionEnum<SeamScarfType>(SeamScarfType::None));
        cfg.set_key_value("precise_z_height", new ConfigOptionBool(false));
 
        // Position by the belt-calibration pattern: drop to the bed, then translate
        // the instance by the delta between the object's ACTUAL bbox center and the
        // target. Setting the instance offset directly is unreliable here — the
        // freshly added cube's local frame is not centered, so set_offset() lands
        // the min corner (not the center) on the target, leaving the bar centered
        // on the bed edge with half of it hanging off.
        new_object->invalidate_bounding_box();
        new_object->ensure_on_bed();
        const BoundingBoxf3 cur = new_object->bounding_box_exact();
        new_object->translate_instances(Vec3d(plan.center.x() - cur.center().x(),
                                              plan.center.y() - cur.center().y(),
                                              0.0));
        new_object->instances.front()->set_assemble_transformation(new_object->instances.front()->get_transformation());
 
        const size_t obj_idx = model.objects.size() - 1;
        // Registers the object in the sidebar and notifies the part plates;
        // selection is left untouched (auto-managed object).
        obj_list->add_object_to_list(obj_idx, /*call_selection_changed=*/false);
 
        sigs[size_t(plate_idx)] = plan.sig;
    }
 
    return true;
}

References _u8L, Slic3r::ModelObject::add_instance(), Slic3r::Model::add_object(), Slic3r::ModelObject::add_volume(), Slic3r::ModelObject::bounding_box_exact(), Slic3r::btNoBrim, Slic3r::ByObject, Slic3r::BoundingBox3Base< PointType >::center(), Slic3r::center(), Slic3r::ModelObject::config, Slic3r::GUI::PartPlate::contain_instance_totally(), Slic3r::BoundingBoxBase< PointType, APointsType >::defined, Slic3r::Geometry::deg2rad(), Slic3r::Model::delete_object(), Slic3r::ModelObject::ensure_on_bed(), EPSILON, Slic3r::expand_mixed_filaments(), Slic3r::f(), Slic3r::GUI::BeltPurgeSignature::filament_count, Slic3r::GUI::PartPlateList::find_instance(), Slic3r::get_extents(), Slic3r::ModelVolume::get_extruders(), Slic3r::get_flush_volumes_matrix(), Slic3r::GUI::PartPlate::get_origin(), Slic3r::GUI::PartPlateList::get_plate(), Slic3r::GUI::PartPlateList::get_plate_count(), Slic3r::ConfigOptionResolver::has(), Slic3r::has_any_mixed_filament(), Slic3r::ModelObject::instance_bounding_box(), Slic3r::ModelObject::instances, Slic3r::ModelObject::invalidate_bounding_box(), Slic3r::ipRectilinear, Slic3r::GUI::BeltPurgeSignature::key, Slic3r::length(), M_PI, Slic3r::make_cube(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::TriangleMesh::merge(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::ModelObject::name, Slic3r::ModelVolume::name, Slic3r::None, Slic3r::GUI::PartPlateList::notify_instance_removed(), obj_list(), Slic3r::Model::objects, Slic3r::DynamicConfig::opt_float(), Slic3r::ConfigBase::option(), Slic3r::ModelConfig::option(), Slic3r::prime_volume(), Slic3r::printable_height(), printer_config(), Slic3r::ModelConfig::set_key_value(), Slic3r::ModelObject::translate_instances(), Slic3r::GUI::BeltPurgeSignature::valid, Slic3r::ConfigOptionSingle< T >::value, Slic3r::ConfigOptionVector< T >::values, Slic3r::ModelObject::volumes, Slic3r::X, and Slic3r::Y.

Referenced by Slic3r::GUI::Plater::priv::ensure_belt_purge_tower(), and Slic3r::GUI::Plater::priv::update_background_process().

Here is the call graph for this function:

Here is the caller graph for this function:

ensure_model_info()

std::shared_ptr< ModelInfo > Slic3r::GUI::ensure_model_info ( )

static

{
    auto& model = wxGetApp().plater()->model();
    if (model.model_info == nullptr) {
        model.model_info = std::make_shared<ModelInfo>();
    }
    return model.model_info;
}

Referenced by Slic3r::GUI::DesignerPanel::on_input_enter_description(), Slic3r::GUI::DesignerPanel::on_input_enter_model(), Slic3r::GUI::DesignerPanel::on_select_license(), and Slic3r::GUI::AuFile::on_set_cover().

Here is the caller graph for this function:

entity_endpoints()

void Slic3r::GUI::entity_endpoints ( const SketchEntity & e, std::vector< Vec2d > & out )

static

{
    out.clear();
    if (e.type == SketchEntity::Type::Line) {
        out.push_back(e.p0);
        out.push_back(e.p1);
    } else if (e.type == SketchEntity::Type::Arc) {
        out.push_back(e.center + e.radius * Vec2d(std::cos(e.start_angle), std::sin(e.start_angle)));
        out.push_back(e.center + e.radius * Vec2d(std::cos(e.end_angle),   std::sin(e.end_angle)));
    }
}

References Slic3r::SketchEntity::Arc, Slic3r::SketchEntity::center, Slic3r::SketchEntity::end_angle, entity_endpoints(), Slic3r::SketchEntity::Line, Slic3r::SketchEntity::p0, Slic3r::SketchEntity::p1, Slic3r::SketchEntity::radius, Slic3r::SketchEntity::start_angle, and Slic3r::SketchEntity::type.

Referenced by Slic3r::GUI::DesignSketchTool::connected_loop(), and entity_endpoints().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_moved()

bool Slic3r::GUI::entity_moved ( const SketchEntity & a, const SketchEntity & b, double tol )

static

{
    if (a.type != b.type) return true;
    auto moved = [tol](const Vec2d& p, const Vec2d& q) { return (p - q).norm() > tol; };
    if (moved(a.p0, b.p0)) return true;
    switch (a.type) {
    case SketchEntity::Type::Point:
        return false;
    case SketchEntity::Type::Line:
        return moved(a.p1, b.p1);
    case SketchEntity::Type::Circle:
        return moved(a.center, b.center) || std::abs(a.radius - b.radius) > tol;
    case SketchEntity::Type::Arc:
        return moved(a.p1, b.p1) || moved(a.center, b.center)
            || std::abs(a.radius - b.radius) > tol
            || std::abs((a.end_angle - a.start_angle) - (b.end_angle - b.start_angle)) > tol;
    case SketchEntity::Type::Ellipse:
    case SketchEntity::Type::EllipseArc:
        return moved(a.center, b.center) || std::abs(a.radius - b.radius) > tol
            || std::abs(a.rminor - b.rminor) > tol || std::abs(a.rotation - b.rotation) > tol;
    default:
        return moved(a.p1, b.p1);
    }
}

References Slic3r::SketchEntity::Arc, Slic3r::SketchEntity::center, Slic3r::SketchEntity::Circle, Slic3r::SketchEntity::Ellipse, Slic3r::SketchEntity::EllipseArc, Slic3r::SketchEntity::end_angle, entity_moved(), Slic3r::SketchEntity::Line, Slic3r::SketchEntity::p0, Slic3r::SketchEntity::p1, Slic3r::SketchEntity::Point, Slic3r::SketchEntity::radius, Slic3r::SketchEntity::rminor, Slic3r::SketchEntity::rotation, Slic3r::SketchEntity::start_angle, and Slic3r::SketchEntity::type.

Referenced by Slic3r::GUI::DesignSketchTool::confirm_op(), and entity_moved().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_pick_dist()

double Slic3r::GUI::entity_pick_dist ( const Vec2d & p, const SketchEntity & e )

static

{
    switch (e.type) {
    case SketchEntity::Type::Line:   return point_segment_dist(p, e.p0, e.p1);
    case SketchEntity::Type::Point:  return (p - e.p0).norm();
    case SketchEntity::Type::Circle:
    case SketchEntity::Type::Arc:    return std::abs((p - e.center).norm() - e.radius);
    case SketchEntity::Type::Ellipse:
    case SketchEntity::Type::EllipseArc: {
        // Accurate edge pick: sample the true ellipse outline as a polyline and take the
        // min segment distance. The crude mean-radius circle mis-picks eccentric ellipses
        // (the outline at the major/minor extremes is far from that circle), which made the
        // face-fill swallow edge clicks. Full ellipse sweeps 0..2pi; an arc its param range.
        const double cu = std::cos(e.rotation), su = std::sin(e.rotation);
        const bool full = (e.type == SketchEntity::Type::Ellipse);
        const double t0 = full ? 0.0 : e.start_angle;
        const double t1 = full ? 2.0 * M_PI : e.end_angle;
        const int n = 48;
        double best = 1e30; Vec2d prev;
        for (int i = 0; i <= n; ++i) {
            const double t = t0 + (t1 - t0) * double(i) / n;
            const double lx = e.radius * std::cos(t), ly = e.rminor * std::sin(t);   // local
            const Vec2d q(e.center.x() + lx * cu - ly * su,
                          e.center.y() + lx * su + ly * cu);                          // world
            if (i > 0) best = std::min(best, point_segment_dist(p, prev, q));
            prev = q;
        }
        return best;
    }
    case SketchEntity::Type::BSpline: {
        const std::vector<Vec2d> poly = bspline_polyline(e.ctrl);
        double best = 1e30;
        for (size_t i = 1; i < poly.size(); ++i)
            best = std::min(best, point_segment_dist(p, poly[i - 1], poly[i]));
        return best;
    }
    }
    return 1e30;
}

References Slic3r::SketchEntity::Arc, Slic3r::SketchEntity::BSpline, bspline_polyline(), Slic3r::SketchEntity::center, Slic3r::SketchEntity::Circle, Slic3r::SketchEntity::ctrl, Slic3r::SketchEntity::Ellipse, Slic3r::SketchEntity::EllipseArc, Slic3r::SketchEntity::end_angle, entity_pick_dist(), Slic3r::SketchEntity::Line, M_PI, Slic3r::SketchEntity::p0, Slic3r::SketchEntity::p1, Slic3r::SketchEntity::Point, point_segment_dist(), Slic3r::SketchEntity::radius, Slic3r::SketchEntity::rminor, Slic3r::SketchEntity::rotation, Slic3r::SketchEntity::start_angle, and Slic3r::SketchEntity::type.

Referenced by Slic3r::GUI::DesignSketchTool::apply_live_trim(), Slic3r::GUI::DesignSketchTool::compute_trim_preview(), entity_pick_dist(), Slic3r::GUI::DesignSketchTool::hit_display_sketch(), Slic3r::GUI::DesignSketchTool::hit_test(), and Slic3r::GUI::DesignSketchTool::on_mouse_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_ref_point()

bool Slic3r::GUI::entity_ref_point ( const SketchEntity & e, Vec2d & out )

static

{
    switch (e.type) {
    case SketchEntity::Type::Point:  out = e.p0;     return true;
    case SketchEntity::Type::Circle:
    case SketchEntity::Type::Arc:
    case SketchEntity::Type::Ellipse:
    case SketchEntity::Type::EllipseArc: out = e.center; return true;
    default:                         return false;   // Line
    }
}

References Slic3r::SketchEntity::Arc, Slic3r::SketchEntity::center, Slic3r::SketchEntity::Circle, Slic3r::SketchEntity::Ellipse, Slic3r::SketchEntity::EllipseArc, entity_ref_point(), Slic3r::SketchEntity::p0, Slic3r::SketchEntity::Point, and Slic3r::SketchEntity::type.

Referenced by Slic3r::GUI::DesignSketchTool::apply_dimension(), Slic3r::GUI::DesignSketchTool::dimension_current(), Slic3r::GUI::DesignSketchTool::dimension_kind(), and entity_ref_point().

Here is the call graph for this function:

Here is the caller graph for this function:

epsilon()

double Slic3r::GUI::epsilon ( )

constexpr

{ return 0.0011; }

Referenced by contains(), Slic3r::GUI::IMSlider::get_label(), Slic3r::GUI::IMSlider::get_tick_from_value(), and Slic3r::GUI::Preview::update_layers_slider().

Here is the caller graph for this function:

equivalent_areas()

bool Slic3r::GUI::equivalent_areas	(	const double &	bottom_area,
		const double &	top_area )

{
    return fabs(bottom_area - top_area) <= miscalculation();
}

References miscalculation().

Referenced by check_color_change(), and Slic3r::GUI::Preview::update_layers_slider().

Here is the call graph for this function:

Here is the caller graph for this function:

estimate_wipe_tower_info()

arrangement::ArrangePolygon Slic3r::GUI::estimate_wipe_tower_info	(	int	plate_index,
		std::set< int > &	extruder_ids )

{
    PartPlateList& ppl = wxGetApp().plater()->get_partplate_list();
    const auto& full_config = wxGetApp().preset_bundle->full_config();
    int plate_count = ppl.get_plate_count();
    int plate_index_valid = std::min(plate_index, plate_count - 1);
 
    // we have to estimate the depth using the extruder number of all plates
    int extruder_size = extruder_ids.size();
 
    Vec3d wipe_tower_size, wipe_tower_pos;
    auto arrange_poly = ppl.get_plate(plate_index_valid)->estimate_wipe_tower_polygon(full_config, plate_index, wipe_tower_pos, wipe_tower_size, extruder_size);
    arrange_poly.bed_idx = plate_index;
    return arrange_poly;
}

References Slic3r::arrangement::ArrangePolygon::bed_idx, Slic3r::GUI::PartPlate::estimate_wipe_tower_polygon(), Slic3r::GUI::PartPlateList::get_plate(), and Slic3r::GUI::PartPlateList::get_plate_count().

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

Here is the call graph for this function:

Here is the caller graph for this function:

expolygon_from_polygon()

ExPolygon Slic3r::GUI::expolygon_from_polygon ( const Polygon & polygon )

static

{
    ExPolygon expolygon;
    expolygon.contour = polygon;
    expolygon.contour.make_counter_clockwise();
    return expolygon;
}

References Slic3r::ExPolygon::contour, and Slic3r::Polygon::make_counter_clockwise().

Referenced by init_exclusion_volume_prism_model(), init_model_from_polygons(), and Slic3r::GUI::PartPlate::update_exclusion_volume_preview_models().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_remote_filename()

std::string Slic3r::GUI::extract_remote_filename

(

const std::string &

str

)

                                                        {
    std::regex r("filename=\"([^\"]*)\"");
    std::smatch match;
    if (std::regex_search(str.begin(), str.end(), match, r)) {
        return match.str(1);
    } else {
        return "";
    }
}

Referenced by Slic3r::GUI::FileGet::priv::get_perform().

Here is the caller graph for this function:

extruder_group_chip_bg()

wxColour Slic3r::GUI::extruder_group_chip_bg ( )

static

{
    return StateColor::darkModeColorFor(*wxWHITE);
}

References StateColor::darkModeColorFor().

Referenced by Slic3r::GUI::ExtruderGroup::ExtruderGroup(), Slic3r::GUI::HoverLabel::HoverLabel(), Slic3r::GUI::ExtruderGroup::sys_color_changed(), and Slic3r::GUI::HoverLabel::sys_color_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

extruder_supports_tpu_high_flow()

bool Slic3r::GUI::extruder_supports_tpu_high_flow	(	PresetBundle *	preset_bundle,
		int	extruder_id )

{
    if (!preset_bundle)
        return false;
    const auto *nozzle_diameter = preset_bundle->printers.get_edited_preset().config.option<ConfigOptionFloats>("nozzle_diameter");
    return nozzle_diameter != nullptr && extruder_id >= 0 && extruder_id < (int) nozzle_diameter->values.size() &&
           nozzle_diameter_supports_tpu_high_flow(nozzle_diameter->values[extruder_id]);
}

References Slic3r::Preset::config, Slic3r::PresetCollection::get_edited_preset(), Slic3r::nozzle_diameter(), nozzle_diameter_supports_tpu_high_flow(), Slic3r::ConfigBase::option(), and Slic3r::PresetBundle::printers.

Referenced by Slic3r::GUI::Sidebar::priv::get_nozzle_options(), and tryPopUpMultiNozzleDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

eye_action()

DesignRowList::Action Slic3r::GUI::eye_action ( bool shown )

static

{
    return { RowVisibility, shown ? "design_eye" : "design_eye_off", shown ? _L("Hide") : _L("Show") };
}

References _L, and RowVisibility.

Referenced by Slic3r::GUI::DesignPanel::refresh_parts(), Slic3r::GUI::DesignPanel::refresh_pinned(), and Slic3r::GUI::DesignPanel::refresh_tree().

Here is the caller graph for this function:

face_plane_inward()

SketchPlane Slic3r::GUI::face_plane_inward ( const TopoDS_Face & face )

static

{
    SketchPlane p;
    p.origin = GeometryEngine::face_centroid_world(face);
    p.normal = (-GeometryEngine::face_normal_world(face)).normalized();   // inward
    // Align the in-plane x-axis with the face's LONGEST straight edge so the (u,v) frame matches
    // the face sides — then "distance from a side" (the hole construction dims) reads correctly.
    Vec3d x(0, 0, 0); double best = 0;
    for (const TopoDS_Edge& e : GeometryEngine::edges_of_face(face)) {
        const std::vector<Vec3d> pts = GeometryEngine::sample_edge_world(e);
        if (pts.size() < 2) continue;
        Vec3d d = pts.back() - pts.front();
        d = d - p.normal * d.dot(p.normal);        // project the edge direction into the plane
        const double len = d.norm();
        if (len > best) { best = len; x = d / len; }
    }
    if (best < 1e-9) {   // curved/edgeless face: fall back to an arbitrary in-plane basis
        const Vec3d ref = std::abs(p.normal.z()) < 0.9 ? Vec3d(0, 0, 1) : Vec3d(1, 0, 0);
        x = ref.cross(p.normal).normalized();
    }
    p.x_axis = x.normalized();
    p.y_axis = p.normal.cross(p.x_axis).normalized();
    return p;
}

References Slic3r::GeometryEngine::edges_of_face(), Slic3r::GeometryEngine::face_centroid_world(), Slic3r::GeometryEngine::face_normal_world(), Slic3r::SketchPlane::normal, Slic3r::SketchPlane::origin, Slic3r::GeometryEngine::sample_edge_world(), Slic3r::SketchPlane::x_axis, and Slic3r::SketchPlane::y_axis.

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

Here is the call graph for this function:

Here is the caller graph for this function:

face_selected_volume_to_camera()

bool Slic3r::GUI::face_selected_volume_to_camera	(	const Camera &	camera,
		GLCanvas3D &	canvas,
		const std::optional< double > &	wanted_up_limit = {} )

Apply camera direction for emboss direction.

Parameters

camera	Define view vector
canvas	Containe Selected ModelVolume to modify orientation
wanted_up_limit	[Optional]Limit for direction of up vector

Returns

True when apply change otherwise false

{
    GLVolume *gl_volume_ptr = get_selected_gl_volume(canvas);
    if (gl_volume_ptr == nullptr)
        return false;
    GLVolume &gl_volume = *gl_volume_ptr;
 
    const ModelObjectPtrs &objects = canvas.get_model()->objects;
    ModelObject *object_ptr = get_model_object(gl_volume, objects);
    assert(object_ptr != nullptr);
    if (object_ptr == nullptr)
        return false;
    ModelObject &object = *object_ptr;
 
    const ModelInstance *instance_ptr = get_model_instance(gl_volume, object);
    assert(instance_ptr != nullptr);
    if (instance_ptr == nullptr)
        return false;
    const ModelInstance &instance = *instance_ptr;
 
    ModelVolume *volume_ptr = get_model_volume(gl_volume, object);
    assert(volume_ptr != nullptr);
    if (volume_ptr == nullptr)
        return false;
    ModelVolume &volume = *volume_ptr;
 
    // Calculate new volume transformation
    Transform3d volume_tr = volume.get_matrix();
    std::optional<Transform3d> fix;
    if (volume.emboss_shape.has_value()) {
        fix = volume.emboss_shape->fix_3mf_tr;
        if (fix.has_value())
            volume_tr = volume_tr * fix->inverse();
    }
 
    Transform3d instance_tr     = instance.get_matrix();
    Transform3d instance_tr_inv = instance_tr.inverse();
    Transform3d world_tr        = instance_tr * volume_tr; // without sla !!!
    std::optional<float> current_angle;
    if (wanted_up_limit.has_value())
        current_angle = Emboss::calc_up(world_tr, *wanted_up_limit);
 
    Vec3d world_position = gl_volume.world_matrix()*Vec3d::Zero();
 
    assert(camera.get_type() == Camera::EType::Perspective || 
           camera.get_type() == Camera::EType::Ortho);
    Vec3d wanted_direction = (camera.get_type() == Camera::EType::Perspective) ?
        Vec3d(camera.get_position() - world_position) : 
        (-camera.get_dir_forward());
    
    Transform3d new_volume_tr = get_volume_transformation(world_tr, wanted_direction, world_position,
        fix, instance_tr_inv, current_angle, wanted_up_limit);
 
    Selection &selection = canvas.get_selection();
    if (is_embossed_object(selection)) {
        // transform instance instead of volume
        Transform3d new_instance_tr = instance_tr * new_volume_tr * volume.get_matrix().inverse();        
        gl_volume.set_instance_transformation(new_instance_tr);
        
        // set same transformation to other instances when instance is embossed object
        if (selection.is_single_full_instance()) 
            selection.synchronize_unselected_instances(Selection::SyncRotationType::GENERAL);
    } else {
        // write result transformation
        gl_volume.set_volume_transformation(new_volume_tr);
    }
 
    if (volume.type() == ModelVolumeType::MODEL_PART) {
        object.invalidate_bounding_box();
        object.ensure_on_bed();
    }
 
    canvas.do_rotate(L("Face the camera"));
    wxGetApp().obj_manipul()->set_dirty();
    return true;
}

References Slic3r::Emboss::calc_up(), Slic3r::GUI::GLCanvas3D::do_rotate(), Slic3r::ModelVolume::emboss_shape, Slic3r::GUI::Selection::GENERAL, Slic3r::GUI::Camera::get_dir_forward(), Slic3r::ModelInstance::get_matrix(), Slic3r::ModelVolume::get_matrix(), Slic3r::GUI::GLCanvas3D::get_model(), get_model_instance(), get_model_object(), get_model_volume(), Slic3r::GUI::Camera::get_position(), get_selected_gl_volume(), Slic3r::GUI::GLCanvas3D::get_selection(), Slic3r::GUI::Camera::get_type(), Slic3r::GUI::Selection::is_single_full_instance(), L, Slic3r::MODEL_PART, Slic3r::Model::objects, Slic3r::GUI::Camera::Ortho, Slic3r::GUI::Camera::Perspective, Slic3r::GLVolume::set_instance_transformation(), Slic3r::GLVolume::set_volume_transformation(), Slic3r::GUI::Selection::synchronize_unselected_instances(), Slic3r::ModelVolume::type(), and Slic3r::GLVolume::world_matrix().

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_advanced(), and Slic3r::GUI::GLGizmoSVG::draw_face_the_camera().

Here is the call graph for this function:

Here is the caller graph for this function:

fatal_error()

void Slic3r::GUI::fatal_error

(

wxWindow *

parent

)

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

References fatal_error(), and show_error().

Referenced by fatal_error().

Here is the call graph for this function:

Here is the caller graph for this function:

filament_color_picker_changed()

bool Slic3r::GUI::filament_color_picker_changed	(	const ColorSelection &	initial,
		const std::optional< ColorSelection > &	result )

{
    // Compare encoded bytes, not ColorRGBA's tolerant floating point equality.
    // An unchanged seed also leaves unrepresentable multi-color data untouched.
    return result && color_selection_to_json(initial) != color_selection_to_json(*result);
}

Referenced by Slic3r::GUI::FilamentPickerDialog::BindEvents(), and Slic3r::GUI::PlaterPresetComboBox::show_default_color_picker().

Here is the caller graph for this function:

filament_color_picker_initial()

ColorSelection Slic3r::GUI::filament_color_picker_initial

(

const FilamentColorPickerValue &

value

)

{
    if (const auto exact = filament_color_picker_selection(value))
        return *exact;
    if (!value.colors.empty()) {
        if (const auto primary = color_selection_from_json({{"type", "solid"}, {"colors", {value.colors.front()}}}, {false, true}))
            return *primary;
    }
    if (const auto primary = color_selection_from_json({{"type", "solid"}, {"colors", {value.primary}}}, {false, true}))
        return *primary;
    return ColorRGBA(0.f, 0.f, 0.f, 1.f);
}

References Slic3r::GUI::FilamentColorPickerValue::colors, filament_color_picker_selection(), and Slic3r::GUI::FilamentColorPickerValue::primary.

Referenced by Slic3r::GUI::FilamentPickerDialog::BindEvents(), and Slic3r::GUI::PlaterPresetComboBox::show_default_color_picker().

Here is the call graph for this function:

Here is the caller graph for this function:

filament_color_picker_result()

FilamentColorPickerValue Slic3r::GUI::filament_color_picker_result

(

const ColorSelection &

selection

)

{
    // Keep legacy RGB spelling for opaque colors; retain RGBA for transparency.
    const auto canonical = color_selection_to_json(selection);
    FilamentColorPickerValue value;
    value.gradient = canonical.at("type") == "gradient";
    for (const auto& color : canonical.at("colors")) {
        auto hex = color.get<std::string>();
        if (hex.compare(7, 2, "FF") == 0) hex.resize(7);
        value.colors.push_back(std::move(hex));
    }
    return value;
}

References Slic3r::GUI::FilamentColorPickerValue::colors, and Slic3r::GUI::FilamentColorPickerValue::gradient.

Referenced by Slic3r::GUI::PlaterPresetComboBox::PlaterPresetComboBox(), Slic3r::GUI::FilamentPickerDialog::BindEvents(), and Slic3r::GUI::PlaterPresetComboBox::show_default_color_picker().

Here is the caller graph for this function:

filament_color_picker_selection()

std::optional< ColorSelection > Slic3r::GUI::filament_color_picker_selection

(

const FilamentColorPickerValue &

value

)

{
    return color_selection_from_json({{"type", value.gradient ? "gradient" : "solid"}, {"colors", value.colors}}, {true, true});
}

References Slic3r::GUI::FilamentColorPickerValue::colors, and Slic3r::GUI::FilamentColorPickerValue::gradient.

Referenced by Slic3r::GUI::FilamentPickerDialog::BindEvents(), filament_color_picker_initial(), and Slic3r::GUI::PlaterPresetComboBox::show_default_color_picker().

Here is the caller graph for this function:

filament_color_picker_value()

FilamentColorPickerValue Slic3r::GUI::filament_color_picker_value ( const DynamicPrintConfig & config, std::size_t index )

static

{
    FilamentColorPickerValue value;
    if (const auto* primary = config.opt<ConfigOptionStrings>("filament_colour"); primary && index < primary->values.size())
        value.primary = primary->values[index];
    if (const auto* multi = config.opt<ConfigOptionStrings>("filament_multi_colour"); multi && index < multi->values.size()) {
        std::istringstream stream(multi->values[index]);
        for (std::string color; stream >> color;)
            value.colors.push_back(std::move(color));
    }
    if (value.colors.empty() && !value.primary.empty())
        value.colors.push_back(value.primary);
    if (const auto* types = config.opt<ConfigOptionStrings>("filament_colour_type"); types && index < types->values.size())
        value.gradient = value.colors.size() > 1 && types->values[index] == "0";
    return value;
}

References Slic3r::GUI::FilamentColorPickerValue::colors, Slic3r::GUI::FilamentColorPickerValue::gradient, Slic3r::DynamicConfig::opt(), Slic3r::GUI::FilamentColorPickerValue::primary, and Slic3r::ConfigOptionVector< T >::size().

Referenced by Slic3r::GUI::PlaterPresetComboBox::PlaterPresetComboBox(), and Slic3r::GUI::PlaterPresetComboBox::show_default_color_picker().

Here is the call graph for this function:

Here is the caller graph for this function:

filament_name_to_wx_string()

wxString Slic3r::GUI::filament_name_to_wx_string ( const std::string & name )

static

{
    wxString utf8_name = wxString::FromUTF8(name.c_str());
    if (!utf8_name.empty() || name.empty())
        return utf8_name;
    return wxString(name);
}

Referenced by Slic3r::GUI::FilamentSelectPopup::create_item_row(), Slic3r::GUI::FilamentSelectPopup::create_mixed_item_row(), Slic3r::GUI::TextureImportDialog::rebuild_mapping_rows(), and Slic3r::GUI::TextureImportDialog::show_filament_popup().

Here is the caller graph for this function:

filament_type_for_color_decompose()

std::string Slic3r::GUI::filament_type_for_color_decompose

(

Preset *

preset

)

{
    if (!preset)
        return kDecomposePlaShortType;
 
    std::string display_type;
    std::string ft = preset->config.get_filament_type(display_type);
    const std::string basic = official_basic_type_from_preset_name(preset->name);
    if (!basic.empty())
        ft = basic;
    if (ft.empty())
        ft = kDecomposePlaShortType;
    return ft;
}

References Slic3r::Preset::config, Slic3r::DynamicPrintConfig::get_filament_type(), kDecomposePlaShortType, Slic3r::Preset::name, and official_basic_type_from_preset_name().

Referenced by Slic3r::GUI::TextureImportDialog::add_decomposed_mixed_filament(), and Slic3r::GUI::Sidebar::decompose_filament_color().

Here is the call graph for this function:

Here is the caller graph for this function:

filaments_count() [1/2]

int Slic3r::GUI::filaments_count ( )

static

{
    return wxGetApp().filaments_cnt();
}

Referenced by Slic3r::GUI::ObjectList::ObjectList(), Slic3r::GUI::MenuFactory::append_menu_item_change_extruder(), Slic3r::GUI::MenuFactory::append_menu_item_change_filament(), create_freq_settings_popupmenu(), get_full_settings_hierarchy(), Slic3r::GUI::ObjectList::key_event(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::ObjectList::update_filament_values_for_items(), Slic3r::GUI::ObjectList::update_objects_list_filament_column(), and Slic3r::GUI::ObjectList::update_objects_list_filament_column_when_delete_filament().

Here is the caller graph for this function:

filaments_count() [2/2]

int Slic3r::GUI::filaments_count ( )

static

{
    return wxGetApp().filaments_cnt();
}

file_url_from_path()

wxString Slic3r::GUI::file_url_from_path

(

const boost::filesystem::path &

path

)

{
  return wxFileSystem::FileNameToURL(wxFileName(from_path(path)));
}

References from_path().

Referenced by Slic3r::GUI::NozzleListTable::NozzleListTable(), Slic3r::GUI::PrivacyUpdateDialog::PrivacyUpdateDialog(), Slic3r::GUI::ProjectPanel::ProjectPanel(), Slic3r::GUI::WebViewPanel::WebViewPanel(), WipingDialog::WipingDialog(), Slic3r::GUI::web_hosting::bootstrap_url(), Slic3r::GUI::WebViewHostDialog::build_resource_url(), Slic3r::GUI::GuideFrame::BuildProfileJson(), Slic3r::GUI::web_hosting::content_base_url(), Slic3r::ElegooLink::get_print_host_webui(), Slic3r::GUI::GuideFrame::LoadProfileFamily(), Slic3r::GUI::MarkdownTip::LoadStyle(), Slic3r::GUI::GuideFrame::SetStartPage(), Slic3r::GUI::ZUserLogin::ShowErrorPage(), Slic3r::GUI::Sidebar::update_all_preset_comboboxes(), and Slic3r::GUI::UpdateVersionDialog::update_version_info().

Here is the call graph for this function:

Here is the caller graph for this function:

file_wildcards()

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));
        }
    const wxString translated_title = Slic3r::GUI::I18N::translate(data.title_id);
    return GUI::format_wxstr("%s (%s)|%s", translated_title, title, mask);
}

References Slic3r::GUI::FileWildcards::file_extensions, file_wildcards_by_type, format_wxstr(), Slic3r::GUI::FileWildcards::title_id, and Slic3r::GUI::I18N::translate().

Referenced by anonymous_namespace{GLGizmoSVG.cpp}::choose_svg_file(), Slic3r::GUI::GLGizmoSVG::draw_filename(), Slic3r::GUI::Plater::export_gcode(), Slic3r::GUI::Plater::export_gcode_3mf(), Slic3r::GUI::Plater::priv::get_export_file(), Slic3r::GUI::GUI_App::import_model(), Slic3r::GUI::GUI_App::import_zip(), Slic3r::GUI::GUI_App::load_gcode(), Slic3r::GUI::BedShapePanel::load_model(), Slic3r::GUI::CreatePrinterPresetDialog::load_model_stl(), Slic3r::GUI::GUI_App::load_project(), Slic3r::GUI::BedShapePanel::load_stl(), Slic3r::GUI::BedShapePanel::load_texture(), Slic3r::GUI::CreatePrinterPresetDialog::load_texture(), Slic3r::GUI::Plater::priv::reload_from_disk(), Slic3r::GUI::Plater::priv::replace_with_stl(), and start_new_gcodeviewer_open_file().

Here is the call graph for this function:

Here is the caller graph for this function:

fill_gradient_ramp_rect()

void Slic3r::GUI::fill_gradient_ramp_rect	(	wxDC &	dc,
		const wxRect &	rect,
		const std::vector< wxColour > &	ramp )

{
    if (rect.width <= 0 || rect.height <= 0 || ramp.empty()) return;
 
    dc.SetPen(*wxTRANSPARENT_PEN);
    for (int y = 0; y < rect.height; ++y) {
        // Row 0 is the top of the rect and so takes the ramp's last entry, the model's top.
        // Mapping over height - 1 puts both ends of the ramp on screen even in a short swatch.
        const double t = (rect.height > 1) ? (double) (rect.height - 1 - y) / (rect.height - 1) : 0.5;
        dc.SetBrush(wxBrush(ramp[static_cast<size_t>(t * (ramp.size() - 1) + 0.5)]));
        dc.DrawRectangle(rect.x, rect.y + y, rect.width, 1);
    }
}

Referenced by create_gradient_ramp_bitmap(), Slic3r::GUI::MixedFilamentDialog::create_preview_panel(), and Slic3r::GUI::Sidebar::update_mixed_filament_list().

Here is the caller graph for this function:

fill_gradient_rect_east()

void Slic3r::GUI::fill_gradient_rect_east	(	wxDC &	dc,
		const wxRect &	rect,
		const wxColour &	from,
		const wxColour &	to )

{
    if (rect.width <= 0 || rect.height <= 0) return;
 
    auto mix_channel = [](unsigned char a, unsigned char b, double t) {
        return static_cast<unsigned char>(a + (b - a) * t + 0.5);
    };
 
    dc.SetPen(*wxTRANSPARENT_PEN);
    for (int x = 0; x < rect.width; ++x) {
        const double t = rect.width > 1 ? static_cast<double>(x) / (rect.width - 1) : 0.0;
        const wxColour col(mix_channel(from.Red(), to.Red(), t),
                           mix_channel(from.Green(), to.Green(), t),
                           mix_channel(from.Blue(), to.Blue(), t),
                           mix_channel(from.Alpha(), to.Alpha(), t));
        dc.SetBrush(wxBrush(col));
        dc.DrawRectangle(rect.x + x, rect.y, 1, rect.height);
    }
}

Referenced by Slic3r::GUI::AMSPreview::doRender(), Slic3r::GUI::MappingItem::doRender(), Slic3r::GUI::MaterialItem::doRender(), Slic3r::GUI::MaterialSyncItem::doRender(), Slic3r::GUI::AMSLib::render_generic_lib(), and Slic3r::GUI::AMSLib::render_lite_lib().

Here is the caller graph for this function:

fill_nozzle_volume_combo()

void Slic3r::GUI::fill_nozzle_volume_combo ( ComboBox * combo )

static

{
    combo->Clear();
    const ConfigOptionDef *nozzle_volume_type_def = print_config_def.get("nozzle_volume_type");
    if (nozzle_volume_type_def && nozzle_volume_type_def->enum_keys_map) {
        for (size_t i = 0; i < nozzle_volume_type_def->enum_labels.size(); ++i)
            combo->Append(_L(nozzle_volume_type_def->enum_labels[i]), wxNullBitmap,
                          (void *) (intptr_t) nozzle_volume_type_def->enum_keys_map->at(nozzle_volume_type_def->enum_values[i]));
    }
    select_nozzle_volume(combo, NozzleVolumeType::nvtStandard);
}

References _L, ComboBox::Append(), Slic3r::ConfigOptionDef::enum_keys_map, Slic3r::ConfigOptionDef::enum_labels, Slic3r::ConfigOptionDef::enum_values, Slic3r::nvtStandard, Slic3r::print_config_def, and select_nozzle_volume().

Referenced by Slic3r::GUI::CalibrationPresetPage::init_selection_values().

Here is the call graph for this function:

Here is the caller graph for this function:

find_close_layer_idx() [1/2]

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_close_layer_idx() [2/2]

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;
}

find_decompose_standard_preset_name()

std::string Slic3r::GUI::find_decompose_standard_preset_name	(	size_t	source_config_idx,
		const std::string &	basic_type )

{
    const PresetBundle& preset_bundle = *wxGetApp().preset_bundle;
    if (source_config_idx < preset_bundle.filament_presets.size()) {
        const std::string& source_name = preset_bundle.filament_presets[source_config_idx];
        if (source_name.find(std::string(kDecomposeBambuPresetPrefix) + basic_type) != std::string::npos)
            return source_name;
    }
 
    const std::string prefix = std::string(kDecomposeBambuPresetPrefix) + basic_type + " @BBL ";
    for (const std::string& preset_name : preset_bundle.filament_presets) {
        if (preset_name.find(prefix) == 0)
            return preset_name;
    }
 
    return {};
}

References Slic3r::PresetBundle::filament_presets, and kDecomposeBambuPresetPrefix.

Referenced by prepare_decompose_mixed_result().

Here is the caller graph for this function:

find_existing_decompose_component()

int Slic3r::GUI::find_existing_decompose_component	(	const DecomposeOfficialComponent &	component,
		const std::vector< std::string > &	physical_colors,
		const std::vector< size_t > &	physical_config_indices,
		size_t	source_config_idx )

{
    auto& project_config = wxGetApp().preset_bundle->project_config;
    auto* filament_id_opt = project_config.option<ConfigOptionStrings>("filament_id");
    auto* type_opt = project_config.option<ConfigOptionStrings>("filament_type");
    const PresetBundle& preset_bundle = *wxGetApp().preset_bundle;
    const size_t num_physical = physical_colors.size();
    // component.filament_id is our OF id; the two constants are the printer's own ids.
    auto* agent = wxGetApp().getAgent();
    const std::string printer_filament_id = agent ? agent->from_orca_filament_id(component.filament_id) : component.filament_id;
    const std::string expected_basic_type = printer_filament_id == kDecomposePetgFilamentId ? kDecomposePetgBasicType :
                                            printer_filament_id == kDecomposePlaFilamentId ? kDecomposePlaBasicType : "";
    const std::string expected_short_type = expected_basic_type == kDecomposePetgBasicType ? kDecomposePetgShortType :
                                            expected_basic_type == kDecomposePlaBasicType ? kDecomposePlaShortType : "";
    const std::string expected_preset_part = expected_basic_type.empty() ? "" : std::string(kDecomposeBambuPresetPrefix) + expected_basic_type;
    for (size_t i = 0; i < num_physical && i < physical_config_indices.size(); ++i) {
        const size_t config_idx = physical_config_indices[i];
        const std::string slot_color = decompose_normalize_color_hex(physical_colors[i]);
        const std::string slot_filament_id = (filament_id_opt && config_idx < filament_id_opt->values.size()) ? filament_id_opt->values[config_idx] : "";
        const std::string slot_type = (type_opt && config_idx < type_opt->values.size()) ? type_opt->values[config_idx] : "";
        const std::string preset_name = config_idx < preset_bundle.filament_presets.size() ? preset_bundle.filament_presets[config_idx] : "";
        if (config_idx == source_config_idx) {
            continue;
        }
        if (slot_color != component.color_hex) {
            continue;
        }
 
        if (!component.filament_id.empty() && slot_filament_id == component.filament_id) {
            return static_cast<int>(config_idx + 1);
        }
 
        if (!expected_basic_type.empty() && (slot_type == expected_basic_type || slot_type == expected_short_type)) {
            return static_cast<int>(config_idx + 1);
        }
 
        if (!expected_preset_part.empty() && preset_name.find(expected_preset_part) != std::string::npos) {
            return static_cast<int>(config_idx + 1);
        }
 
        const bool has_material_hint = !slot_filament_id.empty() || !slot_type.empty() || !preset_name.empty();
        if (!expected_basic_type.empty() && has_material_hint)
            continue;
 
        return static_cast<int>(config_idx + 1);
    }
    return -1;
}

References Slic3r::GUI::DecomposeOfficialComponent::color_hex, decompose_normalize_color_hex(), Slic3r::GUI::DecomposeOfficialComponent::filament_id, kDecomposeBambuPresetPrefix, kDecomposePetgBasicType, kDecomposePetgFilamentId, kDecomposePetgShortType, kDecomposePlaBasicType, kDecomposePlaFilamentId, kDecomposePlaShortType, and Slic3r::ConfigOptionVector< T >::values.

Referenced by count_decompose_new_physical_filaments(), and prepare_decompose_mixed_result().

Here is the call graph for this function:

Here is the caller graph for this function:

find_font()

wxFont * Slic3r::GUI::find_font	(	const std::string &	text_str,
		int	max_size = 32 )

{
  auto is_font_suitable = [](std::string str, wxFont &font, int max_size) {
    wxString msg(str);
  wxCoord w, h;
  get_text_extent(msg, w, h, &font);
 
    if (w <= max_size)
      return true;
    else
      return false;
  };
  wxFont *font = nullptr;
  if (is_font_suitable(text_str, Label::Head_24, max_size))
    font = &Label::Head_24;
  else if (is_font_suitable(text_str, Label::Head_20, max_size))
    font = &Label::Head_20;
  else if (is_font_suitable(text_str, Label::Head_18, max_size))
    font = &Label::Head_18;
  else if (is_font_suitable(text_str, Label::Head_16, max_size))
    font = &Label::Head_16;
  else if (is_font_suitable(text_str, Label::Head_14, max_size))
    font = &Label::Head_14;
  else
    font = &Label::Head_12;
 
  return font;
}

References get_text_extent(), Label::Head_12, Label::Head_14, Label::Head_16, Label::Head_18, Label::Head_20, and Label::Head_24.

Here is the call 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_cgal(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::Tab::OnActivate(), and Slic3r::GUI::GLGizmoCut3D::perform_cut().

Here is the caller graph for this function:

fit_in_display()

void Slic3r::GUI::fit_in_display	(	wxTopLevelWindow &	window,
		wxSize	desired_size )

Make sure the given window fits inside current display.

{
    const auto display_size = wxDisplay(window.GetParent()).GetClientArea();
    if (desired_size.GetWidth() > display_size.GetWidth()) {
        desired_size.SetWidth(display_size.GetWidth() * 4 / 5);
    }
    if (desired_size.GetHeight() > display_size.GetHeight()) {
        desired_size.SetHeight(display_size.GetHeight() * 4 / 5);
    }
 
    window.SetSize(desired_size);
}

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

Here is the caller graph for this function:

float_to_string_with_precision()

std::string Slic3r::GUI::float_to_string_with_precision ( float value, int precision = 3 )

static

{
    if (value < 0)
        return std::string();
 
    std::stringstream stream;
    stream << std::fixed << std::setprecision(precision) << value;
    return stream.str();
}

Referenced by Slic3r::GUI::AMSMaterialsSetting::on_select_cali_result(), and Slic3r::GUI::AMSMaterialsSetting::on_select_filament().

Here is the caller graph for this function:

focus_event()

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."));
        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:

font_faces()

const wxArrayString & Slic3r::GUI::font_faces ( )

static

{
    static wxArrayString faces = [] {
        // '@' faces are the vertical-writing aliases GTK/MSW list twice.
        wxArrayString f = wxFontEnumerator::GetFacenames(wxFONTENCODING_SYSTEM, false);
        f.erase(std::remove_if(f.begin(), f.end(), [](const wxString& n) { return n.StartsWith("@"); }), f.end());
        f.Sort();
        return f;
    }();
    return faces;
}

References Slic3r::f().

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

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().

Referenced by Slic3r::GUI::AboutDialog::AboutDialog(), Slic3r::GUI::CopyrightsDialog::CopyrightsDialog(), Slic3r::GUI::NetworkTestDialog::NetworkTestDialog(), Slic3r::GUI::PageWelcome::PageWelcome(), Slic3r::GUI::ProjectDropDialog::ProjectDropDialog(), Slic3r::GUI::GLGizmoSimplify::add_simplify_suggestion_notification(), Slic3r::GUI::NotificationManager::UpdatedItemsInfoNotification::add_type(), Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp}::add_wheel_dependencies_to_sys_path(), Slic3r::GUI::GLGizmoSimplify::apply_simplify(), Slic3r::GUI::ImGuiWrapper::bbl_input_double(), Slic3r::GUI::ImGuiWrapper::bbl_slider_float(), Slic3r::GUI::ImGuiWrapper::bbl_slider_float_style(), Slic3r::GUI::ImGuiWrapper::bbl_sliderin(), Slic3r::GUI::GUI_App::check_bundle_updates(), Slic3r::GUI::PartPlate::check_compatible_of_nozzle_and_filament(), Slic3r::GUI::PartPlate::check_mixture_filament_compatible(), Slic3r::PresetUpdater::priv::check_new_vendors(), Slic3r::GUI::GUI_App::check_new_version_sf(), Slic3r::PluginManager::check_registry_locked(), Slic3r::GUI::TextureImportDialog::compact_used_virtual_filaments(), Slic3r::GUI::Config::copy_config_dir_single_level(), Slic3r::copy_file_fix(), anonymous_namespace{GLGizmoSVG.cpp}::create_fill_warning(), Slic3r::GUI::GLGizmoEmboss::create_notification_not_valid_font(), anonymous_namespace{GLGizmoSVG.cpp}::create_shape_warnings(), anonymous_namespace{GLGizmoSVG.cpp}::create_stroke_warning(), Slic3r::PluginManager::delete_and_unsubscribe_cloud_plugin(), Slic3r::PluginManager::delete_plugin(), Slic3r::delete_plugin_root(), Slic3r::GUI::TextureImportDialog::do_auto_match(), Slic3r::PluginManager::download_and_install_cloud_plugin(), Slic3r::CloudPluginService::download_cloud_plugin(), Slic3r::GUI::GUI_App::download_plugin(), Slic3r::GUI::ImGuiWrapper::drag_optional_float(), Slic3r::GUI::GLGizmoEmboss::draw_delete_style_button(), Slic3r::GUI::GLGizmoSVG::draw_filename(), Slic3r::GUI::GLGizmoSVG::draw_size(), Slic3r::GUI::GLGizmoEmboss::draw_style_list(), Slic3r::GUI::GLGizmoEmboss::draw_style_rename_popup(), Slic3r::GUI::GLGizmoEmboss::draw_style_save_button(), Slic3r::GUI::ArrangeJob::finalize(), Slic3r::GUI::Emboss::CreateFontStyleImagesJob::finalize(), Slic3r::BackgroundSlicingProcess::finalize_gcode(), Slic3r::find_installed_plugin_entry(), Slic3r::SlicingProcessCompletedEvent::format_error_message(), get_curr_time(), Slic3r::GUI::FileGet::priv::get_perform(), get_primitive_mode(), Slic3r::Obico::get_printers(), Slic3r::Repetier::get_printers(), Slic3r::PrusaLink::get_storage(), Slic3r::GUI::GLGizmoMmuSegmentation::handle_snapshot_action_name(), Slic3r::GUI::Plater::import_model_id(), Slic3r::GUI::ImGuiWrapper::input_double(), Slic3r::GUI::ImGuiWrapper::input_double(), Slic3r::GUI::ImGuiWrapper::input_optional_float(), Slic3r::GUI::ImGuiWrapper::input_vec3(), Slic3r::plugin_loader::install_plugin(), Slic3r::plugin_hooks::anonymous_namespace{PluginHooks.cpp}::install_slicing_pipeline_hook(), Slic3r::PluginManager::keep_installed_plugin_as_local(), Slic3r::plugin_loader::load(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::Plater::load_gcode(), Slic3r::GUI::HintDatabase::load_hints_from_file(), Slic3r::PluginManager::load_plugin(), Slic3r::PluginManager::load_plugin_impl(), Slic3r::PluginManager::merge_discovered_plugins(), Slic3r::GUI::TextureImportDialog::on_computation_complete(), Slic3r::GUI::GUI_App::on_http_error(), Slic3r::GUI::GUI_App::on_init_inner(), Slic3r::GUI::GLGizmoSimplify::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window(), Slic3r::GUI::Plater::post_process_string_object_exception(), Slic3r::GUI::Plater::preview_zip_archive(), Slic3r::GUI::ArrangeJob::process(), Slic3r::GUI::FillBedJob::process(), Slic3r::GUI::OrientJob::process(), Slic3r::GUI::PrintJob::process(), Slic3r::GUI::SendJob::process(), Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp}::read_local_plugin_package_metadata(), refresh_plugin_metadata_blocking(), Slic3r::NetworkAgentFactory::register_python_printer_agent(), Slic3r::GUI::PluginsDialog::reload_local_plugin(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::GLGizmoCut3D::render_angle_input(), Slic3r::GUI::GLCanvas3D::CenterOfMass::render_details(), Slic3r::GUI::GLGizmoCut3D::render_groove_float_input(), Slic3r::GUI::GLGizmoCut3D::render_groove_int_input(), Slic3r::GUI::GLGizmoCut3D::render_groove_two_float_input(), Slic3r::GUI::GLGizmoTextureDisplacement::render_image_adjust_window(), Slic3r::report_install_failure(), Slic3r::resolve_allowed_plugin_root(), Slic3r::GUI::DesignSketchTool::resolve_live_drag(), Slic3r::resolve_missing_plugins(), Slic3r::GUI::ConfigWizard::priv::select_default_materials_for_printer_models(), anonymous_namespace{GLGizmoSVG.cpp}::select_shape(), Slic3r::GUI::Plater::send_gcode_finish(), anonymous_namespace{3DPrinterOS.cpp}::TokenAuthDialog::SendRequest(), Slic3r::PrusaConnect::set_http_post_header_args(), show_notification_extruders_limit_exceeded(), Slic3r::GUI::ImGuiWrapper::slider_float(), Slic3r::GUI::ImGuiWrapper::slider_float(), Slic3r::GUI::ImGuiWrapper::slider_float(), Slic3r::GUI::ImGuiWrapper::slider_optional_float(), Slic3r::GUI::ImGuiWrapper::slider_optional_int(), Slic3r::GUI::GUI_App::start_sync_user_preset(), Slic3r::GUI::PrintHostSendDialog::storage(), Slic3r::GUI::GUI_App::sync_bundle(), Slic3r::PluginManager::unsubscribe_cloud_plugin(), Slic3r::PluginManager::update_cloud_plugin(), Slic3r::GUI::GUI_App::update_single_bundle(), validate_thumbnails_string(), and wxBEGIN_EVENT_TABLE().

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_compact_weight()

std::string Slic3r::GUI::format_compact_weight ( double value_in_grams, bool imperial_units )

static

{
    char buffer[64];
    if (imperial_units) {
        ::sprintf(buffer, "%.2f oz", value_in_grams / GizmoObjectManipulation::oz_to_g);
        return buffer;
    }
 
    const double abs_value = value_in_grams < 0.0 ? -value_in_grams : value_in_grams;
    const char* unit = "g";
    double scaled_value = abs_value;
    if (scaled_value >= 1000000.0) {
        scaled_value /= 1000000.0;
        unit = "t";
    } else if (scaled_value >= 1000.0) {
        scaled_value /= 1000.0;
        unit = "kg";
    }
 
    ::sprintf(buffer, "%s%.2f%s", value_in_grams < 0.0 ? "-" : "", scaled_value, unit);
    return buffer;
}

References Slic3r::GUI::GizmoObjectManipulation::oz_to_g.

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

Here is the caller graph for this function:

format_nozzle_diameter()

wxString Slic3r::GUI::format_nozzle_diameter

(

float

diameter

)

{
    if (diameter <= 0.0f) {
        return _L("Unknown");
    }
 
    return wxString::Format("%smm", wxString::FromDouble(diameter));
}

References _L.

Referenced by _get_tips(), Slic3r::GUI::PrinterPartsDialog::Show(), and Slic3r::GUI::PrinterPartsDialog::UpdateNozzleInfo().

Here is the caller graph for this function:

format_number()

std::string Slic3r::GUI::format_number ( float value )

static

{
    std::ostringstream oss;
    oss << std::fixed << std::setprecision((static_cast<int>(value * 10) % 10 == 0) ? 0 : 1) << value;
    return oss.str();
}

References format_number().

Referenced by construct_extruder_unprintable_error(), and format_number().

Here is the call graph for this function:

Here is the caller graph for this function:

format_parser_error_html()

std::string Slic3r::GUI::format_parser_error_html ( const std::string & msg )

static

{
    std::string out;
    for (const auto &[text, is_code] : classify_code_lines(msg)) {
        if (!out.empty()) out += "<br>"; // join, not trail; a trailing <br> forces a scrollbar
        std::string escaped = xml_escape(text);
        if (is_code)
            out += "<code><excerpt>" + escaped + "</excerpt></code>";
        else
            out += escaped;
    }
    return out;
}

References classify_code_lines(), and Slic3r::xml_escape().

Referenced by add_msg_content().

Here is the call graph for this function:

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().

Referenced by Slic3r::GUI::EditGCodeDialog::EditGCodeDialog(), Slic3r::IPListDialog::IPListDialog(), RammingPanel::RammingPanel(), Slic3r::GUI::SendSystemInfoDialog::SendSystemInfoDialog(), Slic3r::GUI::Plater::_calib_pa_pattern(), add_config_substitutions(), Slic3r::GUI::UnsavedChangesDialog::build(), Slic3r::GUI::Plater::calib_temp(), change_opt_value(), Slic3r::GUI::GUI_App::check_legacy_user_filament_presets(), check_objects_after_cut(), Slic3r::GUI::GUI_App::check_print_host_queue(), Slic3r::GUI::Tab::delete_preset(), Slic3r::GUI::GLGizmoEmboss::draw_delete_style_button(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), Slic3r::GUI::GLGizmoEmboss::draw_style_list(), file_wildcards(), Slic3r::GUI::ObjectList::fix_through_cgal(), format_wxstr(), Slic3r::UltiMaker::generate_auth_creds(), generic_exception_handle(), Slic3r::PluginConfig::get_config_response(), get_default_name(), Slic3r::GUI::CopyrightsDialog::get_html_text(), Slic3r::GUI::ObjectList::get_mesh_errors_info(), Slic3r::GUI::FileGet::priv::get_perform(), Slic3r::PrusaLink::get_storage(), Slic3r::C3DPrinterOS::get_test_failed_msg(), Slic3r::CrealityPrint::get_test_failed_msg(), Slic3r::ElegooLink::get_test_failed_msg(), Slic3r::Moonraker::get_test_failed_msg(), Slic3r::Obico::get_test_failed_msg(), Slic3r::OctoPrint::get_test_failed_msg(), Slic3r::PrusaConnect::get_test_failed_msg(), Slic3r::PrusaLink::get_test_failed_msg(), Slic3r::SimplyPrint::get_test_failed_msg(), Slic3r::SL1Host::get_test_failed_msg(), Slic3r::C3DPrinterOS::get_test_ok_msg(), Slic3r::GUI::Field::get_value_by_opt_type(), GUI_Run(), highlight(), Slic3r::GUI::EditGCodeDialog::init_params_list(), is_same_nozzle_type(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::Plater::load_gcode(), make_bold(), Slic3r::GUI::Downloader::on_error(), Slic3r::GUI::PrintHostQueueDialog::on_error(), Slic3r::GUI::GUI_App::on_http_error(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::FeedDirectionDialog::OnRadioClicked(), prepare_decompose_mixed_result(), Slic3r::GUI::Plater::preview_zip_archive(), Slic3r::GUI::Sidebar::remove_all_mixed_filaments(), Slic3r::GUI::GLGizmoCut3D::render_input_window_warning(), Slic3r::GUI::GCodeViewer::render_legend_color_arr_recommen(), Slic3r::PluginConfig::restore_config_response(), Slic3r::GUI::Plater::priv::save_project_if_dirty(), Slic3r::GUI::EditGCodeDialog::selection_changed(), Slic3r::GUI::PluginsConfigDialog::send_capability_config(), Slic3r::GUI::PageMaterials::set_compatible_printers_html_window(), Slic3r::GUI::PrinterAgentChoice::set_value(), Slic3r::GUI::UnsavedChangesDialog::show_info_line(), show_substitutions_info(), show_substitutions_info(), Slic3r::Moonraker::test(), Slic3r::OctoPrint::test(), Slic3r::PrusaLink::test(), Slic3r::PrusaLink::test_with_method_check(), Slic3r::GUI::UnsavedChangesDialog::update(), Slic3r::GUI::ColorDecomposeDialog::update_filament_limit_warning(), Slic3r::GUI::SavePresetDialog::update_info_for_edit_ph_printer(), Slic3r::GUI::DiffPresetDialog::update_tree(), Slic3r::ElegooLink::upload(), Slic3r::OctoPrint::upload(), Slic3r::GUI::Tab::validate_custom_gcode(), and validate_thumbnails_string().

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().

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:

frame_time_stats()

FrameTimeStats Slic3r::GUI::frame_time_stats

(

std::vector< double >

frame_ms

)

{
    FrameTimeStats stats;
    if (frame_ms.empty())
        return stats;
 
    std::sort(frame_ms.begin(), frame_ms.end());
    const double total_ms = std::accumulate(frame_ms.begin(), frame_ms.end(), 0.0);
    auto percentile = [&frame_ms](double p) {
        const size_t rank = size_t(std::ceil(p * double(frame_ms.size()) / 100.0));
        return frame_ms[std::clamp<size_t>(rank, 1, frame_ms.size()) - 1];
    };
    stats.fps        = total_ms > 0.0 ? 1000.0 * double(frame_ms.size()) / total_ms : 0.0;
    stats.average_ms = total_ms / double(frame_ms.size());
    stats.median_ms  = percentile(50.0);
    stats.p95_ms     = percentile(95.0);
    stats.p99_ms     = percentile(99.0);
    stats.max_ms     = frame_ms.back();
    return stats;
}

References Slic3r::GUI::FrameTimeStats::average_ms, Slic3r::GUI::FrameTimeStats::fps, Slic3r::GUI::FrameTimeStats::max_ms, Slic3r::GUI::FrameTimeStats::median_ms, Slic3r::GUI::FrameTimeStats::p95_ms, and Slic3r::GUI::FrameTimeStats::p99_ms.

Referenced by Slic3r::GUI::anonymous_namespace{SceneBenchmark.cpp}::SceneBenchmarkDialog::report().

Here is the caller graph for this function:

framed_input()

wxPanel * Slic3r::GUI::framed_input ( wxWindow * parent )

static

{
    wxColour clr(0xDB, 0xDB, 0xDB);
    if (wxGetApp().dark_mode())
        clr = StateColor::darkModeColorFor(clr);
    auto* frame = new wxPanel(parent, wxID_ANY);
    frame->SetBackgroundColour(clr);
    frame->SetSizer(new wxBoxSizer(wxVERTICAL));
    return frame;
}

References StateColor::darkModeColorFor().

Here is the call graph for this function:

free_print_volumes()

std::vector< BoundingBoxf3 > Slic3r::GUI::free_print_volumes ( const BoundingBoxf3 & bed, const std::vector< BoundingBoxf3 > & excludes )

static

{
    std::vector<double> xs{ bed.min.x(), bed.max.x() };
    std::vector<double> ys{ bed.min.y(), bed.max.y() };
    for (const BoundingBoxf3& ex : excludes) {
        for (const double x : { ex.min.x(), ex.max.x() })
            if (x > bed.min.x() && x < bed.max.x())
                xs.push_back(x);
        for (const double y : { ex.min.y(), ex.max.y() })
            if (y > bed.min.y() && y < bed.max.y())
                ys.push_back(y);
    }
    std::sort(xs.begin(), xs.end());
    std::sort(ys.begin(), ys.end());
    xs.erase(std::unique(xs.begin(), xs.end()), xs.end());
    ys.erase(std::unique(ys.begin(), ys.end()), ys.end());
 
    const double min_size = 2. * Slic3r::BuildVolume::SceneEpsilon;
    std::vector<BoundingBoxf3> free_volumes;
    for (size_t i = 0; i < xs.size(); ++i)
    for (size_t j = i + 1; j < xs.size(); ++j)
    for (size_t k = 0; k < ys.size(); ++k)
    for (size_t l = k + 1; l < ys.size(); ++l) {
        const double min_x = xs[i], max_x = xs[j], min_y = ys[k], max_y = ys[l];
        if (max_x - min_x <= min_size || max_y - min_y <= min_size)
            continue;
 
        const bool blocked = std::any_of(excludes.begin(), excludes.end(), [&](const BoundingBoxf3& ex) {
            return min_x < ex.max.x() && max_x > ex.min.x() && min_y < ex.max.y() && max_y > ex.min.y();
        });
        if (blocked)
            continue;
 
        BoundingBoxf3 box = bed;
        box.min.x() = min_x;
        box.min.y() = min_y;
        box.max.x() = max_x;
        box.max.y() = max_y;
        free_volumes.push_back(box);
    }
    return free_volumes;
}

References Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, and Slic3r::BuildVolume::SceneEpsilon.

Referenced by Slic3r::GUI::Plater::priv::scale_selection_to_fit_print_volume().

Here is the caller graph for this function:

free_window()

void Slic3r::GUI::free_window

(

wxWindow *

win

)

{
#if !defined(__WXGTK__)
    unbind_events(win);
    for (auto c : win->GetChildren())
        if (dynamic_cast<wxTextCtrl*>(c))
            unbind_events(c);
    win->Hide();
    if (auto sizer = win->GetContainingSizer())
        sizer->Clear();
    win->Reparent(wxGetApp().mainframe);
    if (win->GetClientData())
        reinterpret_cast<std::deque<wxWindow *>*>(win->GetClientData())->push_back(win);
#else
    delete win;
#endif
}

References unbind_events().

Referenced by Slic3r::GUI::OptionsGroup::clear().

Here is the call graph for this function:

Here is the caller 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 WipingDialog::WipingDialog(), Slic3r::GUI::PrintHostQueueDialog::append_job(), Slic3r::GUI::GUI_App::associate_url(), Slic3r::GUI::GUI_App::check_url_association(), desktop_open_project_attachment(), Slic3r::GUI::Plater::export_3mf(), Slic3r::GUI::Plater::export_gcode(), Slic3r::GUI::Plater::export_gcode_3mf(), file_url_from_path(), Slic3r::GUI::Plater::priv::get_export_file(), Slic3r::GUI::Plater::priv::get_export_gcode_filename(), Slic3r::GUI::Plater::priv::get_project_filename(), Slic3r::GUI::Plater::import_model_id(), Slic3r::GUI::Plater::load_files(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::ObjectList::load_modifier(), Slic3r::GUI::Plater::open_3mf_file(), Slic3r::GUI::HMSQuery::query_image_from_local(), and Slic3r::GUI::SendToPrinterDialog::set_default().

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());
}

Referenced by Slic3r::GUI::AboutDialog::AboutDialog(), Slic3r::GUI::CopyrightsDialog::CopyrightsDialog(), Slic3r::GUI::EditCalibrationHistoryDialog::EditCalibrationHistoryDialog(), Slic3r::GUI::InputIpAddressDialog::InputIpAddressDialog(), Slic3r::GUI::SavePresetDialog::Item::Item(), Slic3r::GUI::MediaPlayCtrl::MediaPlayCtrl(), Slic3r::GUI::MsgUpdateConfig::MsgUpdateConfig(), Slic3r::GUI::MsgUpdateForced::MsgUpdateForced(), Slic3r::GUI::NetworkTestDialog::NetworkTestDialog(), Slic3r::GUI::PagePrinters::PagePrinters(), Slic3r::GUI::PageWelcome::PageWelcome(), Slic3r::GUI::ParamsNode::ParamsNode(), Slic3r::GUI::PhysicalPrinterDialog::PhysicalPrinterDialog(), Slic3r::GUI::PrinterPicker::PrinterPicker(), Slic3r::GUI::PrivacyUpdateDialog::PrivacyUpdateDialog(), Slic3r::GUI::ProjectDropDialog::ProjectDropDialog(), Slic3r::GUI::SLAImportDialog::SLAImportDialog(), Slic3r::GUI::SyncAmsInfoDialog::SyncAmsInfoDialog(), add_config_substitutions(), Slic3r::GUI::PresetComboBox::add_connected_printers(), Slic3r::GUI::Plater::add_file(), Slic3r::GUI::SavePresetDialog::add_info_for_edit_ph_printer(), Slic3r::GUI::Plater::add_model(), Slic3r::GUI::ObjectList::add_object_to_list(), Slic3r::GUI::IMEXModesCtrl::add_row(), Slic3r::GUI::ObjectList::add_volumes_to_object_in_list(), Slic3r::GUI::MultiSendMachineModel::AddMachine(), Slic3r::GUI::ObjectDataViewModel::AddObject(), Slic3r::GUI::ObjectDataViewModel::AddPlate(), Slic3r::GUI::DataList< wxListBox, std::string >::append(), Slic3r::GUI::OptionsGroup::append_line(), Slic3r::GUI::MenuFactory::append_menu_item_change_extruder(), Slic3r::GUI::MenuFactory::append_menu_item_change_filament(), Slic3r::GUI::MenuFactory::append_menu_item_clone(), apply_extruder_selector(), Slic3r::GUI::StaticText::BUILD(), Slic3r::GUI::UnsavedChangesDialog::build(), Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), Slic3r::GUI::PublishSettingsDialog::build_option_model(), Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings(), Slic3r::GUI::PluginPickerDialog::build_ui(), Slic3r::GUI::ConfigManipulation::check_adaptive_pressure_advance_model(), Slic3r::GUI::ConfigWizard::priv::check_and_install_missing_materials(), Slic3r::GUI::CalibrationPresetPage::check_filament_compatible(), Slic3r::GUI::GUI_App::check_legacy_user_filament_presets(), check_objects_after_cut(), cloud_page_url(), Slic3r::GUI::GUI_App::cloud_webview_handoff(), color_string(), copy_file_gui(), Slic3r::GUI::NotificationManager::PopNotification::count_lines(), create_combochecklist(), Slic3r::GUI::CreateFilamentPresetDialog::create_dialog_buttons(), Slic3r::GUI::CreatePresetForPrinterDialog::create_dialog_buttons(), Slic3r::GUI::MenuFactory::create_filament_action_menu(), Slic3r::GUI::EditFilamentPresetDialog::create_filament_basic_info(), Slic3r::GUI::PreferencesDialog::create_items(), Slic3r::GUI::CreatePrinterPresetDialog::create_page2_dialog_buttons(), Slic3r::GUI::CreatePresetForPrinterDialog::create_selected_printer_preset_sizer(), Slic3r::GUI::OptionsGroup::create_single_option_line(), custom_gcode_group_title(), Slic3r::GUI::PluginsDialog::delete_local_plugin(), Slic3r::GUI::EditFilamentPresetDialog::delete_preset(), desktop_open_any_folder(), desktop_open_datadir_folder(), Slic3r::GUI::PluginField::display_name_for_value(), Slic3r::GUI::GizmoObjectManipulation::do_render_move_window(), Slic3r::GUI::MachineObjectPanel::doRender(), Slic3r::GUI::MObjectPanel::doRender(), Slic3r::GUI::MultiMachineItem::doRender(), Slic3r::GUI::GLGizmoSVG::draw_filename(), Slic3r::ElegooLink::elegoo_cc2_test(), Slic3r::ElegooLink::elegoo_test(), Slic3r::anonymous_namespace{PluginHostApp.cpp}::export_3mf_copy(), Slic3r::GUI::MainFrame::export_config(), Slic3r::GUI::Plater::export_stl(), Slic3r::GUI::KBShortcutsDialog::fill_pages(), Slic3r::GUI::PlaterWorker< WorkerSubclass >::PlaterJob::finalize(), Slic3r::GUI::IMEXModesCtrl::fix_row_name(), Slic3r::GUI::ObjectList::fix_through_cgal(), Slic3r::SlicingProcessCompletedEvent::format_error_message(), from_path(), Slic3r::GUI::GLTexture::generate_from_text(), Slic3r::GUI::PartPlate::generate_plate_name_texture(), Slic3r::GUI::PresetTree::get_child_item(), Slic3r::PluginConfig::get_config_response(), Slic3r::GUI::ConfigOptionsGroup::get_config_value(), Slic3r::GUI::ConfigOptionsGroup::get_config_value2(), get_default_name(), get_error_message(), Slic3r::GUI::Plater::priv::get_export_file(), Slic3r::GUI::Plater::priv::get_export_gcode_filename(), Slic3r::GUI::CreateFilamentPresetDialog::get_filament_preset_choices(), get_formatted_tooltip_text(), Slic3r::Repetier::get_groups(), Slic3r::GUI::PrintJob::get_http_error_msg(), Slic3r::GUI::SendJob::get_http_error_msg(), Slic3r::GUI::GUI_App::get_login_info(), Slic3r::GUI::FileGet::priv::get_perform(), Slic3r::GUI::PresetComboBox::get_preset_item_name(), Slic3r::GUI::PlaterPresetComboBox::get_preset_name(), Slic3r::GUI::PresetComboBox::get_preset_name(), Slic3r::GUI::TabPresetComboBox::get_preset_name(), get_preset_name_by_filament_id(), Slic3r::Obico::get_printers(), Slic3r::Repetier::get_printers(), Slic3r::GUI::PresetTree::get_root_item(), get_string_from_enum(), get_string_value(), Slic3r::AstroBox::get_test_failed_msg(), Slic3r::Duet::get_test_failed_msg(), Slic3r::ESP3D::get_test_failed_msg(), Slic3r::FlashAir::get_test_failed_msg(), Slic3r::Flashforge::get_test_failed_msg(), Slic3r::MKS::get_test_failed_msg(), Slic3r::Repetier::get_test_failed_msg(), Slic3r::UltiMaker::get_test_failed_msg(), Slic3r::GUI::PresetComboBox::get_tooltip(), Slic3r::GUI::OptionsGroup::get_url(), Slic3r::GUI::Field::get_value_by_opt_type(), Slic3r::GUI::ObjectGridTable::GetValue(), Slic3r::GUI::anonymous_namespace{KBShortcutsDialog.cpp}::global_key_advice(), Slic3r::GUI::PluginsConfigDialog::handle_web_command(), Slic3r::GUI::GUI_App::handle_web_request(), Slic3r::GUI::GUI_App::import_model(), Slic3r::GUI::Plater::import_model_id(), import_texture_to_library(), Slic3r::GUI::GUI_App::import_zip(), Slic3r::GUI::ElegooPrintHostSendDialog::init(), Slic3r::GUI::FlashforgePrintHostSendDialog::init(), Slic3r::GUI::PrintHostSendDialog::init(), Slic3r::GUI::OpenGLManager::init_gl(), Slic3r::GUI::MainFrame::init_menubar_as_editor(), Slic3r::GUI::PluginsDialog::install_cloud_plugin(), install_local_plugin_package(), Slic3r::GUI::Plater::install_missing_cloud_plugins(), Slic3r::GUI::MainFrame::load_config_file(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::GUI_App::load_language(), Slic3r::GUI::BitmapCache::load_png(), Slic3r::GUI::MainFrame::load_printer_url(), load_texture_image_data(), Slic3r::GUI::GuideFrame::LoadProfileData(), Slic3r::GUI::MarkdownTip::LoadTip(), make_string_bold(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::material_title(), Slic3r::GUI::GUI_App::maybe_migrate_user_presets_on_login(), Slic3r::GUI::ImageGrid::mouseMoved(), Slic3r::GUI::Choice::msw_rescale(), Slic3r::GUI::GUI_App::on_cloud_web_session_minted(), Slic3r::GUI::EditDevNameDialog::on_edit_name(), Slic3r::GUI::GUI_App::on_init_inner(), Slic3r::GUI::AuFile::on_input_enter(), Slic3r::GUI::SelectMachineDialog::on_rename_enter(), Slic3r::GUI::SendMultiMachinePage::on_rename_enter(), Slic3r::GUI::SendToPrinterDialog::on_rename_enter(), Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window(), Slic3r::BonjourDialog::on_reply(), Slic3r::GUI::AMSMaterialsSetting::on_select_filament(), Slic3r::GUI::BindMachineDialog::on_show(), Slic3r::GUI::UnBindMachineDialog::on_show(), Slic3r::GUI::Plater::priv::on_tab_selection_changing(), Slic3r::GUI::ObjectList::OnStartEditing(), Slic3r::GUI::anonymous_namespace{Downloader.cpp}::open_folder(), Slic3r::GUI::anonymous_namespace{NotificationManager.cpp}::open_folder(), Slic3r::open_missing_plugins_on_cloud(), Slic3r::GUI::Plater::open_platesettings_dialog(), Slic3r::GUI::GUI_App::open_plugins_dialog(), Slic3r::GUI::SpeedDialWebDialog::open_wiki(), Slic3r::GUI::anonymous_namespace{PrintHostDialogs.cpp}::FlashforgeSlotCard::parse_color(), Slic3r::PresetUpdater::priv::parse_version_string(), Slic3r::GUI::GLGizmoCut3D::perform_cut(), Slic3r::GUI::OptionsGroup::pick_plugin(), Slic3r::GUI::MediaPlayCtrl::Play(), Slic3r::GUI::PluginsDialog::plugin_display_name(), Slic3r::GUI::AMSMaterialsSetting::Popup(), Slic3r::GUI::GUI_App::post_init(), Slic3r::GUI::MainFrame::preview_only_hint(), Slic3r::GUI::Plater::preview_zip_archive(), Slic3r::GUI::CreatePrinterPresetDialog::printer_preset_sort_with_nozzle_diameter(), Slic3r::GUI::SendJob::process(), Slic3r::GUI::GLGizmoTextureDisplacement::push_uv_pane_state(), Slic3r::GUI::FlashforgePrintHostSendDialog::rebuild_mapping_rows(), Slic3r::GUI::GUI_App::refresh_plugins(), Slic3r::GUI::PluginsDialog::reinstall_cloud_plugin(), Slic3r::GUI::Plater::priv::reload_from_disk(), Slic3r::GUI::PrinterAgentChoice::reload_rows(), Slic3r::GUI::GLGizmoCut3D::render_angle_input(), Slic3r::GUI::GLGizmoTextureDisplacement::render_debug_stage_panel(), Slic3r::GUI::GCodeViewer::render_legend_color_arr_recommen(), Slic3r::GUI::GLGizmoTextureDisplacement::render_texture_library_popup(), Slic3r::GUI::ImageGrid::renderContent2(), Slic3r::GUI::Plater::priv::replace_all_with_stl(), Slic3r::GUI::Plater::priv::replace_volume_with_stl(), Slic3r::GUI::Plater::priv::replace_with_stl(), Slic3r::GUI::GUI_App::request_new_version(), Slic3r::GUI::GUI_App::request_user_logout(), Slic3r::GUI::PluginsDialog::restore_capability_config(), Slic3r::PluginConfig::restore_config_response(), Slic3r::GUI::SpeedDialWebDialog::run_action(), Slic3r::GUI::PluginsDialog::run_script_plugin_capability(), Slic3r::GUI::Plater::priv::save_project_if_dirty(), Slic3r::GUI::anonymous_namespace{ActionRegistry.cpp}::script_outcome_to_action_result(), Slic3r::GUI::Plater::select_plate_by_hover_id(), Slic3r::GUI::PluginsConfigDialog::send_capability_config(), Slic3r::GUI::SideToolsPanel::set_current_printer_name(), Slic3r::GUI::CreatePrinterPresetDialog::set_current_visible_printer(), Slic3r::GUI::SelectMachineDialog::set_default(), Slic3r::GUI::SendMultiMachinePage::set_default(), Slic3r::GUI::SendToPrinterDialog::set_default(), Slic3r::GUI::SyncAmsInfoDialog::set_default(), Slic3r::GUI::EditDevNameDialog::set_machine_obj(), Slic3r::GUI::Plater::priv::set_project_filename(), Slic3r::GUI::anonymous_namespace{PrintHostDialogs.cpp}::FlashforgeSlotCard::set_slot(), Slic3r::GUI::ObjectDataViewModel::SetCurSelectedPlateFullName(), Slic3r::GUI::MediaPlayCtrl::SetMachineObject(), Slic3r::GUI::ExtruderGroup::SetRowDiameters(), Slic3r::GUI::anonymous_namespace{ActionRegistry.cpp}::setting_text(), Slic3r::GUI::FilamentPickerDialog::SetupLabelsContent(), Slic3r::GUI::MainFrame::shortcut_label(), Slic3r::GUI::BoostThreadWorker::show_error_info(), Slic3r::GUI::anonymous_namespace{SceneBenchmark.cpp}::SceneBenchmarkDialog::show_report(), show_substitutions_info(), Slic3r::GUI::PageMaterials::sort_list_data(), Slic3r::GUI::ObjectList::split(), start_new_gcodeviewer_open_file(), Slic3r::GUI::IMEXModesCtrl::suggested_mode_names(), Slic3r::GUI::Sidebar::sync_ams_list(), Slic3r::GUI::CaliPASaveAutoPanel::sync_cali_result(), Slic3r::GUI::CaliPASaveAutoPanel::sync_cali_result_for_multi_extruder(), Slic3r::GUI::HistoryWindow::sync_history_data(), Slic3r::GUI::Config::take_config_snapshot_cancel_on_error(), Slic3r::GUI::Config::take_config_snapshot_report_error(), Slic3r::AstroBox::test(), Slic3r::CrealityPrint::test(), Slic3r::Obico::test(), Slic3r::OctoPrint::test(), Slic3r::PrusaLink::test(), Slic3r::Repetier::test(), Slic3r::UltiMaker::test(), Slic3r::PrusaLink::test_with_method_check(), Slic3r::GUI::anonymous_namespace{KBShortcutsDialog.cpp}::to_wx(), Slic3r::GUI::PluginsDialog::toggle_plugin(), Slic3r::GUI::PluginsDialog::toggle_plugin_capability(), Slic3r::GUI::MediaPlayCtrl::ToggleStream(), Slic3r::GUI::PluginsDialog::unsubscribe_cloud_plugin(), Slic3r::GUI::MachineInfoPanel::update(), Slic3r::GUI::PlaterPresetComboBox::update(), Slic3r::GUI::SavePresetDialog::Item::update(), Slic3r::GUI::TabPresetComboBox::update(), Slic3r::GUI::Sidebar::update_all_preset_comboboxes(), Slic3r::GUI::PluginPickerDialog::update_description(), Slic3r::GUI::TabPresetComboBox::update_dirty(), Slic3r::GUI::UpdatePluginDialog::update_info(), Slic3r::GUI::Sidebar::update_mixed_filament_list(), Slic3r::GUI::ObjectList::update_name_in_list(), Slic3r::GUI::PluginsDialog::update_plugin(), Slic3r::GUI::PhysicalPrinterDialog::update_preset_input(), Slic3r::GUI::PhysicalPrinterDialog::update_printers(), Slic3r::GUI::ObjectSettings::update_settings_list(), Slic3r::GUI::ObjectTableSettings::update_settings_list(), Slic3r::GUI::CalibrationCaliPage::update_subtask(), Slic3r::GUI::StatusPanel::update_subtask(), Slic3r::GUI::DiffPresetDialog::update_tree(), Slic3r::GUI::UnsavedChangesDialog::update_tree(), Slic3r::GUI::UnsavedChangesDialog::update_tree(), Slic3r::GUI::SendToPrinterDialog::update_user_printer(), Slic3r::GUI::SyncAmsInfoDialog::update_user_printer(), Slic3r::GUI::ModelNode::UpdateEnabling(), Slic3r::GUI::ObjectDataViewModel::UpdateItemNames(), Slic3r::anonymous_namespace{Flashforge.cpp}::validate_local_api_response(), Slic3r::GUI::Plater::priv::warnings_dialog(), and Slic3r::wxDEFINE_EVENT().

gcode()

std::string Slic3r::GUI::gcode ( Type type )

static

{
    Slic3r::DynamicPrintConfig config = wxGetApp().preset_bundle->full_config();
    switch (type) {
    //BBS
    case Template:    return config.opt_string("template_custom_gcode");
    case PausePrint:  return config.opt_string("machine_pause_gcode");
 
    default:          return "";
    }
 
    //const PrintConfig& config = GUI::wxGetApp().plater()->fff_print().config();
    //switch (type) {
    //case PausePrint:  return config.machine_pause_gcode;
    //case Template:    return config.template_custom_gcode;
    //default:          return "";
    //}
}

References Slic3r::DynamicConfig::opt_string(), Slic3r::CustomGCode::PausePrint, and Slic3r::CustomGCode::Template.

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern_gen_gcode(), Slic3r::GUI::IMSlider::add_code_as_tick(), Slic3r::GUI::IMEXModesCtrl::add_row(), Slic3r::GUI::PartPlateList::clear(), Slic3r::GUI::PartPlateList::create_plate(), Slic3r::GUI::PartPlateList::init(), Slic3r::GUI::PartPlateList::rebuild_plates_after_deserialize(), Slic3r::GUI::IMSlider::render_add_menu(), Slic3r::GUI::IMSlider::render_edit_menu(), Slic3r::GUI::IMSlider::show_tooltip(), and Slic3r::GUI::Tab::validate_custom_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_image()

bool Slic3r::GUI::generate_image	(	const std::string &	filename,
		wxImage &	image,
		wxSize	img_size,
		int	method )

{
    wxInitAllImageHandlers();
 
    bool    result = true;
    wxImage img;
    result = load_image(filename, img);
    if (!result) return result;
 
    image = wxImage(img_size);
    image.SetType(wxBITMAP_TYPE_PNG);
    if (!image.HasAlpha()) {
        image.InitAlpha();
    }
 
    //image.Clear(0);
    //unsigned char *alpha = image.GetAlpha();
    unsigned char* alpha = new unsigned char[image.GetWidth() *  image.GetHeight()];
    if (alpha) { ::memset(alpha, wxIMAGE_ALPHA_TRANSPARENT, image.GetWidth() * image.GetHeight()); }
    if (method == GERNERATE_IMAGE_RESIZE) {
        float h_factor   = img.GetHeight() / (float) image.GetHeight();
        float w_factor   = img.GetWidth() / (float) image.GetWidth();
        float factor     = std::min(h_factor, w_factor);
        int   tar_height = (int) ((float) img.GetHeight() / factor);
        int   tar_width  = (int) ((float) img.GetWidth() / factor);
        img              = img.Rescale(tar_width, tar_height);
        image.Paste(img, (image.GetWidth() - tar_width) / 2, (image.GetHeight() - tar_height) / 2);
    } else if (method == GERNERATE_IMAGE_CROP_VERTICAL) {
        float w_factor   = img.GetWidth() / (float) image.GetWidth();
        int   tar_height = (int) ((float) img.GetHeight() / w_factor);
        int   tar_width  = (int) ((float) img.GetWidth() / w_factor);
        img              = img.Rescale(tar_width, tar_height);
        image.Paste(img, (image.GetWidth() - tar_width) / 2, (image.GetHeight() - tar_height) / 2);
    } else {
        return false;
    }
 
    //image.ConvertAlphaToMask(image.GetMaskRed(), image.GetMaskGreen(), image.GetMaskBlue());
    return true;
}

References GERNERATE_IMAGE_CROP_VERTICAL, GERNERATE_IMAGE_RESIZE, and load_image().

Referenced by Slic3r::GUI::AuFile::on_set_cover().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_max_speed_parameter_value()

std::vector< double > Slic3r::GUI::generate_max_speed_parameter_value	(	const std::string &	key,
		const float	line_width,
		const float	layer_height,
		const bool	linear,
		const int	pass )

{
    auto  preset_bundle   = wxGetApp().preset_bundle;
    auto &printer_config  = preset_bundle->printers.get_edited_preset().config;
    auto &filament_config = preset_bundle->filaments.get_edited_preset().config;
    auto &print_config    = preset_bundle->prints.get_edited_preset().config;
 
    int              extruder_nums       = preset_bundle->get_printer_extruder_count();
    std::vector<int> extruder_types      = printer_config.option<ConfigOptionEnumsGeneric>("extruder_type")->values;
    std::vector<int> nozzle_volume_types = preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type")->values;
 
    float nozzle_diameter = printer_config.option<ConfigOptionFloats>("nozzle_diameter")->values[0];
 
    Flow flow = Flow(line_width, layer_height, nozzle_diameter);
 
    std::vector<double> speed_values;
    speed_values.reserve(extruder_nums * nozzle_volume_types.size());
 
    for (size_t i = 0; i < extruder_nums; ++i) {
        int    index                         = get_index_for_extruder_parameter(filament_config, "filament_max_volumetric_speed", i, ExtruderType(extruder_types[i]),
                                                                                NozzleVolumeType(nozzle_volume_types[i]));
        double filament_max_volumetric_speed = filament_config.option<ConfigOptionFloats>("filament_max_volumetric_speed")->get_at(index);
        double cur_flowrate                  = filament_config.option<ConfigOptionFloats>("filament_flow_ratio")->get_at(index);
        double max_speed                     = linear ? filament_max_volumetric_speed / (flow.mm3_per_mm() * (cur_flowrate + (pass == 2 ? 0.035 : 0.05)) / cur_flowrate) :
                                                        filament_max_volumetric_speed / (flow.mm3_per_mm() * (pass == 1 ? 1.2 : 1));
 
        index = get_index_for_extruder_parameter(print_config, key, i, ExtruderType(extruder_types[i]), NozzleVolumeType(nozzle_volume_types[i]));
        ConfigOptionFloatsNullable *speed_opt = print_config.option<ConfigOptionFloatsNullable>(key);
        double speed_value = std::floor(std::min(speed_opt->values[index], max_speed));
        for (size_t v_id = 0; v_id < nozzle_volume_types.size(); ++v_id) {
            speed_values.emplace_back(speed_value);
        }
    }
    return speed_values;
}

References Slic3r::get_index_for_extruder_parameter(), layer_height, Slic3r::nozzle_diameter(), printer_config(), and Slic3r::ConfigOptionVector< double >::values.

Referenced by adjust_settings_for_flowrate_calib().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_system_info_json()

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("OrcaSlicerVersion", 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));
#ifdef __WXGTK__
    const LinuxDisplayBackend display_backend = get_linux_display_backend();
    const char* display_backend_name = "unknown";
    const char* gl_backend_hint = "Unknown";
    switch (display_backend) {
    case LinuxDisplayBackend::Wayland:
        display_backend_name = "wayland";
        gl_backend_hint = "EGL";
        break;
    case LinuxDisplayBackend::X11:
        display_backend_name = "x11";
        gl_backend_hint = "GLX";
        break;
    default:
        break;
    }
    data_node.put("Linux_DisplayBackend", display_backend_name);
    data_node.put("Linux_GLBackendHint", gl_backend_hint);
#else
    data_node.put("Linux_DisplayBackend", "unknown");
    data_node.put("Linux_GLBackendHint", "Unknown");
#endif
#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().current_language_code_safe());
 
 
    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)
            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 = into_u8(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());
    opengl_node.put("GLSLVersion", OpenGLManager::get_gl_info().get_glsl_version());
    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:
    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);
    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(), get_unique_id(), get_version(), GL_EXTENSIONS, gl_get_string_safe(), into_u8(), parse_lscpu_etc(), Slic3r::platform(), Slic3r::platform_flavor(), Slic3r::platform_flavor_to_string(), Slic3r::platform_to_string(), and Slic3r::total_physical_memory().

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

Here is the call graph for this function:

Here is the caller graph for this function:

generic_exception_handle()

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
/*#ifdef WIN32
    //LPEXCEPTION_POINTERS exception_pointers = nullptr;
    __try {
        throw;
    }
    __except (CBaseException::UnhandledExceptionFilter2(GetExceptionInformation()), EXCEPTION_EXECUTE_HANDLER) {
    //__except (exception_pointers = GetExceptionInformation(), EXCEPTION_EXECUTE_HANDLER) {
    //    if (exception_pointers) {
    //        CBaseException::UnhandledExceptionFilter(exception_pointers);
    //    }
    //    else
            throw;
    }
#else*/
    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.
        BOOST_LOG_TRIVIAL(error) << boost::format("std::bad_alloc exception: %1%") % ex.what();
        flush_logs();
        wxString errmsg = wxString::Format(_L("OrcaSlicer will terminate because of running out of memory. "
                                              "It may be a bug. It will be appreciated if you report the issue to our team."));
        wxMessageBox(errmsg + "\n\n" + wxString(ex.what()), _L("Fatal error"), wxOK | wxICON_ERROR);
 
        std::terminate();
        //throw;
     } catch (const boost::io::bad_format_string& ex) {
      BOOST_LOG_TRIVIAL(error) << boost::format("Uncaught exception: %1%") % ex.what();
          flush_logs();
        wxString errmsg = _L("OrcaSlicer will terminate because of a localization error. "
                             "It will be appreciated if you report the specific scenario this issue happened.");
        wxMessageBox(errmsg + "\n\n" + wxString(ex.what()), _L("Critical error"), wxOK | wxICON_ERROR);
        std::terminate();
        //throw;
    } catch (const std::exception& ex) {
        BOOST_LOG_TRIVIAL(error) << boost::format("Uncaught exception: %1%") % ex.what();
        flush_logs();
        wxLogError(format_wxstr(_L("OrcaSlicer got an unhandled exception: %1%"), ex.what()));
        throw;
    }
//#endif
}

References _L, Slic3r::flush_logs(), 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_all_camera_view_type()

wxArrayString Slic3r::GUI::get_all_camera_view_type

(

)

                                         {
    wxArrayString all_types;
    for (size_t i = 0; i < (int)Camera::ViewAngleType::Count_ViewAngleType; i++) {
        all_types.Add(get_view_type_string((Camera::ViewAngleType) i));
    }
    return all_types;
}

References Slic3r::GUI::Camera::Count_ViewAngleType, and get_view_type_string().

Here is the call graph for this function:

get_app_config()

AppConfig * Slic3r::GUI::get_app_config

(

)

{
    return wxGetApp().app_config;
}

Referenced by Slic3r::GUI::MultiMachinePickPage::MultiMachinePickPage(), Slic3r::GUI::SendMultiMachinePage::SendMultiMachinePage(), Slic3r::GUI::PreferencesDialog::create(), Slic3r::GUI::PresetBundleDialog::create(), Slic3r::GUI::OpenGLManager::create_wxglcanvas(), Slic3r::ElegooLink::get_print_host_webui(), Slic3r::GUI::ConnectPrinterDialog::init_bitmap(), Slic3r::GUI::GCodeViewer::load_as_gcode(), Slic3r::anonymous_namespace{ElegooLink.cpp}::load_sn_from_config(), Slic3r::anonymous_namespace{ElegooLink.cpp}::persist_sn(), Slic3r::GUI::Plater::send_gcode(), Slic3r::GUI::Plater::send_gcode_legacy(), Slic3r::ElegooLink::upload(), Slic3r::OctoPrint::upload(), Slic3r::ElegooLink::upload_inner_with_host(), Slic3r::OctoPrint::upload_inner_with_host(), and Slic3r::PrusaLink::upload_inner_with_host().

Here is the caller graph for this function:

get_applied_map()

std::vector< int > Slic3r::GUI::get_applied_map ( DynamicConfig & proj_config, const Plater * plater_ref, const PartPlate * partplate_ref, const bool sync_plate )

static

{
    if (sync_plate)
        return partplate_ref->get_real_filament_maps(proj_config);
    return plater_ref->get_global_filament_map();
}

References Slic3r::GUI::Plater::get_global_filament_map(), and Slic3r::GUI::PartPlate::get_real_filament_maps().

Referenced by try_pop_up_before_slice().

Here is the call graph for this function:

Here is the caller graph for this function:

get_applied_map_mode()

FilamentMapMode Slic3r::GUI::get_applied_map_mode ( DynamicConfig & proj_config, const Plater * plater_ref, const PartPlate * partplate_ref, const bool sync_plate )

static

{
    if (sync_plate)
        return partplate_ref->get_real_filament_map_mode(proj_config);
    return plater_ref->get_global_filament_map_mode();
}

References Slic3r::GUI::Plater::get_global_filament_map_mode(), and Slic3r::GUI::PartPlate::get_real_filament_map_mode().

Referenced by try_pop_up_before_slice().

Here is the call graph for this function:

Here is the caller graph for this function:

get_applied_volume_map()

std::vector< int > Slic3r::GUI::get_applied_volume_map ( DynamicConfig & proj_config, const Plater * plater_ref, const PartPlate * partplate_ref, const bool sync_plate )

static

{
    if (sync_plate)
        return partplate_ref->get_real_filament_volume_maps(proj_config);
    return plater_ref->get_global_filament_volume_map();
}

References Slic3r::GUI::Plater::get_global_filament_volume_map(), and Slic3r::GUI::PartPlate::get_real_filament_volume_maps().

Referenced by try_pop_up_before_slice().

Here is the call graph for this function:

Here is the caller graph for this function:

get_bitmap_size()

wxSize Slic3r::GUI::get_bitmap_size ( const wxBitmap & bmp )

static

{
#ifdef __APPLE__
    return bmp.GetScaledSize();
#else
    return bmp.GetSize();
#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::msw_rescale(), and Slic3r::GUI::OG_CustomCtrl::CtrlLine::render().

Here is the caller graph for this function:

get_brightness_value()

int Slic3r::GUI::get_brightness_value ( wxImage image )

static

                                               {
 
    wxImage grayImage = image.ConvertToGreyscale();
 
    int width = grayImage.GetWidth();
    int height = grayImage.GetHeight();
 
    int totalLuminance = 0;
    unsigned char alpha;
    int num_none_transparent = 0;
    for (int y = 0; y < height; y += 2) {
 
        for (int x = 0; x < width; x += 2) {
 
            alpha = image.GetAlpha(x, y);
            if (alpha != 0) {
                wxColour pixelColor = grayImage.GetRed(x, y);
                totalLuminance += pixelColor.Red();
                num_none_transparent = num_none_transparent + 1;
            }
        }
    }
    if (totalLuminance <= 0 || num_none_transparent <= 0) {
        return 0;
    }
    return totalLuminance / num_none_transparent;
}

Referenced by Slic3r::GUI::StatusPanel::load_thumbnail_from_url(), Slic3r::GUI::StatusPanel::on_webrequest_state(), and Slic3r::GUI::ThumbnailPanel::set_thumbnail().

Here is the caller graph for this function:

get_cached_selected_filament()

std::map< int, Preset * > Slic3r::GUI::get_cached_selected_filament

(

MachineObject *

obj

)

                                                                      {
    std::map<int, Preset*> selected_filament_map;
    if (!obj) return selected_filament_map;
 
    PresetCollection* filament_presets = &wxGetApp().preset_bundle->filaments;
    for (auto selected_prest : obj->selected_cali_preset) {
        Preset* preset = filament_presets->find_preset(selected_prest.name);
        if (!preset)
            continue;
 
        selected_filament_map.emplace(std::make_pair(selected_prest.tray_id, preset));
    }
    return selected_filament_map;
}

References Slic3r::PresetCollection::find_preset(), and Slic3r::MachineObject::selected_cali_preset.

Referenced by Slic3r::GUI::FlowRateWizard::on_cali_save(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_save(), Slic3r::GUI::PressureAdvanceWizard::on_cali_save(), and Slic3r::GUI::FlowRateWizard::on_cali_start().

Here is the call graph for this function:

Here is the caller graph for this function:

get_cached_selected_filament_for_multi_extruder()

std::map< int, TrayInfo > Slic3r::GUI::get_cached_selected_filament_for_multi_extruder

(

MachineObject *

obj

)

{
    std::map<int, TrayInfo> selected_filament_map;
    if (!obj)
        return selected_filament_map;
 
    PresetCollection *filament_presets = &wxGetApp().preset_bundle->filaments;
    for (auto selected_prest : obj->selected_cali_preset) {
        TrayInfo tray_info;
        tray_info.preset = filament_presets->find_preset(selected_prest.name);
        if (!tray_info.preset)
            continue;
 
        tray_info.extruder_id = selected_prest.extruder_id;
        tray_info.nozzle_volume_type = selected_prest.nozzle_volume_type;
        selected_filament_map.emplace(std::make_pair(selected_prest.tray_id, tray_info));
    }
    return selected_filament_map;
}

References Slic3r::GUI::TrayInfo::extruder_id, Slic3r::PresetCollection::find_preset(), Slic3r::GUI::TrayInfo::nozzle_volume_type, Slic3r::GUI::TrayInfo::preset, and Slic3r::MachineObject::selected_cali_preset.

Referenced by Slic3r::GUI::FlowRateWizard::generate_index_key_value(), Slic3r::GUI::FlowRateWizard::on_cali_save(), and Slic3r::GUI::FlowRateWizard::on_cali_start().

Here is the call graph for this function:

Here is the caller graph for this function:

get_cali_filament_mode()

CalibrationFilamentMode Slic3r::GUI::get_cali_filament_mode	(	MachineObject *	obj,
		CalibMode	mode )

{
    // default 
    if (!obj) return CalibrationFilamentMode::CALI_MODEL_SINGLE;
 
 
    if (mode == CalibMode::Calib_PA_Line) {
        if (obj->get_printer_series() == PrinterSeries::SERIES_X1)
            return CalibrationFilamentMode::CALI_MODEL_MULITI;
        else if (obj->get_printer_series() == PrinterSeries::SERIES_P1P)
            return CalibrationFilamentMode::CALI_MODEL_SINGLE;
    }
    else if (mode == CalibMode::Calib_Flow_Rate) {
        if (obj->get_printer_series() == PrinterSeries::SERIES_X1)
            return CalibrationFilamentMode::CALI_MODEL_SINGLE;
        else if (obj->get_printer_series() == PrinterSeries::SERIES_P1P)
            return CalibrationFilamentMode::CALI_MODEL_SINGLE;
    }
 
    return CalibrationFilamentMode::CALI_MODEL_SINGLE;
}

References CALI_MODEL_MULITI, CALI_MODEL_SINGLE, Slic3r::Calib_Flow_Rate, Slic3r::Calib_PA_Line, Slic3r::MachineObject::get_printer_series(), SERIES_P1P, and SERIES_X1.

Referenced by Slic3r::GUI::FlowRateWizard::on_cali_action(), and Slic3r::GUI::PressureAdvanceWizard::on_cali_action().

Here is the call graph for this function:

Here is the caller graph for this function:

get_cali_mode_caption_string()

wxString Slic3r::GUI::get_cali_mode_caption_string

(

CalibMode

mode

)

{
    if (mode == CalibMode::Calib_PA_Line)
        return _L("Flow Dynamics Calibration");
    if (mode == CalibMode::Calib_Flow_Rate)
        return _L("Flow Rate Calibration");
    if (mode == CalibMode::Calib_Vol_speed_Tower)
        return _L("Max Volumetric Speed Calibration");
    return "no cali_mode_caption";
}

References _L, Slic3r::Calib_Flow_Rate, Slic3r::Calib_PA_Line, and Slic3r::Calib_Vol_speed_Tower.

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

Here is the caller graph for this function:

get_cali_style()

CalibrationStyle Slic3r::GUI::get_cali_style

(

MachineObject *

obj

)

{
    if (!obj) return CalibrationStyle::CALI_STYLE_DEFAULT;
 
    if (obj->get_printer_series() == PrinterSeries::SERIES_X1)
        return CalibrationStyle::CALI_STYLE_X1;
    else if (obj->get_printer_series() == PrinterSeries::SERIES_P1P)
        return CalibrationStyle::CALI_STYLE_P1P;
 
    return CalibrationStyle::CALI_STYLE_DEFAULT;
}

References CALI_STYLE_DEFAULT, CALI_STYLE_P1P, CALI_STYLE_X1, Slic3r::MachineObject::get_printer_series(), SERIES_P1P, and SERIES_X1.

Here is the call graph for this function:

get_calib_mode_name()

std::string Slic3r::GUI::get_calib_mode_name	(	CalibMode	cali_mode,
		int	stage )

{
    switch(cali_mode) {
    case CalibMode::Calib_PA_Line:
        return "pa_line_calib_mode";
    case CalibMode::Calib_Auto_PA_Line:
        return "auto_pa_line_calib_mode";
    case CalibMode::Calib_PA_Pattern:
        return "pa_pattern_calib_mode";
    case CalibMode::Calib_Flow_Rate:
        if (stage == 1)
            return "flow_rate_coarse_calib_mode";
        else if (stage == 2)
            return "flow_rate_fine_calib_mode";
        else
            return "flow_rate_coarse_calib_mode";
    case CalibMode::Calib_Temp_Tower:
        return "temp_tower_calib_mode";
    case CalibMode::Calib_Vol_speed_Tower:
        return "vol_speed_tower_calib_mode";
    case CalibMode::Calib_VFA_Tower:
        return "vfa_tower_calib_mode";
    case CalibMode::Calib_Retraction_tower:
        return "retration_tower_calib_mode";
    case CalibMode::Calib_Input_shaping_freq:
        return "input_shaping_freq_calib_mode";
    case CalibMode::Calib_Input_shaping_damp:
        return "input_shaping_damp_calib_mode";
    case CalibMode::Calib_Cornering:
        return "cornering_calib_mode";
    default:
        assert(false);
        return "";
    }
}

References Slic3r::Calib_Auto_PA_Line, Slic3r::Calib_Cornering, Slic3r::Calib_Flow_Rate, Slic3r::Calib_Input_shaping_damp, Slic3r::Calib_Input_shaping_freq, Slic3r::Calib_PA_Line, Slic3r::Calib_PA_Pattern, Slic3r::Calib_Retraction_tower, Slic3r::Calib_Temp_Tower, Slic3r::Calib_VFA_Tower, and Slic3r::Calib_Vol_speed_Tower.

Referenced by Slic3r::GUI::CalibUtils::send_to_print(), and Slic3r::GUI::CalibUtils::send_to_print().

Here is the caller graph for this function:

get_calibration_type_name()

wxString Slic3r::GUI::get_calibration_type_name

(

CalibMode

cali_mode

)

{
    switch (cali_mode) {
    case CalibMode::Calib_PA_Line:
        return _L("Flow Dynamics");
    case CalibMode::Calib_Flow_Rate:
        return _L("Flow ratio");
    case CalibMode::Calib_Vol_speed_Tower:
        return _L("Max Volumetric Speed");
    case CalibMode::Calib_Temp_Tower:
        return _L("Temperature");
    case CalibMode::Calib_Retraction_tower:
        return _L("Retraction");
    default:
        return "";
    }
}

References _L, Slic3r::Calib_Flow_Rate, Slic3r::Calib_PA_Line, Slic3r::Calib_Retraction_tower, Slic3r::Calib_Temp_Tower, and Slic3r::Calib_Vol_speed_Tower.

Referenced by Slic3r::GUI::CalibrationPanel::init_tabpanel().

Here is the caller graph for this function:

get_calibration_wiki_page()

wxString Slic3r::GUI::get_calibration_wiki_page

(

CalibMode

cali_mode

)

{
    std::string language = wxGetApp().app_config->get("language");
    wxString    region   = "en";
    if (language.find("zh") == 0)
        region = "zh";
 
    switch (cali_mode) {
    case CalibMode::Calib_PA_Line:
        return wxString::Format("https://wiki.bambulab.com/%s/software/bambu-studio/calibration_pa", region);
    case CalibMode::Calib_Flow_Rate:
        return wxString::Format("https://wiki.bambulab.com/%s/software/bambu-studio/calibration_flow_rate", region);
    case CalibMode::Calib_Vol_speed_Tower:
        return wxString::Format("https://wiki.bambulab.com/%s/software/bambu-studio/calibration_volumetric", region);
    case CalibMode::Calib_Temp_Tower:
        return wxString::Format("https://wiki.bambulab.com/%s/software/bambu-studio/calibration_temperature", region);
    case CalibMode::Calib_Retraction_tower:
        return wxString::Format("https://wiki.bambulab.com/%s/software/bambu-studio/calibration_retraction", region);
    default:
        return "";
    }
}

References Slic3r::Calib_Flow_Rate, Slic3r::Calib_PA_Line, Slic3r::Calib_Retraction_tower, Slic3r::Calib_Temp_Tower, and Slic3r::Calib_Vol_speed_Tower.

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

Here is the caller graph for this function:

get_cannot_reason_text()

wxString Slic3r::GUI::get_cannot_reason_text

(

DevAms::CannotDryReason

reason

)

{
    wxString cannot_reason_text;
    switch (reason)
    {
    case DevAms::CannotDryReason::InsufficientPower:
        cannot_reason_text = "*" + _L("Insufficient power") + "\n";
        cannot_reason_text += _L("  Too many AMS drying simultaneously. Please plug in the power or stop other drying processes before starting.") + "\n";
        break;
    case DevAms::CannotDryReason::AmsBusy:
        cannot_reason_text = "*" + _L("AMS is busy") + "\n";
        cannot_reason_text += _L("  AMS is calibrating | reading RFID | loading/unloading material, please wait.") + "\n";
        break;
    case DevAms::CannotDryReason::ConsumableAtAmsOutlet:
        cannot_reason_text = "*" + _L("Filament in AMS outlet") + "\n";
        cannot_reason_text += _L("  The high drying temperature may cause AMS blockage, please unload first.");
        break;
    case DevAms::CannotDryReason::InitiatingAmsDrying:
        cannot_reason_text = "*" + _L("Initiating AMS drying") + "\n";
        break;
    case DevAms::CannotDryReason::NotSupportedIn2dMode:
        cannot_reason_text = "*" + _L("Not supported in 2D mode") + "\n";
        break;
    case DevAms::CannotDryReason::DryingInProgress:
        cannot_reason_text = "*" + _L("Task in progress") + "\n";
        cannot_reason_text += _L("  The AMS might be in use during Task.") + "\n";
        break;
    case DevAms::CannotDryReason::Upgrading:
        cannot_reason_text = "*" + _L("Upgrading") + "\n";
        cannot_reason_text += _L("  Firmware update in progress, please wait...") + "\n";
        break;
    case DevAms::CannotDryReason::InsufficientPowerNeedPluginPower:
        cannot_reason_text = "*" + _L("Insufficient power") + "\n";
        cannot_reason_text += _L("  Please plug in the power and then use the drying function.") + "\n";
        break;
    case DevAms::CannotDryReason::FilamentAtAmsOutletManualUnload:
        cannot_reason_text = "*" + _L("Filament in AMS outlet") + "\n";
        cannot_reason_text += _L("  The high drying temperature may cause AMS blockage. Please unload the filament manually before proceeding.") + "\n";
        break;
    default:
        cannot_reason_text = "*" + _L("System is busy") + "\n";
        cannot_reason_text += _L("  Initiating other drying processes, please wait a few seconds...") + "\n";
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": unknown cannot dry reason";
        break;
    }
    return cannot_reason_text;
}

References _L, Slic3r::DevAms::AmsBusy, Slic3r::DevAms::ConsumableAtAmsOutlet, Slic3r::DevAms::DryingInProgress, Slic3r::DevAms::FilamentAtAmsOutletManualUnload, Slic3r::DevAms::InitiatingAmsDrying, Slic3r::DevAms::InsufficientPower, Slic3r::DevAms::InsufficientPowerNeedPluginPower, Slic3r::DevAms::NotSupportedIn2dMode, and Slic3r::DevAms::Upgrading.

Referenced by organize_cannot_reasons_text().

Here is the caller graph for this function:

get_color()

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

static

{
    return GLGizmoBase::AXES_COLOR[axis];
}

References Slic3r::GUI::GLGizmoBase::AXES_COLOR.

Referenced by 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 caller graph for this function:

get_config_json()

json Slic3r::GUI::get_config_json ( const Preset * preset )

static

                                                  {
    json j;
    // record the headers
    j[BBL_JSON_KEY_VERSION] = preset->version.to_string();
    j[BBL_JSON_KEY_NAME]    = preset->name;
    j[BBL_JSON_KEY_FROM]    = "";
 
   DynamicPrintConfig config = preset->config;
 
    // record all the key-values
    for (const std::string &opt_key : config.keys()) {
        const ConfigOption *opt = config.option(opt_key);
        if (opt->is_scalar()) {
            if (opt->type() == coString)
                // keep \n, \r, \t
                j[opt_key] = (dynamic_cast<const ConfigOptionString *>(opt))->value;
            else
                j[opt_key] = opt->serialize();
        } else {
            const ConfigOptionVectorBase *vec = static_cast<const ConfigOptionVectorBase *>(opt);
            std::vector<std::string> string_values = vec->vserialize();
 
            json j_array(string_values);
            j[opt_key] = j_array;
        }
    }
 
    return j;
}

References BBL_JSON_KEY_FROM, BBL_JSON_KEY_NAME, BBL_JSON_KEY_VERSION, Slic3r::Preset::config, Slic3r::coString, Slic3r::DynamicConfig::keys(), Slic3r::Preset::name, Slic3r::ConfigBase::option(), Slic3r::Semver::to_string(), Slic3r::Preset::version, and Slic3r::ConfigOptionVectorBase::vserialize().

Here is the call graph for this function:

get_curr_radio_type()

wxString Slic3r::GUI::get_curr_radio_type ( std::vector< std::pair< RadioBox *, wxString > > & radio_btns )

static

{
    for (std::pair<RadioBox *, wxString> radio_string : radio_btns) {
        if (radio_string.first->GetValue()) {
            return radio_string.second;
        }
    }
    return "";
}

Referenced by Slic3r::GUI::ExportConfigsDialog::create_dialog_buttons(), and Slic3r::GUI::ExportConfigsDialog::update_include_bed_assets_enabled().

Here is the caller graph for this function:

get_curr_time() [1/2]

std::string Slic3r::GUI::get_curr_time ( const char * format = "%Y_%m_%d_%H_%M_%S" )

static

{
    std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
 
    std::time_t time = std::chrono::system_clock::to_time_t(now);
 
    std::tm            local_time = *std::localtime(&time);
    std::ostringstream time_stream;
    time_stream << std::put_time(&local_time, format);
 
    std::string current_time = time_stream.str();
    return current_time;
}

References format().

Referenced by get_curr_timestmp(), get_filament_id(), Slic3r::GUI::ExportConfigsDialog::initial_file_name(), and Slic3r::GUI::ExportPresetBundleDialog::OnExportData().

Here is the call graph for this function:

Here is the caller graph for this function:

get_curr_time() [2/2]

std::string Slic3r::GUI::get_curr_time ( const char * format = "%Y_%m_%d_%H_%M_%S" )

static

{
    std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
 
    std::time_t time = std::chrono::system_clock::to_time_t(now);
 
    std::tm local_time = *std::localtime(&time);
    std::ostringstream time_stream;
    time_stream << std::put_time(&local_time, format);
 
    std::string current_time = time_stream.str();
    return current_time;
}

References format().

Here is the call graph for this function:

get_curr_timestmp()

std::string Slic3r::GUI::get_curr_timestmp ( )

static

{
    return get_curr_time("%Y%m%d%H%M%S");
    // std::time_t currentTime = std::time(nullptr);
    // std::ostringstream oss;
    // oss << currentTime;
    // std::string timestampString = oss.str();
    // return timestampString;
}

References get_curr_time().

Referenced by Slic3r::GUI::ExportConfigsDialog::archive_filament_bundle_to_file(), and Slic3r::GUI::ExportConfigsDialog::archive_preset_bundle_to_file().

Here is the call graph for this function:

Here is the caller graph for this function:

get_cut_plane_points()

std::array< Vec3d, 4 > Slic3r::GUI::get_cut_plane_points	(	const BoundingBoxf3 &	bbox,
		const double &	cut_height )

{
    std::array<Vec3d, 4> plane_pts;
    plane_pts[0] = Vec3d(bbox.min(0), bbox.min(1), cut_height);
    plane_pts[1] = Vec3d(bbox.max(0), bbox.min(1), cut_height);
    plane_pts[2] = Vec3d(bbox.max(0), bbox.max(1), cut_height);
    plane_pts[3] = Vec3d(bbox.min(0), bbox.max(1), cut_height);
    return plane_pts;
}

References Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, and Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min.

get_data_from_svg()

bool Slic3r::GUI::get_data_from_svg	(	const std::string &	filename,
		unsigned int	max_size_px,
		ThumbnailData &	thumbnail_data )

{
    bool compression_enabled = false;
 
    NSVGimage *image = nsvgParseFromFile(filename.c_str(), "px", 96.0f);
    if (image == nullptr) { return false; }
 
    float scale = (float) max_size_px / std::max(image->width, image->height);
 
    thumbnail_data.width  = (int) (scale * image->width);
    thumbnail_data.height = (int) (scale * image->height);
 
    int n_pixels = thumbnail_data.width * thumbnail_data.height;
 
    if (n_pixels <= 0) {
        nsvgDelete(image);
        return false;
    }
 
    NSVGrasterizer *rast = nsvgCreateRasterizer();
    if (rast == nullptr) {
        nsvgDelete(image);
        return false;
    }
 
    // creates the temporary buffer only once, with max size, and reuse it for all the levels, if generating mipmaps
    std::vector<unsigned char> data(n_pixels * 4, 0);
    thumbnail_data.pixels = data;
    nsvgRasterize(rast, image, 0, 0, scale, thumbnail_data.pixels.data(), thumbnail_data.width, thumbnail_data.height, thumbnail_data.width * 4);
 
    // we manually generate mipmaps because glGenerateMipmap() function is not reliable on all graphics cards
    int   lod_w = thumbnail_data.width;
    int   lod_h = thumbnail_data.height;
    GLint level = 0;
    while (lod_w > 1 || lod_h > 1) {
        ++level;
 
        lod_w = std::max(lod_w / 2, 1);
        lod_h = std::max(lod_h / 2, 1);
        scale /= 2.0f;
 
        data.resize(lod_w * lod_h * 4);
 
        nsvgRasterize(rast, image, 0, 0, scale, data.data(), lod_w, lod_h, lod_w * 4);
    }
 
    nsvgDeleteRasterizer(rast);
    nsvgDelete(image);
 
    return true;
}

References Slic3r::ThumbnailData::height, Slic3r::nsvgParseFromFile(), Slic3r::ThumbnailData::pixels, scale(), and Slic3r::ThumbnailData::width.

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_default_font()

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

inline

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

References get_default_font_for_dpi(), and get_dpi_for_window().

Referenced by Slic3r::GUI::AboutDialog::AboutDialog(), and Slic3r::GUI::CopyrightsDialog::CopyrightsDialog().

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< wxFrame >::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_default_k_n_value()

void Slic3r::GUI::get_default_k_n_value	(	const std::string &	filament_id,
		float &	k,
		float &	n )

{
    // filament_id is our OF id; the literals below are the printer's own. An id the agent has
    // no mapping for (e.g. a caller still on the old id) passes through unchanged.
    auto* agent = wxGetApp().getAgent();
    const std::string printer_filament_id = agent ? agent->from_orca_filament_id(filament_id) : filament_id;
    if (printer_filament_id.compare("GFU01") == 0) {
        /* TPU 95A */
        k = 0.25;
        n = 1.0;
    } else if (printer_filament_id.compare("GFU03") == 0) {
        /* TPU 90A */
        k = 0.35;
        n = 1.0;
    } else if (printer_filament_id.compare("GFU04") == 0) {
        /* TPU 85A */
        k = 0.65;
        n = 1.0;
    } else if (printer_filament_id.compare("GFG00") == 0 || printer_filament_id.compare("GFG01") == 0 ||
               printer_filament_id.compare("GFG60") == 0 || printer_filament_id.compare("GFL06") == 0 ||
               printer_filament_id.compare("GFL55") == 0 || printer_filament_id.compare("GFG99") == 0 ||
               printer_filament_id.compare("GFG98") == 0 || printer_filament_id.compare("GFG97") == 0 ||
               printer_filament_id.compare("GFG50") == 0 || printer_filament_id.compare("GFU02") == 0 ||
               printer_filament_id.compare("GFU98") == 0 || printer_filament_id.compare("GFS00") == 0 ||
               printer_filament_id.compare("GFS02") == 0) {
        /* 0.04 filaments */
        k = 0.04;
        n = 1.0;
    } else {
        /* other */
        k = 0.02;
        n = 1.0;
    }
}

Referenced by Slic3r::GUI::AMSMaterialsSetting::on_select_filament(), and Slic3r::GUI::AMSLib::render_generic_text().

Here is the caller graph for this function:

get_default_name()

wxString Slic3r::GUI::get_default_name ( wxString filament_name, CalibMode mode )

static

                                                                        {
    PresetBundle* preset_bundle = wxGetApp().preset_bundle;
    for (auto it = preset_bundle->filaments.begin(); it != preset_bundle->filaments.end(); it++) {
        if (filament_name.compare(it->name) == 0) {
            if (!it->alias.empty())
                filament_name = from_u8(it->alias);
            else
                filament_name = from_u8(it->name);
        }
    }
 
    switch (mode)
    {
    case Slic3r::CalibMode::Calib_None:
        break;
    case Slic3r::CalibMode::Calib_PA_Line:
        if (filament_name.StartsWith("Generic")) {
            filament_name.Replace("Generic", "Brand", false);
        }
        break;
    case Slic3r::CalibMode::Calib_PA_Tower:
        break;
    case Slic3r::CalibMode::Calib_Flow_Rate:
        filament_name = format_wxstr(_L("%1% Flow Rate Calibrated"), filament_name);
        break;
    case Slic3r::CalibMode::Calib_Temp_Tower:
        filament_name = format_wxstr(_L("%1% Temperature Calibrated"), filament_name);
        break;
    case Slic3r::CalibMode::Calib_Vol_speed_Tower:
        filament_name = format_wxstr(_L("%1% Max Vol Speed Calibrated"), filament_name);
        break;
    case Slic3r::CalibMode::Calib_VFA_Tower:
        break;
    case Slic3r::CalibMode::Calib_Retraction_tower:
        break;
    case Slic3r::CalibMode::Calib_Input_shaping_freq:
        break;
    case Slic3r::CalibMode::Calib_Input_shaping_damp:
        break;
    case Slic3r::CalibMode::Calib_Cornering:
        break;
    default:
        break;
    }
    return filament_name;
}

References _L, Slic3r::PresetCollection::begin(), Slic3r::Calib_Cornering, Slic3r::Calib_Flow_Rate, Slic3r::Calib_Input_shaping_damp, Slic3r::Calib_Input_shaping_freq, Slic3r::Calib_None, Slic3r::Calib_PA_Line, Slic3r::Calib_PA_Tower, Slic3r::Calib_Retraction_tower, Slic3r::Calib_Temp_Tower, Slic3r::Calib_VFA_Tower, Slic3r::Calib_Vol_speed_Tower, Slic3r::PresetCollection::end(), Slic3r::PresetBundle::filaments, format_wxstr(), and from_u8().

Referenced by Slic3r::GUI::CaliPASaveAutoPanel::default_naming(), Slic3r::GUI::CalibrationFlowCoarseSavePage::Show(), Slic3r::GUI::CalibrationFlowFineSavePage::Show(), Slic3r::GUI::CalibrationMaxVolumetricSpeedSavePage::Show(), Slic3r::GUI::CaliPASaveManualPanel::Show(), Slic3r::GUI::CalibrationFlowX1SavePage::sync_cali_result(), and Slic3r::GUI::CaliPASaveAutoPanel::sync_cali_result_for_multi_extruder().

Here is the call graph for this function:

Here is the caller graph for this function:

get_diameter_string()

std::string Slic3r::GUI::get_diameter_string ( float diameter )

static

{
    std::ostringstream stream; // ORCA ensure 0.25 returned as 0.25. previous code returned as 0.2 because of std::setprecision(1)
    stream << std::fixed << std::setprecision(2) << diameter;  // Use 2 decimals to capture 0.25 / 0.15 reliably
    std::string s = stream.str();
    if (s.find('.') != std::string::npos) {   // Remove trailing zeros, but keep at least one decimal if needed
        s.erase(s.find_last_not_of('0') + 1);
        if (s.back() == '.') s += '0';        // Ensure "1." → "1.0"
    }
    return s;
}

Referenced by Slic3r::GUI::ExtruderGroup::SetRowDiameters(), Slic3r::GUI::Sidebar::priv::switch_diameter_to(), Slic3r::GUI::Sidebar::priv::sync_extruder_list(), and Slic3r::GUI::Sidebar::update_presets().

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; }
        const int dpi = GetDeviceCaps(hdc, LOGPIXELSX);
        ReleaseDC(hwnd, hdc); // GetDC's handle must be released, unlike GetWindowDC's
        return dpi;
    }
#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< wxFrame >::DPIAware(), Slic3r::GUI::GLCanvas3D::_check_and_update_toolbar_icon_scale(), Slic3r::GUI::GLCanvas3D::_render_3d_navigator(), Slic3r::GUI::GLCanvas3D::_render_assembly_tooltip_button(), Slic3r::GUI::GLCanvas3D::_render_canvas_toolbar(), Slic3r::GUI::GLCanvas3D::_render_frame(), Slic3r::GUI::GLCanvas3D::_render_imgui_select_plate_toolbar(), Slic3r::GUI::GLCanvas3D::_render_plate_switcher(), add_msg_content(), Slic3r::GUI::GizmoObjectManipulation::do_render_move_window(), Slic3r::GUI::GLCanvas3D::get_canvas_toolbar_right(), get_default_font(), get_default_font_for_dpi(), Slic3r::GUI::Emboss::StyleManager::init_style_images(), marker_scale(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window(), Slic3r::GUI::GLGizmoUtils::render_tooltip_button(), Slic3r::GUI::GizmoObjectManipulation::reset_button(), Slic3r::GUI::GizmoObjectManipulation::reset_zero_button(), Slic3r::GUI::SplashScreen::scale_font(), and Slic3r::GUI::PageMaterials::set_compatible_printers_html_window().

Here is the caller graph for this function:

get_drag_transformation_type()

TransformationType Slic3r::GUI::get_drag_transformation_type

(

const Selection &

selection

)

Distiguish between object and volume Differ in possible transformation type.

Parameters

selection

Contain selected volume/object

Returns

Transformation to use

{
    return is_embossed_object(selection) ?
        TransformationType::Instance_Relative_Joint : 
        TransformationType::Local_Relative_Joint;
}

References Slic3r::GUI::TransformationType::Instance_Relative_Joint, and Slic3r::GUI::TransformationType::Local_Relative_Joint.

Referenced by do_local_z_rotate(), Slic3r::GUI::GLGizmoEmboss::do_mirror(), dragging_rotate_gizmo(), Slic3r::GUI::GLGizmoSVG::draw_mirroring(), and Slic3r::GUI::GLGizmoSVG::draw_size().

Here is the caller graph for this function:

get_dragging_half_size()

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::GLGizmoCut3D::render_cut_plane_grabbers().

Here is the call graph for this function:

Here is the caller graph for this function:

get_dry_status_img_path()

std::string Slic3r::GUI::get_dry_status_img_path ( DevAmsType type, DevAms::DryStatus status, DevAms::DrySubStatus sub_status )

static

{
    std::string img_name = "dev_ams_dry_ctr_";
    switch (type) {
        case DevAmsType::N3S:
            img_name += "n3s";
            break;
        case DevAmsType::N3F:
            img_name += "n3f";
            break;
        default:
            return "";
    }
 
    img_name += "_";
    switch (status) {
        case DevAms::DryStatus::Error:
            img_name += "error";
            return img_name;
    }
 
    switch (sub_status) {
        case DevAms::DrySubStatus::Heating:
            img_name += "heating";
            return img_name;
        case DevAms::DrySubStatus::Dehumidify:
            img_name += "dehumidifying";
            return img_name;
    }
 
    return "";
}

References Slic3r::DevAms::Dehumidify, Slic3r::DevAms::Error, Slic3r::DevAms::Heating, Slic3r::N3F, and Slic3r::N3S.

Referenced by Slic3r::GUI::AMSDryCtrWin::update_image().

Here is the caller graph for this function:

get_error_message()

std::string Slic3r::GUI::get_error_message

(

int

error_code

)

{
    if (should_disable_hms()) return "";
 
  char buf[64];
    std::string result_str = "";
    std::sprintf(buf,"%08X",error_code);
    std::string hms_host = wxGetApp().app_config->get_hms_host();
    std::string get_lang = wxGetApp().app_config->get_language_code();
 
    std::string url = (boost::format("https://%1%/query.php?lang=%2%&e=%3%")
                        %hms_host
                        %get_lang
                        %buf).str();
 
    Slic3r::Http http = Slic3r::Http::get(url);
    http.header("accept", "application/json")
        .timeout_max(10)
        .on_complete([get_lang, &result_str](std::string body, unsigned status) {
            try {
                json j = json::parse(body);
                if (j.contains("result")) {
                    if (j["result"].get<int>() == 0) {
                        if (j.contains("data")) {
                            json jj = j["data"];
                            if (jj.contains("device_error")) {
                                if (jj["device_error"].contains(get_lang)) {
                                    if (jj["device_error"][get_lang].size() > 0) {
                                        if (!jj["device_error"][get_lang][0]["intro"].empty() || !jj["device_error"][get_lang][0]["ecode"].empty()) {
                                            std::string error_info = jj["device_error"][get_lang][0]["intro"].get<std::string>();
                                            std::string error_code = jj["device_error"][get_lang][0]["ecode"].get<std::string>();
                                            error_code.insert(4, " ");
                                            result_str = from_u8(error_info).ToStdString() + "[" + error_code + "]";
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            } catch (...) {
             ;
        }
        })
        .on_error([](std::string body, std::string error, unsigned status) {
            BOOST_LOG_TRIVIAL(info) << boost::format("[BBL ErrorMessage]: status=%1%, error=%2%, body=%3%") % status % error % body;
        }).perform_sync();
 
        return result_str;
}

References Slic3r::Geometry::contains(), Slic3r::empty(), from_u8(), Slic3r::Http::get(), Slic3r::http, and should_disable_hms().

Here is the call graph for this function:

get_exist_vendor_choices()

wxArrayString Slic3r::GUI::get_exist_vendor_choices ( VendorMap & vendors )

static

{
    wxArrayString choices;
    PresetBundle  temp_preset_bundle;
    temp_preset_bundle.load_system_models_from_json(ForwardCompatibilitySubstitutionRule::EnableSystemSilent);
    PresetBundle *preset_bundle = wxGetApp().preset_bundle;
 
    VendorProfile users_models  = preset_bundle->get_custom_vendor_models();
 
    vendors = temp_preset_bundle.vendors;
 
    if (!users_models.models.empty()) {
        vendors[users_models.name] = users_models;
    }
 
    for (const auto& vendor : vendors) {
        if (vendor.second.models.empty() || vendor.second.id.empty()) continue;
        choices.Add(vendor.first);
    }
    return choices;
}

References Slic3r::EnableSystemSilent, Slic3r::PresetBundle::get_custom_vendor_models(), Slic3r::PresetBundle::load_system_models_from_json(), Slic3r::VendorProfile::models, Slic3r::VendorProfile::name, and Slic3r::PresetBundle::vendors.

Referenced by Slic3r::GUI::CreatePrinterPresetDialog::create_printer_preset_item(), and Slic3r::GUI::CreatePrinterPresetDialog::on_select_printer_model().

Here is the call graph for this function:

Here is the caller graph for this function:

get_extruder_id_for_volumes()

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::ModelVolume::extruder_id(), Slic3r::ModelVolume::is_model_part(), and Slic3r::ModelObject::volumes.

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_fail_reason()

wxString Slic3r::GUI::get_fail_reason

(

int

code

)

{
    if (code == BAMBU_NETWORK_ERR_BIND_CREATE_SOCKET_FAILED)
        return _L("Failed to create socket");
 
    else if (code == BAMBU_NETWORK_ERR_BIND_SOCKET_CONNECT_FAILED)
        return _L("Failed to connect socket");
 
    else if (code == BAMBU_NETWORK_ERR_BIND_PUBLISH_LOGIN_REQUEST)
        return _L("Failed to publish login request");
 
    else if (code == BAMBU_NETWORK_ERR_BIND_GET_PRINTER_TICKET_TIMEOUT)
        return _L("Timeout getting ticket from device");
 
    else if (code == BAMBU_NETWORK_ERR_BIND_GET_CLOUD_TICKET_TIMEOUT)
        return _L("Timeout getting ticket from server");
 
    else if (code == BAMBU_NETWORK_ERR_BIND_POST_TICKET_TO_CLOUD_FAILED)
        return _L("Failed to post ticket to server");
 
    else if (code == BAMBU_NETWORK_ERR_BIND_PARSE_LOGIN_REPORT_FAILED)
        return _L("Failed to parse login report reason");
 
    else if (code == BAMBU_NETWORK_ERR_BIND_ECODE_LOGIN_REPORT_FAILED)
        return _L("Failed to parse login report reason");
 
    else if (code == BAMBU_NETWORK_ERR_BIND_RECEIVE_LOGIN_REPORT_TIMEOUT)
        return _L("Receive login report timeout");
 
    else
        return _L("Unknown Failure");
}

References _L, BAMBU_NETWORK_ERR_BIND_CREATE_SOCKET_FAILED, BAMBU_NETWORK_ERR_BIND_ECODE_LOGIN_REPORT_FAILED, BAMBU_NETWORK_ERR_BIND_GET_CLOUD_TICKET_TIMEOUT, BAMBU_NETWORK_ERR_BIND_GET_PRINTER_TICKET_TIMEOUT, BAMBU_NETWORK_ERR_BIND_PARSE_LOGIN_REPORT_FAILED, BAMBU_NETWORK_ERR_BIND_POST_TICKET_TO_CLOUD_FAILED, BAMBU_NETWORK_ERR_BIND_PUBLISH_LOGIN_REQUEST, BAMBU_NETWORK_ERR_BIND_RECEIVE_LOGIN_REPORT_TIMEOUT, and BAMBU_NETWORK_ERR_BIND_SOCKET_CONNECT_FAILED.

Referenced by Slic3r::GUI::BindMachineDialog::on_bind_fail().

Here is the caller graph for this function:

get_filament_compatible_printer()

void Slic3r::GUI::get_filament_compatible_printer ( Preset * preset, std::vector< std::string > & printers )

static

{
    auto compatible_printers = dynamic_cast<ConfigOptionStrings *>(preset->config.option("compatible_printers"));
    if (compatible_printers == nullptr) return;
    for (const std::string &printer_name : compatible_printers->values) {
        printers.push_back(printer_name);
    }
}

References Slic3r::Preset::config, and Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::EditFilamentPresetDialog::get_same_filament_id_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

get_filament_id()

std::string Slic3r::GUI::get_filament_id ( std::string vendor_typr_serial, const PresetBundle & temp_preset_bundle )

static

{
    std::unordered_map<std::string, std::set<std::string>> filament_id_to_filament_name;
 
    // temp filament presets
    const std::deque<Preset> &filament_presets = temp_preset_bundle.filaments.get_presets();
 
    for (const Preset &preset : filament_presets) {
        std::string preset_name = preset.name;
        size_t      index_at    = preset_name.find_first_of('@');
        if (index_at == std::string::npos) {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " filament preset name has no @ and name is: " << preset_name;
            continue;
        }
        std::string filament_name = preset_name.substr(0, index_at - 1);
        if (filament_name == vendor_typr_serial && preset.filament_id != "null")
            return preset.filament_id;
        filament_id_to_filament_name[preset.filament_id].insert(filament_name);
    }
    // global filament presets
    PresetBundle *                                     preset_bundle               = wxGetApp().preset_bundle;
    std::map<std::string, std::vector<Preset const *>> temp_filament_id_to_presets = preset_bundle->filaments.get_filament_presets();
    for (std::pair<std::string, std::vector<Preset const *>> filament_id_to_presets : temp_filament_id_to_presets) {
        if (filament_id_to_presets.first.empty()) continue;
        for (const Preset *preset : filament_id_to_presets.second) {
            std::string preset_name = preset->name;
            size_t      index_at    = preset_name.find_first_of('@');
            if (index_at == std::string::npos) {
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " filament preset name has no @ and name is: " << preset_name;
                continue;
            }
            std::string filament_name = preset_name.substr(0, index_at - 1);
            if (filament_name == vendor_typr_serial && preset->filament_id != "null")
                return preset->filament_id;
            filament_id_to_filament_name[preset->filament_id].insert(filament_name);
        }
    }
 
    std::string user_filament_id = "P" + calculate_md5(vendor_typr_serial).substr(0, 7);
 
    while (filament_id_to_filament_name.find(user_filament_id) != filament_id_to_filament_name.end()) {//find same filament id
        bool have_same_filament_name = false;
        for (const std::string &name : filament_id_to_filament_name.find(user_filament_id)->second) {
            if (name == vendor_typr_serial) {
                have_same_filament_name = true;
                break;
            }
        }
        if (have_same_filament_name) {
            break;
        }
        else { //Different names correspond to the same filament id
            user_filament_id = "P" + calculate_md5(vendor_typr_serial + get_curr_time()).substr(0, 7);
        }
    }
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " filament name is: " << vendor_typr_serial << "and create filament_id is: " << user_filament_id;
    return user_filament_id;
}

References calculate_md5(), Slic3r::Preset::filament_id, Slic3r::PresetBundle::filaments, get_curr_time(), Slic3r::PresetCollection::get_filament_presets(), Slic3r::PresetCollection::get_presets(), and Slic3r::Preset::name.

Referenced by Slic3r::GUI::CreateFilamentPresetDialog::create_dialog_buttons(), and Slic3r::GUI::CreatePrinterPresetDialog::create_page2_dialog_buttons().

Here is the call graph for this function:

Here is the caller graph for this function:

get_filament_mixture_warning_text()

std::string & Slic3r::GUI::get_filament_mixture_warning_text

(

)

                                              {
    static std::string filament_mixture_warning_text;
    return filament_mixture_warning_text;
}

References get_filament_mixture_warning_text().

Referenced by Slic3r::GUI::GLCanvas3D::_set_warning_notification(), get_filament_mixture_warning_text(), and Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

get_filament_name() [1/2]

std::string Slic3r::GUI::get_filament_name ( std::string & preset_name )

static

{
    size_t index_at = preset_name.find_last_of("@");
    if (std::string::npos == index_at) {
        return preset_name;
    } else {
        return preset_name.substr(0, index_at - 1);
    }
}

Referenced by Slic3r::GUI::EditFilamentPresetDialog::EditFilamentPresetDialog(), Slic3r::GUI::ExportConfigsDialog::data_init(), has_filaments(), and Slic3r::GUI::ExportPresetBundleDialog::InitExportData().

Here is the caller graph for this function:

get_filament_name() [2/2]

std::string Slic3r::GUI::get_filament_name ( std::string & preset_name )

static

{
    size_t index_at = preset_name.find_last_of("@");
    if (std::string::npos == index_at) {
        return preset_name;
    } else {
        return preset_name.substr(0, index_at - 1);
    }
}

get_first_added_preset() [1/2]

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(), and Slic3r::GUI::GuideFrame::apply_config().

Here is the call graph for this function:

Here is the caller graph for this function:

get_first_added_preset() [2/2]

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().

Here is the call 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 anonymous_namespace{GLGizmoEmboss.cpp}::create_input(), anonymous_namespace{GLGizmoSVG.cpp}::create_input(), and get_first_hovered_gl_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

get_flow_ratio()

bool Slic3r::GUI::get_flow_ratio ( const DynamicConfig & config, float & flow_ratio )

static

{
    const ConfigOptionFloatsNullable *flow_ratio_opt = config.option<ConfigOptionFloatsNullable>("filament_flow_ratio");
    if (flow_ratio_opt) {
        flow_ratio = flow_ratio_opt->get_at(0);
        if (flow_ratio > 0)
            return true;
    }
    return false;
}

References Slic3r::ConfigOptionVector< double >::get_at(), and Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::FlowRateWizard::on_cali_start().

Here is the call graph for this function:

Here is the caller graph for this function:

get_formatted_tooltip_text()

wxString Slic3r::GUI::get_formatted_tooltip_text	(	const ConfigOptionDef &	opt,
		const t_config_option_key &	id )

{
    wxString tooltip = _(opt.tooltip);
 
    std::string parameter_name = id;
    std::string opt_key = id;
    int opt_idx = 0;
 
    const size_t hash_pos = static_cast<std::string>(id).find("#");
 
    if (hash_pos != std::string::npos) {
        parameter_name.replace(hash_pos, 1, "[");
        parameter_name += "]";
 
        std::string temp_str = id;
        boost::erase_head(temp_str, hash_pos + 1);
        size_t orig_opt_idx = atoi(temp_str.c_str());
        opt_idx = orig_opt_idx >= 0 ? orig_opt_idx : 0;
 
        boost::erase_tail(opt_key, opt_key.size() - hash_pos);
    }
 
    tooltip += (tooltip.empty() ? "" : "\n\n") + _(L("parameter name")) + ": " + parameter_name;
 
    // Orca:
    // We can't use Orca's default values as-is because they sometimes depend on other values.
    // Parent preset configuration values will be used instead.
    if (const Preset* print_parent_preset = wxGetApp().preset_bundle->prints.get_selected_preset_parent()) {
        const DynamicPrintConfig& parent_config = print_parent_preset->config;
 
        if (!parent_config.has(opt_key))
            return tooltip;
 
        wxString side_text = from_u8(opt.sidetext);
 
        // Orca: a small hack for `layers` side text: adding a space before it for better looking text
        if (opt.sidetext == L("layers"))
            side_text = " " + _(side_text);
 
        if (opt.type == coFloat || opt.type == coInt || opt.type == coPercent || opt.type == coFloatOrPercent || 
            opt.type == coFloats || opt.type == coInts || opt.type == coPercents || opt.type == coFloatsOrPercents) {
            double default_value = std::numeric_limits<double>::quiet_NaN();
 
            if (opt.type == coFloat)
                default_value = parent_config.option<ConfigOptionFloat>(opt_key)->value;
            else if (opt.type == coFloats) {
                if (opt.nullable) {
                    auto opt_floats_nullable = parent_config.option<ConfigOptionFloatsNullable>(opt_key);
                    if (!opt_floats_nullable->values.empty())
                        default_value = opt_floats_nullable->get_at(opt_idx);
                } else {
                    auto opt_floats = parent_config.option<ConfigOptionFloats>(opt_key);
                    if (!opt_floats->values.empty())
                        default_value = opt_floats->get_at(opt_idx);
                }
            }
            else if (opt.type == coInt)
                default_value = parent_config.option<ConfigOptionInt>(opt_key)->value;
            else if(opt.type == coInts) {
                if (opt.nullable) {
                    auto opt_ints_nullable = parent_config.option<ConfigOptionIntsNullable>(opt_key);
                    if (!opt_ints_nullable->values.empty())
                        default_value = opt_ints_nullable->get_at(opt_idx);
                } else {
                    auto opt_ints = parent_config.option<ConfigOptionInts>(opt_key);
                    if (!opt_ints->values.empty())
                        default_value = opt_ints->get_at(opt_idx);
                }
            }
            else if (opt.type == coPercent)
                default_value = parent_config.option<ConfigOptionPercent>(opt_key)->value;
            else if (opt.type == coPercents) {
                if (opt.nullable) {
                    auto opt_percents_nullable = parent_config.option<ConfigOptionPercentsNullable>(opt_key);
                    if (!opt_percents_nullable->values.empty())
                        default_value = opt_percents_nullable->get_at(opt_idx);
                } else {
                    auto opt_percents = parent_config.option<ConfigOptionPercents>(opt_key);
                    if (!opt_percents->values.empty())
                        default_value = opt_percents->get_at(opt_idx);
                }
            }
            else if (opt.type == coFloatOrPercent || opt.type == coFloatsOrPercents) {
                bool is_percent = false;
                if (opt.type == coFloatOrPercent) {
                    default_value = parent_config.option<ConfigOptionFloatOrPercent>(opt_key)->value;
                    is_percent = parent_config.option<ConfigOptionFloatOrPercent>(opt_key)->percent;
                } else if (opt.type == coFloatsOrPercents) {
                    if (opt.nullable) {
                        auto opt_floats_or_percents_nullable = parent_config.option<ConfigOptionFloatsOrPercentsNullable>(opt_key);
                        if (!opt_floats_or_percents_nullable->values.empty()) {
                            default_value = opt_floats_or_percents_nullable->get_at(opt_idx).value;
                            is_percent    = opt_floats_or_percents_nullable->get_at(opt_idx).percent;
                        }
                    } else {
                        auto opt_floats_or_percents = parent_config.option<ConfigOptionFloatsOrPercents>(opt_key);
                        if (!opt_floats_or_percents->values.empty()) {
                            default_value = opt_floats_or_percents->get_at(opt_idx).value;
                            is_percent    = opt_floats_or_percents->get_at(opt_idx).percent;
                        }
                    }
                }
                
                if (is_percent)
                    side_text = "%";
                else if (!side_text.empty()) {
                    static std::string postfix = " or %";
                    auto postfix_pos = side_text.find(postfix);
                    if (postfix_pos != std::string::npos)
                        side_text.erase(postfix_pos, postfix.length());
                }
            }
 
            if (!std::isnan(default_value))
                tooltip += "\n\n" + _(L("Default")) + ": " + _(double_to_string(default_value)) + _(side_text);
 
            if (opt.min > -FLT_MAX && opt.max < FLT_MAX) {
                tooltip += "\n" + _(L("Range")) + ": [" +
                    _(double_to_string(opt.min)) + _(side_text) + ", " +
                    _(double_to_string(opt.max)) + _(side_text) + "]";
            }
        } else if (opt.type == coBool || opt.type == coBools || opt.type == coString || opt.type == coStrings) {
            std::string default_value = "";
 
            if (opt.type == coString)
                default_value = parent_config.option<ConfigOptionString>(opt_key)->value;
            else if (opt.type == coStrings) {
                auto opt_strings = parent_config.option<ConfigOptionStrings>(opt_key);
 
                if (!opt_strings->values.empty())
                    default_value = opt_strings->get_at(opt_idx);
            }
            else if (opt.type == coBool)
                default_value = parent_config.option<ConfigOptionBool>(opt_key)->value != 0 ? "true" : "false";
            else if (opt.type == coBools) {
                if (opt.nullable) {
                    auto opt_bools_nullable = parent_config.option<ConfigOptionBoolsNullable>(opt_key);
                    if (!opt_bools_nullable->values.empty())
                        default_value = opt_bools_nullable->get_at(opt_idx) != 0 ? "true" : "false";
                } else {
                    auto opt_bools = parent_config.option<ConfigOptionBools>(opt_key);
                    if (!opt_bools->values.empty())
                        default_value = opt_bools->get_at(opt_idx) != 0 ? "true" : "false";
                }
            }
 
            tooltip += "\n\n" + _(L("Default")) + ": " +
                (default_value.empty() ? _(L("Empty string")) : _(default_value) + _(side_text));
        }
    }
 
    edit_tooltip(tooltip);
 
    return tooltip;
}

References _, Slic3r::coBool, Slic3r::coBools, Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coFloats, Slic3r::coFloatsOrPercents, Slic3r::coInt, Slic3r::coInts, Slic3r::coPercent, Slic3r::coPercents, Slic3r::coString, Slic3r::coStrings, double_to_string(), edit_tooltip(), from_u8(), Slic3r::ConfigOptionResolver::has(), L, and Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::OptionsGroup::create_single_option_line(), and Slic3r::GUI::Field::get_tooltip_text().

Here is the call graph for this function:

Here is the caller graph for this function:

get_full_label()

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

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

References _L, Slic3r::DynamicPrintConfig::def(), Slic3r::ConfigDef::get(), get_pure_opt_key(), 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()

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

static

{
    auto options = SettingsFactory::get_options(is_part);
 
    const int filaments_cnt = filaments_count();
 
    DynamicPrintConfig config;
    for (auto& option : options)
    {
        auto const opt = config.def()->get(option);
        auto category = opt->category;
        if (is_improper_category(category, filaments_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::DynamicPrintConfig::def(), filaments_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()

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

static

{
#if ENABLE_FIXED_GRABBER
    // Orca: make grabber larger
    return 32. * GLGizmoBase::INV_ZOOM;
#else
    return (bb.size().x() + bb.size().y() + bb.size().z()) / 30.;
#endif
}

References Slic3r::GUI::GLGizmoBase::INV_ZOOM, and Slic3r::BoundingBox3Base< PointType >::size().

Referenced by Slic3r::GUI::GLGizmoCut3D::init_picking_models(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane_grabbers(), Slic3r::GUI::GLGizmoCut3D::update_bb(), 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()

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::GLGizmoCut3D::render_cut_plane_grabbers(), and Slic3r::GUI::GLGizmoCut3D::update_raycasters_for_picking_transform().

Here is the caller graph for this function:

get_hms_info_version()

int Slic3r::GUI::get_hms_info_version

(

std::string &

version

)

{
    AppConfig* config = wxGetApp().app_config;
    if (!config)
        return -1;
    if (should_disable_hms())
        return -1;
    std::string hms_host = config->get_hms_host();
    if(hms_host.empty()) {
        BOOST_LOG_TRIVIAL(error) << "hms_host is empty";
        return -1;
    }
    int result = -1;
    version = "";
    std::string lang;
    std::string query_params = HMSQuery::build_query_params(lang);
    std::string url = (boost::format("https://%1%/GetVersion.php?%2%") % hms_host % query_params).str();
    Slic3r::Http http = Slic3r::Http::get(url);
    http.timeout_max(10)
        .on_complete([&version](std::string body, unsigned status){
            try {
                json j = json::parse(body);
                if (j.contains("ver")) {
                    version = DevJsonValParser::get_longlong_val(j["ver"]);
                }
            } catch (...) {
                ;
            }
        })
        .on_error([&result](std::string body, std::string error, unsigned status) {
            BOOST_LOG_TRIVIAL(error) << "get_hms_info_version: body = " << body << ", status = " << status << ", error = " << error;
            result = -1;
            })
        .perform_sync();
    return result;
}

References Slic3r::GUI::HMSQuery::build_query_params(), Slic3r::Http::get(), Slic3r::AppConfig::get_hms_host(), Slic3r::DevJsonValParser::get_longlong_val(), Slic3r::http, and should_disable_hms().

Here is the call graph for this function:

get_hms_wiki_url()

std::string Slic3r::GUI::get_hms_wiki_url

(

std::string

error_code

)

{
    AppConfig* config = wxGetApp().app_config;
    if (!config) return "";
    if (should_disable_hms()) return "";
 
    std::string hms_host = wxGetApp().app_config->get_hms_host();
    std::string lang_code = HMSQuery::hms_language_code();
    std::string url = (boost::format("https://%1%/index.php?e=%2%&s=device_hms&lang=%3%")
        % hms_host
        % error_code
        % lang_code).str();
 
    DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev) return url;
    MachineObject* obj = dev->get_selected_machine();
    if (!obj) return url;
 
    if (!obj->get_dev_id().empty()) {
        url = (boost::format("https://%1%/index.php?e=%2%&d=%3%&s=device_hms&lang=%4%")
                       % hms_host
                       % error_code
                       % obj->get_dev_id()
                       % lang_code).str();
    }
    return url;
}

References Slic3r::MachineObject::get_dev_id(), Slic3r::AppConfig::get_hms_host(), Slic3r::DeviceManager::get_selected_machine(), Slic3r::GUI::HMSQuery::hms_language_code(), and should_disable_hms().

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_humidity_level_img_path()

std::string Slic3r::GUI::get_humidity_level_img_path ( int humidity_percent )

static

{
    const int num_levels = 5;
    int hum_level;
 
    if (humidity_percent <= 100 / num_levels) {
        hum_level = 5;
    } else if (humidity_percent <= 100 / num_levels * 2) {
        hum_level = 4;
    } else if (humidity_percent <= 100 / num_levels * 3) {
        hum_level = 3;
    } else if (humidity_percent <= 100 / num_levels * 4) {
        hum_level = 2;
    } else {
        hum_level = 1;
    }
 
    if (wxGetApp().dark_mode()) {
        return "hum_level" + std::to_string(hum_level) + "_no_num_dark"; // Orca: use the dark-mode humidity glyph in dark mode
    } else {
        return "hum_level" + std::to_string(hum_level) + "_no_num_light";
    }
 
}

Referenced by Slic3r::GUI::AMSDryCtrWin::update_image().

Here is the caller graph for this function:

get_icon_name()

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_index_type()

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 GL_UNSIGNED_BYTE, GL_UNSIGNED_INT, GL_UNSIGNED_SHORT, Slic3r::GUI::GLModel::Geometry::index_type, 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_left_extruder_unprintable_text()

std::string & Slic3r::GUI::get_left_extruder_unprintable_text ( )

extern

                                                {
    static std::string left_unprintable_text;
    return left_unprintable_text;
}

References get_left_extruder_unprintable_text().

Referenced by Slic3r::GUI::GLCanvas3D::_set_warning_notification(), Slic3r::GUI::GLCanvas3D::check_volumes_outside_state(), get_left_extruder_unprintable_text(), Slic3r::GUI::GLCanvas3D::reload_scene(), try_pop_up_before_slice(), and Slic3r::GUI::Plater::validate_current_plate().

Here is the call graph for this function:

Here is the caller graph for this function:

get_machine_name() [1/2]

std::string Slic3r::GUI::get_machine_name ( const std::string & preset_name )

static

{
    size_t index_at = preset_name.find_last_of("@");
    if (std::string::npos == index_at) {
        return "";
    } else {
        return preset_name.substr(index_at + 1);
    }
}

Referenced by Slic3r::GUI::ExportConfigsDialog::data_init(), and Slic3r::GUI::ExportPresetBundleDialog::InitExportData().

Here is the caller graph for this function:

get_machine_name() [2/2]

std::string Slic3r::GUI::get_machine_name ( const std::string & preset_name )

static

{
    size_t index_at = preset_name.find_last_of("@");
    if (std::string::npos == index_at) {
        return "";
    } else {
        return preset_name.substr(index_at + 1);
    }
}

get_max_layer_height()

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::DynamicConfig::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_min_flush_volumes()

std::vector< int > Slic3r::GUI::get_min_flush_volumes	(	const DynamicPrintConfig &	full_config,
		size_t	nozzle_id )

{
    std::vector<int>extra_flush_volumes;
    //const auto& full_config = wxGetApp().preset_bundle->full_config();
    //auto& printer_config = wxGetApp().preset_bundle->printers.get_edited_preset().config;
 
    const ConfigOptionFloatsNullable* nozzle_volume_opt = full_config.option<ConfigOptionFloatsNullable>("nozzle_volume");
    int nozzle_volume_val = nozzle_volume_opt ? (int)nozzle_volume_opt->get_at(nozzle_id) : 0;
 
    const ConfigOptionInt* enable_long_retraction_when_cut_opt = full_config.option<ConfigOptionInt>("enable_long_retraction_when_cut");
    int machine_enabled_level = 0;
    if (enable_long_retraction_when_cut_opt) {
        machine_enabled_level = enable_long_retraction_when_cut_opt->value;
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": get enable_long_retraction_when_cut from config, value=%1%")%machine_enabled_level;
    }
    const ConfigOptionBools* long_retractions_when_cut_opt = full_config.option<ConfigOptionBools>("long_retractions_when_cut");
    bool machine_activated = false;
    if (long_retractions_when_cut_opt) {
        machine_activated = long_retractions_when_cut_opt->values[nozzle_id] == 1;
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": get long_retractions_when_cut from config, value=%1%, activated=%2%")%long_retractions_when_cut_opt->values[0] %machine_activated;
    }
 
    size_t filament_size = full_config.option<ConfigOptionFloats>("filament_diameter")->values.size();
    std::vector<double> filament_retraction_distance_when_cut(filament_size, 18.0f), printer_retraction_distance_when_cut(filament_size, 18.0f);
    std::vector<unsigned char> filament_long_retractions_when_cut(filament_size, 0);
    const ConfigOptionFloats* filament_retraction_distances_when_cut_opt = full_config.option<ConfigOptionFloats>("filament_retraction_distances_when_cut");
    if (filament_retraction_distances_when_cut_opt) {
        filament_retraction_distance_when_cut = filament_retraction_distances_when_cut_opt->values;
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": get filament_retraction_distance_when_cut from config, size=%1%, values=%2%")%filament_retraction_distance_when_cut.size() %filament_retraction_distances_when_cut_opt->serialize();
    }
 
    const ConfigOptionFloats* printer_retraction_distance_when_cut_opt = full_config.option<ConfigOptionFloats>("retraction_distances_when_cut");
    if (printer_retraction_distance_when_cut_opt) {
        printer_retraction_distance_when_cut = printer_retraction_distance_when_cut_opt->values;
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": get retraction_distances_when_cut from config, size=%1%, values=%2%")%printer_retraction_distance_when_cut.size() %printer_retraction_distance_when_cut_opt->serialize();
    }
 
    const ConfigOptionBools* filament_long_retractions_when_cut_opt = full_config.option<ConfigOptionBools>("filament_long_retractions_when_cut");
    if (filament_long_retractions_when_cut_opt) {
        filament_long_retractions_when_cut = filament_long_retractions_when_cut_opt->values;
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": get filament_long_retractions_when_cut from config, size=%1%, values=%2%")%filament_long_retractions_when_cut.size() %filament_long_retractions_when_cut_opt->serialize();
    }
 
    for (size_t idx = 0; idx < filament_size; ++idx) {
        int extra_flush_volume = nozzle_volume_val;
        int retract_length = machine_enabled_level && machine_activated ? printer_retraction_distance_when_cut[nozzle_id] : 0;
 
        unsigned char filament_activated = filament_long_retractions_when_cut[idx];
        double filament_retract_length = filament_retraction_distance_when_cut[idx];
 
        if (filament_activated == 0)
            retract_length = 0;
        else if (filament_activated == 1 && machine_enabled_level == LongRectrationLevel::EnableFilament) {
            if (!std::isnan(filament_retract_length))
                retract_length = (int)filament_retraction_distance_when_cut[idx];
            else
                retract_length = printer_retraction_distance_when_cut[nozzle_id];
        }
 
        extra_flush_volume -= PI * 1.75 * 1.75 / 4 * retract_length;
        extra_flush_volumes.emplace_back(extra_flush_volume);
    }
    return extra_flush_volumes;
}

References Slic3r::EnableFilament, Slic3r::ConfigOptionVector< double >::get_at(), Slic3r::ConfigBase::option(), PI, Slic3r::ConfigOptionBoolsTempl< NULLABLE >::serialize(), Slic3r::ConfigOptionFloatsTempl< NULLABLE >::serialize(), Slic3r::ConfigOptionSingle< T >::value, Slic3r::ConfigOptionVector< double >::values, and Slic3r::ConfigOptionVector< unsigned char >::values.

Referenced by Slic3r::GUI::Sidebar::auto_calc_flushing_volumes_internal(), WipingDialog::BuildTableObjStr(), WipingDialog::CalcFlushingVolumes(), Slic3r::CLI::run(), and Slic3r::GUI::CalibUtils::set_for_auto_pa_model_and_config().

Here is the call graph for this function:

Here is the caller graph for this function:

get_min_layer_height()

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::DynamicConfig::opt_float().

Referenced by Slic3r::GUI::ObjectList::add_layer_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_distance(), calc_surface_offset(), do_local_z_rotate(), face_selected_volume_to_camera(), get_model_instance(), get_model_instance(), get_model_instance(), anonymous_namespace{EmbossJob.cpp}::start_create_volume_on_surface_job(), and anonymous_namespace{SurfaceDrag.cpp}::start_dragging().

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 calc_distance(), face_selected_volume_to_camera(), get_model_instance(), get_model_object(), get_model_object(), and anonymous_namespace{SurfaceDrag.cpp}::start_dragging().

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/6]

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.

Here is the call graph for this function:

get_model_volume() [2/6]

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/6]

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/6]

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

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

References get_model_volume(), and Slic3r::ObjectBase::id().

Here is the call graph for this function:

get_model_volume() [5/6]

ModelVolume * Slic3r::GUI::get_model_volume ( const Selection & selection, Model & model )

static

{
    const Selection::IndicesList &idxs = selection.get_volume_idxs();
    // only one selected volume
    if (idxs.size() != 1) return nullptr;
    const GLVolume *selected_volume = selection.get_volume(*idxs.begin());
    if (selected_volume == nullptr) return nullptr;
 
    const GLVolume::CompositeID &cid  = selected_volume->composite_id;
    const ModelObjectPtrs       &objs = model.objects;
    if (cid.object_id < 0 || objs.size() <= static_cast<size_t>(cid.object_id)) return nullptr;
    const ModelObject *obj = objs[cid.object_id];
    if (cid.volume_id < 0 || obj->volumes.size() <= static_cast<size_t>(cid.volume_id)) return nullptr;
    return obj->volumes[cid.volume_id];
}

References Slic3r::GLVolume::composite_id, 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::MenuFactory::append_menu_item_edit_svg(), Slic3r::GUI::MenuFactory::append_menu_item_edit_text(), Slic3r::GUI::GLGizmoSimplify::apply_simplify(), calc_angle(), calc_distance(), calc_surface_offset(), Slic3r::GUI::GLGizmoSVG::calculate_scale(), anonymous_namespace{EmbossJob.cpp}::check(), create_meshes(), do_local_z_rotate(), anonymous_namespace{SurfaceDrag.cpp}::dragging(), face_selected_volume_to_camera(), Slic3r::GUI::TextureDisplacementPrepareJob::finalize(), anonymous_namespace{EmbossJob.cpp}::find_closest(), Slic3r::GUI::GLGizmoBrimEars::first_layer_slicer(), anonymous_namespace{SurfaceDrag.cpp}::get_fix_transformation(), get_model_volume(), get_model_volume(), get_model_volume(), get_model_volume(), get_selected_volume(), anonymous_namespace{GLGizmoEmboss.cpp}::init_text_lines(), Slic3r::GUI::GLGizmoEmboss::on_mouse(), Slic3r::GUI::GLGizmoSVG::on_mouse(), Slic3r::GUI::GLGizmoEmboss::on_mouse_change_selection(), Slic3r::GUI::GLGizmoEmboss::on_render(), Slic3r::GUI::GLGizmoSimplify::on_render(), Slic3r::GUI::GLGizmoSVG::on_render(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoSimplify::on_render_input_window(), Slic3r::GUI::Plater::priv::on_right_click(), Slic3r::GUI::GLGizmoBrimEars::register_single_mesh_pick(), Slic3r::GUI::GLGizmoEmboss::set_volume_by_selection(), Slic3r::GUI::GLGizmoSVG::set_volume_by_selection(), Slic3r::GUI::ObjectList::set_volume_type(), anonymous_namespace{EmbossJob.cpp}::start_create_volume_on_surface_job(), anonymous_namespace{SurfaceDrag.cpp}::start_dragging(), anonymous_namespace{EmbossJob.cpp}::update_volume(), and world_matrix_fixed().

Here is the call graph for this function:

Here is the caller graph for this function:

get_model_volume() [6/6]

ModelVolume * Slic3r::GUI::get_model_volume ( const Selection & selection, Model & model )

static

{
    const Selection::IndicesList& idxs = selection.get_volume_idxs();
    // only one selected volume
    if (idxs.size() != 1)
        return nullptr;
    const GLVolume* selected_volume = selection.get_volume(*idxs.begin());
    if (selected_volume == nullptr)
        return nullptr;
 
    const GLVolume::CompositeID& cid = selected_volume->composite_id;
    const ModelObjectPtrs& objs = model.objects;
    if (cid.object_id < 0 || objs.size() <= static_cast<size_t>(cid.object_id))
        return nullptr;
    const ModelObject* obj = objs[cid.object_id];
    if (cid.volume_id < 0 || obj->volumes.size() <= static_cast<size_t>(cid.volume_id))
        return nullptr;
    return obj->volumes[cid.volume_id];
}

References Slic3r::GLVolume::composite_id, 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.

Here is the call graph for this function:

get_name_from_gizmo_etype()

std::string Slic3r::GUI::get_name_from_gizmo_etype

(

GLGizmosManager::EType

type

)

{
    switch (type) {
    case GLGizmosManager::EType::Move:
        return "Move";
    case GLGizmosManager::EType::Rotate:
        return "Rotate";
    case GLGizmosManager::EType::Scale:
        return "Scale";
    case GLGizmosManager::EType::Flatten:
        return "Flatten";
    case GLGizmosManager::EType::Cut:
        return "Cut";
    case GLGizmosManager::EType::MeshBoolean:
        return "MeshBoolean";
    case GLGizmosManager::EType::FdmSupports:
        return "FdmSupports";
    case GLGizmosManager::EType::Seam:
        return "Seam";
    case GLGizmosManager::EType::Emboss:
        return "Text";
    case GLGizmosManager::EType::MmSegmentation:
        return "Color Painting";
    case GLGizmosManager::EType::FuzzySkin:
        return "Fuzzy Skin Painting";
    case GLGizmosManager::EType::TextureDisplacement:
        return "Texture Displacement";
    default:
        return "";
    }
    return "";
}

References Slic3r::GUI::GLGizmosManager::Cut, Slic3r::GUI::GLGizmosManager::Emboss, Slic3r::GUI::GLGizmosManager::FdmSupports, Slic3r::GUI::GLGizmosManager::Flatten, Slic3r::GUI::GLGizmosManager::FuzzySkin, Slic3r::GUI::GLGizmosManager::MeshBoolean, Slic3r::GUI::GLGizmosManager::MmSegmentation, Slic3r::GUI::GLGizmosManager::Move, Slic3r::GUI::GLGizmosManager::Rotate, Slic3r::GUI::GLGizmosManager::Scale, Slic3r::GUI::GLGizmosManager::Seam, and Slic3r::GUI::GLGizmosManager::TextureDisplacement.

get_new_added_presets() [1/2]

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_new_added_presets() [2/2]

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().

Here is the call graph for this function:

get_nozzle_filament_incompatible_text()

std::string & Slic3r::GUI::get_nozzle_filament_incompatible_text

(

)

                                                   {
    static std::string nozzle_filament_incompatible_text;
    return nozzle_filament_incompatible_text;
}

References get_nozzle_filament_incompatible_text().

Referenced by Slic3r::GUI::GLCanvas3D::_set_warning_notification(), get_nozzle_filament_incompatible_text(), and Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

get_nozzle_volume_type_cloud_string()

std::string Slic3r::GUI::get_nozzle_volume_type_cloud_string

(

NozzleVolumeType

nozzle_volume_type

)

{
    if (nozzle_volume_type == NozzleVolumeType::nvtStandard) {
        return "standard_flow";
    }
    else if (nozzle_volume_type == NozzleVolumeType::nvtHighFlow) {
        return "high_flow";
    }
    else if (nozzle_volume_type == NozzleVolumeType::nvtTPUHighFlow) {
        return "tpu_high_flow";
    }
    else if (nozzle_volume_type == NozzleVolumeType::nvtE3DHighFlow) {
        return "e3d_high_flow";
    }
    else if (nozzle_volume_type == NozzleVolumeType::nvtHybrid) {
        // to be supported
        return "hybrid_flow";
    }
    else {
        assert(false);
        return "";
    }
}

References Slic3r::nozzle_volume_type(), Slic3r::nvtE3DHighFlow, Slic3r::nvtHighFlow, Slic3r::nvtHybrid, Slic3r::nvtStandard, and Slic3r::nvtTPUHighFlow.

Referenced by Slic3r::GUI::SelectMachineDialog::build_nozzles_info(), and Slic3r::GUI::SyncAmsInfoDialog::build_nozzles_info().

Here is the call graph for this function:

Here is the caller graph for this function:

get_nozzle_volume_type_name()

wxString Slic3r::GUI::get_nozzle_volume_type_name

(

NozzleVolumeType

type

)

{
    if (NozzleVolumeType::nvtStandard == type) {
        return _L("Standard");
    } else if (NozzleVolumeType::nvtHighFlow == type) {
        return _L("High Flow");
    } else if (NozzleVolumeType::nvtHybrid == type) {
        return _L("Hybrid");
    } else if (NozzleVolumeType::nvtTPUHighFlow == type) {
        return _L("TPU High Flow");
    } else if (NozzleVolumeType::nvtE3DHighFlow == type) {
        return _L("E3D High Flow");
    } else if (NozzleVolumeType::nvtExtraHighFlow == type) {
        return _L("Extra High Flow");
    }
    return wxString();
}

References _L, Slic3r::nvtE3DHighFlow, Slic3r::nvtExtraHighFlow, Slic3r::nvtHighFlow, Slic3r::nvtHybrid, Slic3r::nvtStandard, and Slic3r::nvtTPUHighFlow.

Referenced by Slic3r::GUI::UnsavedChangesDialog::build(), Slic3r::GUI::CaliPASaveAutoPanel::sync_cali_result_for_multi_extruder(), and Slic3r::GUI::HistoryWindow::sync_history_data().

Here is the caller graph for this function:

get_obj_calibration_mode() [1/3]

CalibMode Slic3r::GUI::get_obj_calibration_mode

(

const MachineObject *

obj

)

{
    CalibrationMethod method;
    int cali_stage;
    return get_obj_calibration_mode(obj, method, cali_stage);
}

References get_obj_calibration_mode().

Referenced by get_obj_calibration_mode(), get_obj_calibration_mode(), Slic3r::GUI::CalibrationWizard::on_cali_go_home(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::FlowRateWizard::on_device_connected(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_device_connected(), Slic3r::GUI::PressureAdvanceWizard::on_device_connected(), Slic3r::GUI::CalibrationCaliPage::set_cali_img(), Slic3r::GUI::CalibrationCaliPage::update(), and Slic3r::GUI::StatusPanel::update_subtask().

Here is the call graph for this function:

Here is the caller graph for this function:

get_obj_calibration_mode() [2/3]

CalibMode Slic3r::GUI::get_obj_calibration_mode	(	const MachineObject *	obj,
		CalibrationMethod &	method,
		int &	cali_stage )

{
    method = CalibrationMethod::CALI_METHOD_MANUAL;
 
    if (!obj) return CalibMode::Calib_None;
 
    if (boost::contains(obj->m_gcode_file, "auto_filament_cali")) {
        method = CalibrationMethod::CALI_METHOD_AUTO;
        return CalibMode::Calib_PA_Line;
    }
    if (boost::contains(obj->m_gcode_file, "user_cali_manual_pa")) {
        method = CalibrationMethod::CALI_METHOD_MANUAL;
        return CalibMode::Calib_PA_Line;
    }
    if (boost::contains(obj->m_gcode_file, "extrusion_cali")) {
        method = CalibrationMethod::CALI_METHOD_MANUAL;
        return CalibMode::Calib_PA_Line;
    }
 
    if (boost::contains(obj->m_gcode_file, "abs_flowcalib_cali")) {
        method = CalibrationMethod::CALI_METHOD_AUTO;
        return CalibMode::Calib_Flow_Rate;
    }
 
    if (obj->get_printer_series() == PrinterSeries::SERIES_P1P) {
        if (boost::contains(obj->subtask_name, "auto_filament_cali")) {
            method = CalibrationMethod::CALI_METHOD_AUTO;
            return CalibMode::Calib_PA_Line;
        }
        if (boost::contains(obj->subtask_name, "user_cali_manual_pa")) {
            method = CalibrationMethod::CALI_METHOD_MANUAL;
            return CalibMode::Calib_PA_Line;
        }
        if (boost::contains(obj->subtask_name, "extrusion_cali")) {
            method = CalibrationMethod::CALI_METHOD_MANUAL;
            return CalibMode::Calib_PA_Line;
        }
 
        if (boost::contains(obj->subtask_name, "abs_flowcalib_cali")) {
            method = CalibrationMethod::CALI_METHOD_AUTO;
            return CalibMode::Calib_Flow_Rate;
        }
    }
 
    CalibMode cali_mode = CalibUtils::get_calib_mode_by_name(obj->subtask_name, cali_stage);
    if (cali_mode == CalibMode::Calib_PA_Line && cali_stage == 2) {
        method = CalibrationMethod::CALI_METHOD_NEW_AUTO;
    }
    else if (cali_mode != CalibMode::Calib_None) {
        method = CalibrationMethod::CALI_METHOD_MANUAL;
    }
    return cali_mode;
}

References CALI_METHOD_AUTO, CALI_METHOD_MANUAL, CALI_METHOD_NEW_AUTO, Slic3r::Calib_Flow_Rate, Slic3r::Calib_None, Slic3r::Calib_PA_Line, Slic3r::GUI::CalibUtils::get_calib_mode_by_name(), Slic3r::MachineObject::get_printer_series(), Slic3r::MachineObject::m_gcode_file, SERIES_P1P, and Slic3r::MachineObject::subtask_name.

Here is the call graph for this function:

get_obj_calibration_mode() [3/3]

CalibMode Slic3r::GUI::get_obj_calibration_mode	(	const MachineObject *	obj,
		int &	cali_stage )

{
    CalibrationMethod method;
    return get_obj_calibration_mode(obj, method, cali_stage);
}

References get_obj_calibration_mode().

Here is the call graph for this function:

get_object_clashed_text()

std::string & Slic3r::GUI::get_object_clashed_text

(

)

                                     {
    static std::string object_clashed_text = _u8L("An object is laid over the boundary of plate or exceeds the height limit.\n"
            "Please solve the problem by moving it totally on or off the plate, and confirming that the height is within the build volume.");
    return object_clashed_text;
}

References _u8L, and get_object_clashed_text().

Referenced by Slic3r::GUI::GLCanvas3D::_set_warning_notification(), Slic3r::GUI::GLCanvas3D::check_volumes_outside_state(), get_object_clashed_text(), Slic3r::GUI::GLCanvas3D::reload_scene(), and Slic3r::GUI::Plater::validate_current_plate().

Here is the call graph for this function:

Here is the caller graph for this function:

get_object_limited_text()

std::string & Slic3r::GUI::get_object_limited_text

(

)

                                     {
    static std::string object_limited_text = _u8L("An object is placed in the left/right nozzle-only area or exceeds the printable height of the left nozzle.\n"
            "Please ensure the filaments used by this object are not arranged to other nozzles.");
    return object_limited_text;
}

References _u8L, and get_object_limited_text().

Referenced by Slic3r::GUI::GLCanvas3D::_set_warning_notification(), and get_object_limited_text().

Here is the call graph for this function:

Here is the caller graph for this function:

get_option_label()

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_orca_cloud_agent()

std::shared_ptr< OrcaCloudServiceAgent > Slic3r::GUI::get_orca_cloud_agent ( NetworkAgent * agent )

static

{
    return agent ? std::dynamic_pointer_cast<OrcaCloudServiceAgent>(agent->get_cloud_agent()) : nullptr;
}

References Slic3r::NetworkAgent::get_cloud_agent().

Referenced by cloud_page_url(), Slic3r::GUI::GUI_App::cloud_webview_handoff(), Slic3r::GUI::GUI_App::mint_cloud_web_session(), Slic3r::GUI::GUI_App::on_cloud_web_session_minted(), Slic3r::GUI::GUI_App::request_cloud_web_session(), and Slic3r::GUI::GUI_App::request_user_logout().

Here is the call graph for this function:

Here is the caller graph for this function:

get_physical_extruder_idx()

int Slic3r::GUI::get_physical_extruder_idx ( std::vector< int > physical_extruder_maps, int extruder_id )

static

{
    for (size_t index = 0; index < physical_extruder_maps.size(); ++index) {
        if (physical_extruder_maps[index] == extruder_id) {
            return index;
        }
    }
    return extruder_id;
}

get_pop_up_remind_flag()

bool Slic3r::GUI::get_pop_up_remind_flag ( )

static

{
    auto &app_config = wxGetApp().app_config;
    return app_config->get_bool("pop_up_filament_map_dialog");
}

get_position()

void Slic3r::GUI::get_position ( wxWindowBase * child, wxWindowBase * until_parent, int & x, int & y )

static

                                                                                          {
    int res_x = 0, res_y = 0;
 
    while (child != until_parent && child != nullptr) {
        int _x, _y;
        child->GetPosition(&_x, &_y);
        res_x += _x;
        res_y += _y;
 
        child = child->GetParent();
    }
 
    x = res_x;
    y = res_y;
}

Referenced by Slic3r::GUI::Plater::priv::show_right_click_menu().

Here is the caller graph for this function:

get_prefered_map_mode()

FilamentMapMode Slic3r::GUI::get_prefered_map_mode ( )

static

{
    const static std::map<std::string, int> enum_keys_map = ConfigOptionEnum<FilamentMapMode>::get_enum_values();
    auto                                   &app_config    = wxGetApp().app_config;
    std::string                             mode_str      = app_config->get("prefered_filament_map_mode");
    auto                                    iter          = enum_keys_map.find(mode_str);
    if (iter == enum_keys_map.end()) {
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format("Could not get prefered_filament_map_mode from app config, use AutoForFlsuh mode");
        return FilamentMapMode::fmmAutoForFlush;
    }
    return FilamentMapMode(iter->second);
}

References Slic3r::fmmAutoForFlush, and Slic3r::ConfigOptionEnum< T >::get_enum_values().

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_preset_collection()

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_PRINTER      ? &preset_bundle->printers :
            type == Preset::Type::TYPE_FILAMENT     ? &preset_bundle->filaments :
            type == Preset::Type::TYPE_SLA_MATERIAL ? &preset_bundle->sla_materials :
            type == Preset::Type::TYPE_PRINT        ? &preset_bundle->prints :
            type == Preset::Type::TYPE_SLA_PRINT    ? &preset_bundle->sla_prints :
            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_info()

bool Slic3r::GUI::get_preset_info ( const DynamicConfig & config, const BedType plate_type, int & nozzle_temp, int & bed_temp, float & max_volumetric_speed )

static

{
    const ConfigOptionInts* nozzle_temp_opt = config.option<ConfigOptionInts>("nozzle_temperature");
    const ConfigOptionInts* opt_bed_temp_ints = config.option<ConfigOptionInts>(get_bed_temp_key(plate_type));
    const ConfigOptionFloats* speed_opt = config.option<ConfigOptionFloats>("filament_max_volumetric_speed");
    if (nozzle_temp_opt && speed_opt && opt_bed_temp_ints) {
        nozzle_temp = nozzle_temp_opt->get_at(0);
        max_volumetric_speed = speed_opt->get_at(0);
        bed_temp = opt_bed_temp_ints->get_at(0);
        if (bed_temp >= 0 && nozzle_temp >= 0 && max_volumetric_speed >= 0) {
            return true;
        }
    }
    return false;
}

References Slic3r::ConfigOptionVector< int >::get_at(), Slic3r::get_bed_temp_key(), and Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::PressureAdvanceWizard::on_cali_save(), Slic3r::GUI::FlowRateWizard::on_cali_start(), and Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

Here is the call graph for this function:

Here is the caller graph for this function:

get_preset_name_by_filament_id()

wxString Slic3r::GUI::get_preset_name_by_filament_id ( std::string filament_id )

static

{
    auto preset_bundle = wxGetApp().preset_bundle;
    auto collection = &preset_bundle->filaments;
    wxString preset_name = "";
    for (auto it = preset_bundle->filaments.begin(); it != preset_bundle->filaments.end(); it++) {
        if (filament_id.compare(it->filament_id) == 0) {
            auto preset_parent = collection->get_preset_parent(*it);
            if (preset_parent) {
                if (preset_parent->is_system) {
                    if (!preset_parent->alias.empty())
                        preset_name = from_u8(preset_parent->alias);
                    else
                        preset_name = from_u8(preset_parent->name);
                }
                else { // is custom created filament
                    std::string name_str = preset_parent->name;
                    preset_name = from_u8(name_str.substr(0, name_str.find(" @")));
                }
            }
            else {
                if (it->is_system) {
                    if (!it->alias.empty())
                        preset_name = from_u8(it->alias);
                    else
                        preset_name = from_u8(it->name);
                }
                else { // is custom created filament
                    std::string name_str = it->name;
                    preset_name = from_u8(name_str.substr(0, name_str.find(" @")));
                }
            }
        }
    }
    return preset_name;
}

References from_u8().

Referenced by Slic3r::GUI::EditCalibrationHistoryDialog::EditCalibrationHistoryDialog(), and Slic3r::GUI::HistoryWindow::sync_history_data().

Here is the call graph for this function:

Here is the caller graph for this function:

get_primitive_mode()

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_LINE_STRIP, GL_LINES, GL_POINTS, 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_printer_nozzle_diameter()

std::string Slic3r::GUI::get_printer_nozzle_diameter ( std::string printer_name )

static

                                                                     {
    // Create a lowercase version of the printer_name for case-insensitive search
    std::string printer_name_lower = printer_name;
    std::transform(printer_name_lower.begin(), printer_name_lower.end(), printer_name_lower.begin(), ::tolower);
 
    size_t index = printer_name_lower.find(" nozzle)");
    if (std::string::npos == index) {
        size_t index = printer_name_lower.find(" nozzle");
        if (std::string::npos == index) {
            return "";
        }
        std::string nozzle = printer_name_lower.substr(0, index);
        size_t      last_space_index = nozzle.find_last_of(" ");
        if (std::string::npos == index) {
            return "";
        }
        return nozzle.substr(last_space_index + 1);
    } else {
        std::string nozzle = printer_name_lower.substr(0, index);
        size_t      last_bracket_index = nozzle.find_last_of("(");
        if (std::string::npos == index) {
            return "";
        }
        return nozzle.substr(last_bracket_index + 1);
    }
}

Referenced by Slic3r::GUI::CreateFilamentPresetDialog::create_filament_preset_item(), and Slic3r::GUI::CreateFilamentPresetDialog::get_filament_presets_by_machine().

Here is the caller graph for this function:

get_printer_preset()

Preset * Slic3r::GUI::get_printer_preset

(

const MachineObject *

obj

)

{
    if (!obj)
        return nullptr;
 
    Preset       *printer_preset = nullptr;
 
    PresetBundle *preset_bundle  = wxGetApp().preset_bundle;
    for (auto printer_it = preset_bundle->printers.begin(); printer_it != preset_bundle->printers.end(); printer_it++) {
        // only use system printer preset
        if (!printer_it->is_system)
            continue;
 
        ConfigOption       *printer_nozzle_opt  = printer_it->config.option("nozzle_diameter");
        ConfigOptionFloats *printer_nozzle_vals = nullptr;
        if (printer_nozzle_opt) printer_nozzle_vals = dynamic_cast<ConfigOptionFloats *>(printer_nozzle_opt);
        std::string model_id = printer_it->get_current_printer_type(preset_bundle);
 
        std::string printer_type = obj->get_show_printer_type();
        bool nozzle_diameter_matches_or_unknown = printer_nozzle_vals && obj->GetExtderSystem()->NozzleDiameterMatchesOrUnknown(0, printer_nozzle_vals->get_at(0));
        if (model_id.compare(printer_type) == 0 && nozzle_diameter_matches_or_unknown) {
            printer_preset = &(*printer_it);
        }
    }
    return printer_preset;
}

References Slic3r::PresetCollection::begin(), Slic3r::PresetCollection::end(), Slic3r::ConfigOptionVector< double >::get_at(), Slic3r::MachineObject::get_show_printer_type(), Slic3r::MachineObject::GetExtderSystem(), Slic3r::DevExtderSystem::NozzleDiameterMatchesOrUnknown(), and Slic3r::PresetBundle::printers.

Referenced by Slic3r::GUI::PresetComboBox::add_connected_printers(), Slic3r::check_filaments_printable(), Slic3r::GUI::PresetComboBox::get_preset_item_name(), Slic3r::GUI::Plater::is_same_printer_for_connected_and_selected(), support_nozzle_volume(), and Slic3r::GUI::Sidebar::priv::sync_extruder_list().

Here is the call graph for this function:

Here is the caller graph for this function:

get_pure_opt_key()

std::string Slic3r::GUI::get_pure_opt_key

(

const std::string &

opt_key

)

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

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

Here is the caller graph for this function:

get_right_extruder_unprintable_text()

std::string & Slic3r::GUI::get_right_extruder_unprintable_text ( )

extern

                                                 {
    static std::string right_unprintable_text;
    return right_unprintable_text;
}

References get_right_extruder_unprintable_text().

Referenced by Slic3r::GUI::GLCanvas3D::_set_warning_notification(), Slic3r::GUI::GLCanvas3D::check_volumes_outside_state(), get_right_extruder_unprintable_text(), Slic3r::GUI::GLCanvas3D::reload_scene(), try_pop_up_before_slice(), and Slic3r::GUI::Plater::validate_current_plate().

Here is the call graph for this function:

Here is the caller graph for this function:

get_root_idx()

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_search_inputs()

std::vector< Search::InputInfo > Slic3r::GUI::get_search_inputs ( ConfigOptionMode mode )

static

{
    std::vector<Search::InputInfo> ret {};
 
    auto& tabs_list = wxGetApp().tabs_list;
    auto print_tech = wxGetApp().preset_bundle->printers.get_selected_preset().printer_technology();
    for (auto tab : tabs_list)
        if (tab->supports_printer_technology(print_tech))
            ret.emplace_back(Search::InputInfo {tab->get_config(), tab->type(), mode});
 
    return ret;
}

Referenced by Slic3r::GUI::Sidebar::update_searcher().

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(), face_selected_volume_to_camera(), anonymous_namespace{SurfaceDrag.cpp}::get_fix_transformation(), get_selected_gl_volume(), get_selected_volume(), Slic3r::GUI::GLGizmoEmboss::on_mouse_for_translate(), Slic3r::GUI::GLGizmoEmboss::set_volume_by_selection(), Slic3r::GUI::GLGizmoSVG::set_volume_by_selection(), anonymous_namespace{SurfaceDrag.cpp}::start_dragging(), 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() [1/2]

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

                                                                                        {
    const Selection::IndicesList &volume_ids = selection.get_volume_idxs();
    const ModelObjectPtrs &model_objects     = selection.get_model()->objects;
    for (auto id : volume_ids) {
        const GLVolume *selected_volume = selection.get_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 (volume_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::ObjectBase::id(), Slic3r::GLVolume::CompositeID::object_id, Slic3r::Model::objects, Slic3r::GLVolume::CompositeID::volume_id, and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

get_selected_volume() [2/2]

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]

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

static

{
    return plater()->get_current_canvas3D(true)->get_selection();
}

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

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_settings(), Slic3r::GUI::MenuFactory::append_menu_items_flush_options(), Slic3r::GUI::DiffPresetDialog::create_presets_sizer(), Slic3r::GUI::DiffPresetDialog::get_left_preset_name(), Slic3r::GUI::DiffPresetDialog::get_right_preset_name(), 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]

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

static

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

References ComboBox::GetSelection(), ComboBox::GetString(), and into_u8().

Here is the call graph for this function:

get_single_extruder_mixed_filament_warning_text()

std::string & Slic3r::GUI::get_single_extruder_mixed_filament_warning_text

(

)

                                                            {
    static std::string single_extruder_mixed_filament_warning_text;
    return single_extruder_mixed_filament_warning_text;
}

References get_single_extruder_mixed_filament_warning_text().

Referenced by Slic3r::GUI::GLCanvas3D::_set_warning_notification(), get_single_extruder_mixed_filament_warning_text(), and Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

get_string_from_enum()

wxString Slic3r::GUI::get_string_from_enum	(	const std::string &	opt_key,
		const DynamicPrintConfig &	config,
		bool	is_infill,
		int	idx )

{
    const ConfigOptionDef& def = config.def()->options.at(opt_key);
    const std::vector<std::string>& names = def.enum_labels;//ConfigOptionEnum<T>::get_enum_names();
    int val = 0;
 
    if (idx >= 0)
        val = dynamic_cast<const ConfigOptionInts*>(config.option(opt_key))->get_at(idx);
    else
        val = config.option(opt_key)->getInt();
 
    // Each infill doesn't use all list of infill declared in PrintConfig.hpp.
    // So we should "convert" val to the correct one
    if (is_infill) {
        for (auto key_val : *def.enum_keys_map)
            if (int(key_val.second) == val) {
                auto it = std::find(def.enum_values.begin(), def.enum_values.end(), key_val.first);
                if (it == def.enum_values.end())
                    return "";
                return from_u8(_utf8(names[it - def.enum_values.begin()]));
            }
        return _L("Undefined");
    }
    if (val < 0 || val >= int(names.size()))
        return _L("Undefined");
    return from_u8(_utf8(names[val]));
}

References _L, _utf8, Slic3r::DynamicPrintConfig::def(), Slic3r::ConfigOptionDef::enum_keys_map, Slic3r::ConfigOptionDef::enum_labels, Slic3r::ConfigOptionDef::enum_values, from_u8(), Slic3r::ConfigOption::getInt(), Slic3r::is_infill(), Slic3r::ConfigBase::option(), and Slic3r::ConfigDef::options.

Referenced by get_string_value().

Here is the call graph for this function:

Here is the caller graph for this function:

get_string_value()

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

{
    int orig_opt_idx = -1;
    int opt_idx = -1;
    int pos = opt_key.find("#");
    std::string temp_str = opt_key;
    if (pos > 0) {
        boost::erase_head(temp_str, pos + 1);
        orig_opt_idx = std::atoi(temp_str.c_str());
    }
    opt_idx = orig_opt_idx >= 0 ? orig_opt_idx : 0;
    const std::string pure_key = get_pure_opt_key(opt_key);
    auto option = config.option(pure_key);
    if (!option) {
        return _L("N/A");
    }
    auto opt_vector = dynamic_cast<const ConfigOptionVectorBase *>(option);
 
    if ((option->is_scalar() && option->is_nil()) ||
        (option->is_vector() && opt_vector && opt_idx >= 0 && opt_idx < opt_vector->size() && opt_vector->is_nil(opt_idx)))
        return _L("N/A");
 
    wxString out;
 
    const ConfigOptionDef* opt = config.def()->get(pure_key);
    bool is_nullable = opt->nullable;
 
    switch (opt->type) {
    case coInt:
        return from_u8((boost::format("%1%") % config.opt_int(pure_key)).str());
    case coInts: {
        if (is_nullable) {
            auto values = config.opt<ConfigOptionIntsNullable>(pure_key);
            if (opt_idx < values->size())
                return from_u8((boost::format("%1%") % values->get_at(opt_idx)).str());
        }
        else {
            auto values = config.opt<ConfigOptionInts>(pure_key);
            if (orig_opt_idx >= 0 && orig_opt_idx < values->size()) {
                return from_u8((boost::format("%1%") % values->get_at(opt_idx)).str());
            }
            else {
                std::string value_str;
                for (int i = 0; i < values->size(); i++) {
                    value_str += std::to_string(values->get_at(i));
                    if (i != values->size() - 1) {
                        value_str += ",";
                    }
                }
                return from_u8(value_str);
            }
        }
        return _L("Undefined");
    }
    case coBool:
        return config.opt_bool(pure_key) ? "true" : "false";
    case coBools: {
        if (is_nullable) {
            auto values = config.opt<ConfigOptionBoolsNullable>(pure_key);
            if (opt_idx < values->size())
                return values->get_at(opt_idx) ? "true" : "false";
        }
        else {
            auto values = config.opt<ConfigOptionBools>(pure_key);
            if (opt_idx < values->size())
                return values->get_at(opt_idx) ? "true" : "false";
        }
        return _L("Undefined");
    }
    case coPercent:
        return from_u8((boost::format("%1%%%") % int(config.optptr(pure_key)->getFloat())).str());
    case coPercents: {
        if (is_nullable) {
            auto values = config.opt<ConfigOptionPercentsNullable>(pure_key);
            if (opt_idx < values->size())
                return from_u8((boost::format("%1%%%") % values->get_at(opt_idx)).str());
        }
        else {
            auto values = config.opt<ConfigOptionPercents>(pure_key);
            if (opt_idx < values->size())
                return from_u8((boost::format("%1%%%") % values->get_at(opt_idx)).str());
        }
        return _L("Undefined");
    }
    case coFloat:
        return double_to_string(config.opt_float(pure_key));
    case coFloats: {
        if (is_nullable) {
            auto values = config.opt<ConfigOptionFloatsNullable>(pure_key);
            if (opt_idx < values->size())
                return double_to_string(values->get_at(opt_idx));
        }
        else {
            auto values = config.opt<ConfigOptionFloats>(pure_key);
            if (values && opt_idx < values->size())
                return double_to_string(values->get_at(opt_idx));
        }
        return _L("Undefined");
    }
    case coString:
        return from_u8(config.opt_string(pure_key));
    case coStrings: {
        const ConfigOptionStrings* strings = config.opt<ConfigOptionStrings>(pure_key);
        if (strings) {
            if (pure_key == "compatible_printers" || pure_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 (!strings->empty() && opt_idx < strings->values.size())
                return from_u8(strings->get_at(opt_idx));
        }
        break;
        }
    case coFloatOrPercent: {
        const ConfigOptionFloatOrPercent* opt = config.opt<ConfigOptionFloatOrPercent>(pure_key);
        if (opt)
            out = double_to_string(opt->value) + (opt->percent ? "%" : "");
        return out;
    }
    case coFloatsOrPercents: {
        const auto* values = static_cast<const ConfigOptionVector<FloatOrPercent>*>(option);
        // Orca: Preset comparison may request the entire vector instead of an indexed entry.
        if (orig_opt_idx < 0)
            return from_u8(option->serialize());
        if (opt_idx < values->size()) {
            const FloatOrPercent& value = values->get_at(opt_idx);
            return double_to_string(value.value) + (value.percent ? "%" : "");
        }
        return _L("Undefined");
    }
    case coEnum: {
        return get_string_from_enum(pure_key, config,
            pure_key == "top_surface_pattern" ||
            pure_key == "bottom_surface_pattern" ||
            pure_key == "internal_solid_infill_pattern" ||
            pure_key == "sparse_infill_pattern" ||
            pure_key == "ironing_pattern" ||
            pure_key == "support_ironing_pattern" ||
            pure_key == "support_pattern" ||
            pure_key == "support_interface_pattern")
            ;
    }
    case coEnums: {
        if (!opt_vector || opt_idx >= opt_vector->size())
            return _L("Undefined");
        return get_string_from_enum(pure_key, config,
            pure_key == "top_surface_pattern" ||
            pure_key == "bottom_surface_pattern" ||
            pure_key == "internal_solid_infill_pattern" ||
            pure_key == "sparse_infill_pattern" ||
            pure_key == "ironing_pattern" ||
            pure_key == "support_ironing_pattern" ||
            pure_key == "support_pattern" ||
            pure_key == "support_interface_pattern"
            , opt_idx);
    }
    case coPoint: {
        Vec2d val = config.opt<ConfigOptionPoint>(pure_key)->value;
        return from_u8((boost::format("[%1%]") % ConfigOptionPoint(val).serialize()).str());
    }
    case coPoints: {
        //BBS: add bed_exclude_area
        if (pure_key == "printable_area" || pure_key == "thumbnails") {
            ConfigOptionPoints points = *config.option<ConfigOptionPoints>(pure_key);
            //BuildVolume build_volume = {points.values, 0.};
            return get_thumbnails_string(points.values);
        }
        else if (pure_key == "bed_exclude_area") {
            return from_u8(config.option<ConfigOptionPoints>(pure_key)->serialize());
        }
        else if (pure_key == "head_wrap_detect_zone") {
            return get_thumbnails_string(config.option<ConfigOptionPoints>(pure_key)->values);
        }
        else if (pure_key == "wrapping_exclude_area") {
            return get_thumbnails_string(config.option<ConfigOptionPoints>(pure_key)->values);
        }
        Vec2d val = config.opt<ConfigOptionPoints>(pure_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::coEnums, Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coFloats, Slic3r::coFloatsOrPercents, Slic3r::coInt, Slic3r::coInts, Slic3r::coPercent, Slic3r::coPercents, Slic3r::coPoint, Slic3r::coPoints, Slic3r::coString, Slic3r::coStrings, Slic3r::DynamicPrintConfig::def(), double_to_string(), Slic3r::ConfigOptionVector< T >::empty(), from_u8(), Slic3r::ConfigDef::get(), Slic3r::ConfigOptionVector< T >::get_at(), get_pure_opt_key(), get_string_from_enum(), get_thumbnails_string(), Slic3r::ConfigOption::getFloat(), Slic3r::DynamicConfig::opt(), Slic3r::DynamicConfig::opt_bool(), Slic3r::DynamicConfig::opt_float(), Slic3r::DynamicConfig::opt_int(), Slic3r::DynamicConfig::opt_string(), Slic3r::ConfigBase::option(), Slic3r::DynamicConfig::optptr(), Slic3r::FloatOrPercent::percent, serialize(), Slic3r::ConfigOptionPoints::serialize(), Slic3r::ConfigOptionVector< T >::size(), Slic3r::FloatOrPercent::value, and Slic3r::ConfigOptionVector< T >::values.

Referenced by Slic3r::GUI::PublishSettingsDialog::build_option_model(), 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_system_info()

std::string Slic3r::GUI::get_system_info

(

)

{
    std::stringstream out;
 
    std::string b_start  = "";
    std::string b_end    = "";
    std::string line_end = "\n";
 
    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(), get_system_info(), and Slic3r::total_physical_memory().

Referenced by get_system_info(), and Slic3r::GUI::GUI_App::on_init_inner().

Here is the call graph for this function:

Here is the caller graph for this function:

get_text_extent()

void Slic3r::GUI::get_text_extent	(	const wxString &	msg,
		wxCoord &	w,
		wxCoord &	h,
		wxFont *	font )

{
  wxMemoryDC memDC;
  if (font)
    memDC.SetFont(*font);
  memDC.GetTextExtent(msg, &w, &h);
}

Referenced by find_font().

Here is the caller graph for this function:

get_thumbnail_string()

wxString Slic3r::GUI::get_thumbnail_string

(

const Vec2d &

value

)

{
    wxString ret_str = wxString::Format("%.2fx%.2f", value[0], value[1]);
    return ret_str;
}

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

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(), Slic3r::GUI::ConfigOptionsGroup::get_config_value2(), get_string_value(), and Slic3r::GUI::Field::get_value_by_opt_type().

Here is the caller graph for this function:

get_transform_string()

std::string Slic3r::GUI::get_transform_string ( int bytes )

inline

{
  float ms = (float)bytes / 1024.0f / 1024.0f;
  float ks = (float)bytes / 1024.0f;
  char buffer[32];
  if (ms > 0)
    ::sprintf(buffer, "%.1fM", ms);
  else if (ks > 0)
    ::sprintf(buffer, "%.1fK", ks);
  else
    ::sprintf(buffer, "%.1fK", ks);
  return buffer;
}

get_tray_ams_and_slot_id()

void Slic3r::GUI::get_tray_ams_and_slot_id	(	MachineObject *	obj,
		int	in_tray_id,
		int &	ams_id,
		int &	slot_id,
		int &	tray_id )

{
    assert(obj);
    if (!obj)
        return;
 
    if (in_tray_id == VIRTUAL_TRAY_MAIN_ID || in_tray_id == VIRTUAL_TRAY_DEPUTY_ID) {
        ams_id  = in_tray_id;
        slot_id = 0;
        tray_id = ams_id;
        if (!obj->is_enable_np)
            tray_id = VIRTUAL_TRAY_DEPUTY_ID;
    } else {
        ams_id  = in_tray_id / 4;
        slot_id = in_tray_id % 4;
        tray_id = in_tray_id;
    }
}

References Slic3r::MachineObject::is_enable_np, VIRTUAL_TRAY_DEPUTY_ID, and VIRTUAL_TRAY_MAIN_ID.

Referenced by Slic3r::GUI::CalibrationWizard::cache_preset_info(), Slic3r::GUI::CalibrationPresetPage::get_extruder_id_by_tray_id(), Slic3r::GUI::CalibrationPresetPage::is_filament_in_blacklist(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_start(), and Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

Here is the caller graph for this function:

get_tray_name_by_tray_id()

wxString Slic3r::GUI::get_tray_name_by_tray_id ( int tray_id )

static

{
    wxString tray_name;
    if (tray_id == VIRTUAL_TRAY_MAIN_ID || tray_id == VIRTUAL_TRAY_DEPUTY_ID) {
        tray_name = _L("Ext");
    }
    else {
        int  ams_id = tray_id / 4;
        int slot_id = tray_id % 4;
        if (ams_id >= 0 && ams_id < 26) {
            char prefix = 'A' + ams_id;
            char suffix = '0' + 1 + slot_id;
            tray_name = std::string(1, prefix) + std::string(1, suffix);
        } else if (ams_id >= 128 && ams_id < 153) {
            char prefix = 'A' + ams_id - 128;
            tray_name   = std::string(1, prefix);
        }
    }
    return tray_name;
}

References _L, VIRTUAL_TRAY_DEPUTY_ID, and VIRTUAL_TRAY_MAIN_ID.

Referenced by Slic3r::GUI::CalibrationFlowX1SavePage::sync_cali_result(), Slic3r::GUI::CaliPASaveAutoPanel::sync_cali_result(), and Slic3r::GUI::CaliPASaveAutoPanel::sync_cali_result_for_multi_extruder().

Here is the caller graph for this function:

get_type()

ParamType Slic3r::GUI::get_type ( const std::string & opt_key, const ConfigOptionDef & opt_def )

static

{
    return opt_def.is_scalar() ? ParamType::Scalar : ParamType::Vector;
}

References Slic3r::ConfigOptionDef::is_scalar(), Scalar, and Vector.

Referenced by Slic3r::GUI::EditGCodeDialog::init_params_list().

Here is the call graph for this function:

Here is the caller graph for this function:

get_unique_id()

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;
}

Referenced by generate_system_info_json().

Here is the caller graph for this function:

get_utf8_seq_length() [1/2]

int Slic3r::GUI::get_utf8_seq_length ( const char * seq, size_t size )

static

{
  int length = 0;
  unsigned char c = seq[0];
  if (c < 0x80) { // 0x00-0x7F
    // is ASCII letter
    length++;
  }
  // Bytes 0x80 to 0xBD are trailer bytes in a multibyte sequence.
  // pos is in the middle of a utf-8 sequence. Add the utf-8 trailer bytes.
  else if (c < 0xC0) { // 0x80-0xBF
    length++;
    while (length < size) {
      c = seq[length];
      if (c < 0x80 || c >= 0xC0) {
        break; // prevent overrun
      }
      length++; // add a utf-8 trailer byte
    }
  }
  // Bytes 0xC0 to 0xFD are header bytes in a multibyte sequence.
  // The number of one bits above the topmost zero bit indicates the number of bytes (including this one) in the whole sequence.
  else if (c < 0xE0) { // 0xC0-0xDF
   // add a utf-8 sequence (2 bytes)
    if (2 > size) {
      return size; // prevent overrun
    }
    length += 2;
  }
  else if (c < 0xF0) { // 0xE0-0xEF
   // add a utf-8 sequence (3 bytes)
    if (3 > size) {
      return size; // prevent overrun
    }
    length += 3;
  }
  else if (c < 0xF8) { // 0xF0-0xF7
   // add a utf-8 sequence (4 bytes)
    if (4 > size) {
      return size; // prevent overrun
    }
    length += 4;
  }
  else if (c < 0xFC) { // 0xF8-0xFB
   // add a utf-8 sequence (5 bytes)
    if (5 > size) {
      return size; // prevent overrun
    }
    length += 5;
  }
  else if (c < 0xFE) { // 0xFC-0xFD
   // add a utf-8 sequence (6 bytes)
    if (6 > size) {
      return size; // prevent overrun
    }
    length += 6;
  }
  else { // 0xFE-0xFF
   // not a utf-8 sequence
    length++;
  }
  return length;
}

References Slic3r::length().

Referenced by Slic3r::GUI::NotificationManager::HintNotification::count_lines(), and get_utf8_seq_length().

Here is the call graph for this function:

Here is the caller graph for this function:

get_utf8_seq_length() [2/2]

int Slic3r::GUI::get_utf8_seq_length ( const std::string & text, size_t pos )

static

{
  assert(pos < text.size());
  return get_utf8_seq_length(text.c_str() + pos, text.size() - pos);
}

References get_utf8_seq_length().

Here is the call graph for this function:

get_vendor_name() [1/2]

std::string Slic3r::GUI::get_vendor_name ( std::string & preset_name )

static

{
    if (preset_name.empty()) return "";
    std::string vendor_name = preset_name.substr(preset_name.find_first_not_of(' ')); //remove the name prefix space
    size_t index_at = vendor_name.find(" ");
    if (std::string::npos == index_at) {
        return vendor_name;
    } else {
        vendor_name = vendor_name.substr(0, index_at);
        return vendor_name;
    }
}

Referenced by Slic3r::GUI::ExportConfigsDialog::data_init(), and Slic3r::GUI::ExportPresetBundleDialog::InitExportData().

Here is the caller graph for this function:

get_vendor_name() [2/2]

std::string Slic3r::GUI::get_vendor_name ( std::string & preset_name )

static

{
    if (preset_name.empty())
        return "";
    std::string vendor_name = preset_name.substr(preset_name.find_first_not_of(' ')); // remove the name prefix space
    size_t index_at         = vendor_name.find(" ");
    if (std::string::npos == index_at) {
        return vendor_name;
    } else {
        vendor_name = vendor_name.substr(0, index_at);
        return vendor_name;
    }
}

get_version()

Semver Slic3r::GUI::get_version	(	const std::string &	str,
		const std::regex &	regexp )

                                                                 {
    std::smatch match;
    if (std::regex_match(str, match, regexp)) {
        std::string version_cleaned = match[0];
        const boost::optional<Semver> version = Semver::parse(version_cleaned);
        if (version.has_value()) {
            return *version;
        }
    }
    return Semver::invalid();
}

References get_version(), Slic3r::Semver::invalid(), and Slic3r::Semver::parse().

Referenced by Slic3r::GUI::GUI_App::check_new_version_sf(), generate_system_info_json(), and get_version().

Here is the call graph for this function:

Here is the caller graph for this function:

get_view_type_string() [1/2]

wxString Slic3r::GUI::get_view_type_string

(

Camera::ViewAngleType

type

)

                                                        {
    switch (type) {
    case Slic3r::GUI::Camera::ViewAngleType::Iso: return _L("isometric");
    case Slic3r::GUI::Camera::ViewAngleType::Top_Front: return _L("top_front");
    case Slic3r::GUI::Camera::ViewAngleType::Left: return _L("left");
    case Slic3r::GUI::Camera::ViewAngleType::Right: return _L("right");
    case Slic3r::GUI::Camera::ViewAngleType::Top: return _L("top");
    case Slic3r::GUI::Camera::ViewAngleType::Bottom: return _L("bottom");
    case Slic3r::GUI::Camera::ViewAngleType::Front: return _L("front");
    case Slic3r::GUI::Camera::ViewAngleType::Rear: return _L("rear");
    default: return "";
    }
}

References _L, Slic3r::GUI::Camera::Bottom, Slic3r::GUI::Camera::Front, Slic3r::GUI::Camera::Iso, Slic3r::GUI::Camera::Left, Slic3r::GUI::Camera::Rear, Slic3r::GUI::Camera::Right, Slic3r::GUI::Camera::Top, and Slic3r::GUI::Camera::Top_Front.

get_view_type_string() [2/2]

std::string Slic3r::GUI::get_view_type_string ( libvgcode::EViewType view_type )

static

{
    if (view_type == libvgcode::EViewType::Summary)
        return _u8L("Summary");
    else if (view_type == libvgcode::EViewType::FeatureType)
        return _u8L("Line Type");
    else if (view_type == libvgcode::EViewType::Height)
        return _u8L("Layer Height");
    else if (view_type == libvgcode::EViewType::Width)
        return _u8L("Line Width");
    else if (view_type == libvgcode::EViewType::Speed)
        return _u8L("Speed");
    else if (view_type == libvgcode::EViewType::ActualSpeed)
        return _u8L("Actual Speed");
    else if (view_type == libvgcode::EViewType::Acceleration)
        return _u8L("Acceleration");
    else if (view_type == libvgcode::EViewType::Jerk)
        return _u8L("Jerk");
    else if (view_type == libvgcode::EViewType::FanSpeed)
        return _u8L("Fan Speed");
    else if (view_type == libvgcode::EViewType::Temperature)
        return _u8L("Temperature");
    else if (view_type == libvgcode::EViewType::VolumetricFlowRate)
        return _u8L("Flow");
    else if (view_type == libvgcode::EViewType::ActualVolumetricFlowRate)
        return _u8L("Actual Flow");
    else if (view_type == libvgcode::EViewType::Tool)
        return _u8L("Tool");
    else if (view_type == libvgcode::EViewType::ColorPrint)
        return _u8L("Filament");
    else if (view_type == libvgcode::EViewType::LayerTimeLinear)
        return _u8L("Layer Time");
    else if (view_type == libvgcode::EViewType::LayerTimeLogarithmic)
        return _u8L("Layer Time (log)");
// ORCA: Add Pressure Advance visualization support
    else if (view_type == libvgcode::EViewType::PressureAdvance)
        return _u8L("Pressure Advance");
    return "";
}

References _u8L, libvgcode::Acceleration, libvgcode::ActualSpeed, libvgcode::ActualVolumetricFlowRate, libvgcode::ColorPrint, libvgcode::FanSpeed, libvgcode::FeatureType, libvgcode::Height, libvgcode::Jerk, libvgcode::LayerTimeLinear, libvgcode::LayerTimeLogarithmic, libvgcode::PressureAdvance, libvgcode::Speed, libvgcode::Summary, libvgcode::Temperature, libvgcode::Tool, libvgcode::VolumetricFlowRate, and libvgcode::Width.

Referenced by Slic3r::GUI::GCodeViewer::default_view_type_choices(), get_all_camera_view_type(), and Slic3r::GUI::GCodeViewer::update_by_mode().

Here is the caller graph for this function:

get_volume()

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

                                                                               {
    const ModelObjectPtrs &objects = selection.get_model()->objects;
    for (const ModelObject *object : objects) {
        for (ModelVolume *volume : object->volumes) {
            if (volume->id() == volume_id)
                return volume;
        }        
    }
    return nullptr;
}

References Slic3r::GUI::Selection::get_model(), Slic3r::ObjectBase::id(), and Slic3r::Model::objects.

Here is the call graph for this function:

get_warning_icon_name()

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

static

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

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(), Slic3r::GUI::ObjectList::split(), 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()

WipeTower Slic3r::GUI::get_wipe_tower ( const Plater & plater, int plate_idx )

static

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

References plater().

Referenced by get_wipe_tower_arrangepoly(), Slic3r::GUI::ArrangeJob::prepare_partplate(), and Slic3r::GUI::ArrangeJob::prepare_wipe_tower().

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

)

{
    int id = plater.canvas3D()->fff_print()->get_plate_index();
    if (auto wti = get_wipe_tower(plater, id))
        return get_wipetower_arrange_poly(&wti);
 
    return {};
}

References get_wipe_tower(), get_wipetower_arrange_poly(), and plater().

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_wipetower_arrange_poly()

arrangement::ArrangePolygon Slic3r::GUI::get_wipetower_arrange_poly

(

WipeTower *

tower

)

{
    ArrangePolygon ap = tower->get_arrange_polygon();
    ap.bed_idx = 0;
    ap.setter = NULL; // do not move wipe tower
    return ap;
}

References Slic3r::arrangement::ArrangePolygon::bed_idx, Slic3r::GUI::WipeTower::get_arrange_polygon(), and Slic3r::arrangement::ArrangePolygon::setter.

Referenced by get_wipe_tower_arrangepoly(), Slic3r::GUI::ArrangeJob::prepare_partplate(), and Slic3r::GUI::ArrangeJob::prepare_wipe_tower().

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::EditGCodeDialog::selection_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

getExtruderNozzleCount()

int Slic3r::GUI::getExtruderNozzleCount	(	PresetBundle *	preset_bundle,
		int	extruder_id,
		NozzleVolumeType	volume_type )

{
    if (!preset_bundle)
        return 0;
    auto *opt = preset_bundle->printers.get_edited_preset().config.option<ConfigOptionStrings>("extruder_nozzle_stats");
    if (!opt)
        return 0;
    const auto stats = get_extruder_nozzle_stats(opt->values);
    if (extruder_id < 0 || extruder_id >= (int) stats.size())
        return 0;
    const auto it = stats[extruder_id].find(volume_type);
    return it == stats[extruder_id].end() ? 0 : it->second;
}

References Slic3r::Preset::config, Slic3r::PresetCollection::get_edited_preset(), Slic3r::get_extruder_nozzle_stats(), Slic3r::ConfigBase::option(), and Slic3r::PresetBundle::printers.

Referenced by Slic3r::GUI::Plater::priv::check_ams_status_impl(), manuallySetNozzleCount(), Slic3r::GUI::FilamentMapManualPanel::OnTimer(), Slic3r::GUI::FilamentMapManualPanel::UpdateNozzleCountDisplay(), and updateNozzleCountDisplay().

Here is the call graph for this function:

Here is the caller graph for this function:

getExtruderNozzleCountTotal()

int Slic3r::GUI::getExtruderNozzleCountTotal	(	PresetBundle *	preset_bundle,
		int	extruder_id )

{
    if (!preset_bundle)
        return 0;
    auto *opt = preset_bundle->printers.get_edited_preset().config.option<ConfigOptionStrings>("extruder_nozzle_stats");
    if (!opt)
        return 0;
    const auto stats = get_extruder_nozzle_stats(opt->values);
    if (extruder_id < 0 || extruder_id >= (int) stats.size())
        return 0;
    int sum = 0;
    for (const auto &kv : stats[extruder_id])
        sum += kv.second;
    return sum;
}

References Slic3r::Preset::config, Slic3r::PresetCollection::get_edited_preset(), Slic3r::get_extruder_nozzle_stats(), Slic3r::ConfigBase::option(), and Slic3r::PresetBundle::printers.

Referenced by manuallySetNozzleCount(), onNozzleVolumeTypeSwitch(), Slic3r::GUI::FilamentMapManualPanel::UpdateNozzleCountDisplay(), and updateNozzleCountDisplay().

Here is the call graph for this function:

Here is the caller graph for this function:

GetIntersectionOfRayAndPlane()

Vec3d Slic3r::GUI::GetIntersectionOfRayAndPlane	(	Vec3d	ray_position,
		Vec3d	ray_dir,
		Vec3d	plane_position,
		Vec3d	plane_normal )

{
    double t = (plane_normal.dot(plane_position) - plane_normal.dot(ray_position)) / (plane_normal.dot(ray_dir));
    Vec3d  intersection = ray_position + t * ray_dir;
    return intersection;
}

References Slic3r::intersection().

Referenced by Slic3r::GUI::GLGizmoScale3D::calc_ratio().

Here is the call graph for this function:

Here is the caller graph for this function:

GetNumberFromUser()

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:

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);
    return std::string((value != nullptr) ? value : default_value);
}

References glGetString.

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__
 
    //BBS: remove the try-catch and let exception goto above
    try {
        //GUI::GUI_App* gui = new GUI::GUI_App(params.start_as_gcodeviewer ? GUI::GUI_App::EAppMode::GCodeViewer : GUI::GUI_App::EAppMode::Editor);
        GUI::GUI_App* gui = new GUI::GUI_App();
        //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("app", "single_instance") == "true";
            if (Slic3r::instance_check(params.argc, params.argv, gui_single_instance_setting)) {
                //TODO: do we have delete gui and other stuff?
                return -1;
            }
        //}
 
//      gui->autosave = m_config.opt_string("autosave");
        GUI::GUI_App::SetInstance(gui);
        gui->init_params = &params;
 
        if (params.argc > 1) {
            // STUDIO-273 wxWidgets report error when opening some files with specific names
            // wxWidgets does not handle parameters, so intercept parameters here, only keep the app name
            int                 argc = 1;
            std::vector<char *> argv;
            argv.push_back(params.argv[0]);
            return wxEntry(argc, argv.data());
        } else {
            return wxEntry(params.argc, params.argv);
        }
    } catch (const Slic3r::Exception &ex) {
        BOOST_LOG_TRIVIAL(error) << ex.what() << std::endl;
        wxMessageBox(boost::nowide::widen(ex.what()), _L("Orca Slicer GUI initialization failed"), wxICON_STOP);
    } catch (const std::exception &ex) {
        BOOST_LOG_TRIVIAL(error) << ex.what() << std::endl;
        wxMessageBox(format_wxstr(_L("Fatal error, exception: %1%"), ex.what()), _L("Orca Slicer 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, format_wxstr(), Slic3r::AppConfig::get(), Slic3r::GUI::GUI_App::init_params, and Slic3r::instance_check().

Referenced by Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

guide_strings()

json Slic3r::GUI::guide_strings ( )

static

{
    return {
        {"loading", _u8L("Loading…")},
        // TRN Sidebar entry of the printer selection page for the group of custom (user-defined) printers.
        {"custom_vendor", _u8L_CONTEXT("Custom", "Printer vendor")},
        {"welcome", _u8L("Welcome to Orca Slicer")},
        {"setup_intro", _u8L("Orca Slicer will be set up in several steps. Let's start!")},
        {"get_started", _u8L("Get Started")},
        {"login_region", _u8L("Please select your login region")},
        {"asia_pacific", _u8L("Asia-Pacific")},
        {"china", _u8L("China")},
        {"europe", _u8L("Europe")},
        {"north_america", _u8L("North America")},
        {"others", _u8L_CONTEXT("Others", "Region")},
        {"back", _u8L_CONTEXT("Back", "Navigation")},
        {"next", _u8L("Next")},
        {"finish", _u8L("Finish")},
        {"confirm", _u8L("Confirm")},
        {"cancel", _u8L("Cancel")},
        {"ok", _u8L("OK")},
        {"yes", _u8L("Yes")},
        {"no", _u8L("No")},
        {"error", _u8L("Error")},
        {"information", _u8L("Information")},
        {"printer_selection", _u8L("Printer Selection")},
        {"vendors", _u8L("Vendors")},
        {"search", _u8L("Search")},
        {"custom_printer", _u8L("Custom Printer")},
        {"nozzle", _u8L("Nozzle")},
        {"create", _u8L("Create")},
        {"check_new_printers", _u8L("Check for new printers")},
        {"printer_required", _u8L("At least one printer must be selected.")},
        {"new_printers_found", _u8L("New printers found")},
        {"new_vendors_installed", _u8L("New printer vendors installed: %s")},
        {"vendors_declined", _u8L("New printer vendors were found, but installation was cancelled.")},
        {"no_new_printers", _u8L("No new printers found.")},
        {"filament_selection", _u8L("Filament Selection")},
        {"system_filaments", _u8L("System Filaments")},
        {"custom_filaments", _u8L("Custom Filaments")},
        {"create_new", _u8L("Create New")},
        {"printer", _u8L("Printer")},
        {"filament_type", _u8L("Filament type")},
        {"vendor", _u8L("Vendor")},
        {"all", _u8L("All")},
        {"no_items", _u8L("No items")},
        {"filter_items", _u8L("Filter items")},
        {"checked", _u8L("Checked")},
        {"unchecked", _u8L("Unchecked")},
        {"select_filtered", _u8L("Select filtered")},
        {"select_visible", _u8L("Select visible")},
        {"clear_all", _u8L("Clear all")},
        {"filament_required", _u8L("At least one filament must be selected.")},
        {"use_default_filament", _u8L("Do you want to use the default filament?")},
        {"stealth_mode", _u8L("Stealth Mode")},
        {"stealth_mode_desc", _u8L("This disables all cloud features, including Orca Cloud profile syncing. Users who prefer to work entirely offline can enable this option.")},
        {"stealth_mode_note", _u8L("Note: When Stealth Mode is enabled, your user profiles will not be backed up to Orca Cloud.")},
        {"enable_stealth_mode", _u8L("Enable Stealth Mode.")},
        {"proprietary_plugins", _u8L("Proprietary Plugins")},
        {"proprietary_plugins_desc", _u8L("Some printer vendors require proprietary plugins for communication with their printers. Please select the corresponding plugin if you use such printers.")},
        {"proprietary_plugins_risk", _u8L("Please be aware that these plugins are not developed or maintained by OrcaSlicer. They should be used at your own discretion and risk.")},
        {"install_bambu_plugin", _u8L("Install Bambu Network plug-in")},
    };
}

References _u8L, and _u8L_CONTEXT.

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

Here is the caller graph for this function:

has_cjk()

bool Slic3r::GUI::has_cjk

(

const std::string &

text

)

{
    for (size_t i = 0; i + 2 < text.size(); ++i) {
        unsigned char c1 = text[i];
        unsigned char c2 = text[i + 1];
        unsigned char c3 = text[i + 2];
 
        if ((c1 & 0xF0) == 0xE0 && (c2 & 0xC0) == 0x80 && (c3 & 0xC0) == 0x80) {
            int codepoint = ((c1 & 0x0F) << 12 | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
            if (codepoint >= 0x3000 && codepoint <= 0x9FFF) { return true; }
        }
    }
    return false;
}

Referenced by Slic3r::GUI::DailyTipsDataRenderer::render_text().

Here is the caller graph for this function:

has_filaments()

bool Slic3r::GUI::has_filaments

(

const std::vector< std::string > &

model_filaments

)

                                                                {
    auto &filament_presets = Slic3r::GUI::wxGetApp().preset_bundle->filament_presets;
    if (!Slic3r::GUI::wxGetApp().plater()) return false;
    auto model_objects = Slic3r::GUI::wxGetApp().plater()->model().objects;
    const Slic3r::DynamicPrintConfig &config = wxGetApp().preset_bundle->full_config();
    Model::setExtruderParams(config, filament_presets.size());
 
    auto get_filament_name = [](int id) { return Model::extruderParamsMap.find(id) != Model::extruderParamsMap.end() ? Model::extruderParamsMap.at(id).materialName : "PLA"; };
    for (const ModelObject *mo : model_objects) {
        for (auto vol : mo->volumes) {
            auto ve = vol->get_extruders();
            for (auto id : ve) {
                auto name = get_filament_name(id);
                if (find(model_filaments.begin(), model_filaments.end(), name) != model_filaments.end()) return true;
            }
        }
    }
    return false;
}

References Slic3r::Model::extruderParamsMap, get_filament_name(), has_filaments(), plater(), Slic3r::Model::setExtruderParams(), and Slic3r::DynamicConfig::size().

Referenced by has_filaments(), is_support_filament(), Slic3r::GUI::Tab::on_value_change(), and wxDECLARE_EVENT().

Here is the call graph for this function:

Here is the caller graph for this function:

has_importable_texture()

bool Slic3r::GUI::has_importable_texture ( const Slic3r::TexturedMesh & textured_mesh )

static

{
    if (textured_mesh.vertices.empty() || textured_mesh.indices.empty())
        return false;
 
    if (!textured_mesh.precomputed_face_colors.empty())
        return true;
 
    return std::any_of(textured_mesh.textures.begin(), textured_mesh.textures.end(),
        [](const Slic3r::TextureImage& texture) { return !texture.data.empty(); });
}

References Slic3r::TexturedMesh::indices, Slic3r::TexturedMesh::precomputed_face_colors, Slic3r::TexturedMesh::textures, and Slic3r::TexturedMesh::vertices.

Referenced by Slic3r::GUI::Plater::priv::load_files(), and Slic3r::GUI::Plater::priv::run_textured_mesh_import_dialog().

Here is the caller graph for this function:

has_junction_deviation()

bool Slic3r::GUI::has_junction_deviation ( const DynamicPrintConfig * printer_config )

static

{
    if (!printer_config) {
        return false;
    }
    const auto gcode_flavor = printer_config->option<ConfigOptionEnum<GCodeFlavor>>("gcode_flavor");
    const auto junction_dev = printer_config->option<ConfigOptionFloats>("machine_max_junction_deviation");
    return gcode_flavor &&
           gcode_flavor->value == GCodeFlavor::gcfMarlinFirmware &&
           junction_dev &&
           !junction_dev->values.empty() &&
           junction_dev->values.front() > 0.0;
}

References Slic3r::gcfMarlinFirmware, Slic3r::gcode_flavor(), and printer_config().

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern(), Slic3r::GUI::Plater::Calib_Cornering(), Slic3r::GUI::Plater::calib_input_shaping_damp(), and Slic3r::GUI::Plater::calib_input_shaping_freq().

Here is the call graph for this function:

Here is the caller graph for this function:

Hex2Color()

wxColor Slic3r::GUI::Hex2Color

(

const std::string &

str

)

{
    if (str.empty() || (str.length() != 9 && str.length() != 7) || str[0] != '#')
        throw std::invalid_argument("Invalid hex color format");
 
    auto hexToByte = [](const std::string& hex)->unsigned char
        {
            unsigned int byte;
            std::istringstream(hex) >> std::hex >> byte;
            return static_cast<unsigned char>(byte);
        };
    auto r = hexToByte(str.substr(1, 2));
    auto g = hexToByte(str.substr(3, 2));
    auto b = hexToByte(str.substr(5, 2));
    unsigned char a = 255;
    if (str.size() == 9)
        a = hexToByte(str.substr(7, 2));
    return wxColor(r, g, b, a);
}

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

Here is the caller graph for this function:

hex_digit_to_int()

int Slic3r::GUI::hex_digit_to_int ( const char c )

inline

{
    return
        (c >= '0' && c <= '9') ? int(c - '0') :
        (c >= 'A' && c <= 'F') ? int(c - 'A') + 10 :
        (c >= 'a' && c <= 'f') ? int(c - 'a') + 10 : -1;
}

Referenced by decode_color(), Slic3r::GUI::BitmapCache::parse_color(), and Slic3r::GUI::BitmapCache::parse_color4().

Here is the caller graph for this function:

hex_to_int()

int Slic3r::GUI::hex_to_int ( const char c )

inline

{
    return (c >= '0' && c <= '9') ? int(c - '0') : (c >= 'A' && c <= 'F') ? int(c - 'A') + 10 : (c >= 'a' && c <= 'f') ? int(c - 'a') + 10 : -1;
}

hex_to_wx_colour()

wxColour Slic3r::GUI::hex_to_wx_colour ( const std::string & hex, const wxColour & fallback )

static

{
    wxColour color(hex);
    return color.IsOk() ? color : fallback;
}

Referenced by to_dialog_result(), and Slic3r::GUI::ColorDecomposeDialog::try_build_single_base_result().

Here is the caller graph for this function:

hide_id_middle_string()

wxString Slic3r::GUI::hide_id_middle_string	(	wxString const &	str,
		size_t	offset = 0,
		size_t	length = -1 )

{
#if BBL_RELEASE_TO_PUBLIC
    if (length == size_t(-1)) length = str.Length() - offset;
    if (length <= 8) return str;
    return str.Left(offset + 4) + wxString(length - 8, '*') + str.Mid(offset + length - 4);
#else
    return str;
#endif
}

References Slic3r::length(), and Slic3r::offset().

Referenced by hide_passwd(), Slic3r::GUI::MediaPlayCtrl::Play(), and Slic3r::GUI::MediaPlayCtrl::ToggleStream().

Here is the call graph for this function:

Here is the caller graph for this function:

hide_passwd()

wxString Slic3r::GUI::hide_passwd ( wxString url, std::vector< wxString > const & passwords )

extern

{
#if BBL_RELEASE_TO_PUBLIC
    for (auto &p : passwords) {
        auto i = url.find(p);
        if (i == wxString::npos)
            continue;
        auto j = i + p.length();
        if (p[p.length() - 1] == '=') {
            i = j;
            j = url.find('&', i);
            if (j == wxString::npos) j = url.length();
        }
        auto l = size_t(j - i);
        if (p[0] == '?' || p[0] == '&')
            url = hide_id_middle_string(url, i, l);
        else if (j == url.length() || url[j] == '@' || url[j] == '&')
            url.replace(i, l, l, wxUniChar('*'));
    }
#endif
    return url;
}

References hide_id_middle_string().

Referenced by Slic3r::GUI::MediaFilePanel::fetchUrl(), Slic3r::GUI::SendToPrinterDialog::GetConnection(), Slic3r::GUI::MediaPlayCtrl::Play(), and Slic3r::GUI::MediaPlayCtrl::ToggleStream().

Here is the call graph for this function:

Here is the caller graph for this function:

highlight()

void Slic3r::GUI::highlight ( wxString & str )

static

{
#if defined(SUPPORTS_MARKUP) && !defined(__APPLE__)
    str = format_wxstr("<span bgcolor=\"#009688\">%1%</span>", str);
#endif
}

References format_wxstr().

Referenced by Slic3r::GUI::ParamsNode::GetFormattedText(), Slic3r::GUI::DragShape::paint(), and Slic3r::GUI::GCodeViewer::SequentialView::Marker::render_position_window().

Here is the call graph for this function:

Here is the caller graph for this function:

home_page_strings()

json Slic3r::GUI::home_page_strings ( )

static

{
    return {
        {"login", _u8L("Login")},
        // TRN Short badge on a recent project that was published (a published 3MF). Keep it about three letters long.
        {"published_badge", _u8L("PUB")},
        {"not_signed_in", _u8L("Not signed in")},
        {"plugin_not_detected", _u8L("Bambu Network plug-in not detected. Click <a>here</a> to install it.")},
        {"log_out", _u8L("Log Out")},
        {"recent", _u8L("Recent")},
        {"new_project", _u8L("New Project")},
        {"create_new_project", _u8L("Create new project")},
        {"open_project", _u8L("Open Project")},
        {"recently_opened", _u8L("Recently opened")},
        {"clear_all", _u8L("Clear all")},
        {"remove", _u8L("Remove")},
        {"show_in_folder", _u8L("Show in folder")},
    };
}

References _u8L.

Referenced by Slic3r::GUI::WebViewPanel::create_browser().

Here is the caller graph for this function:

http_origin_of()

wxString Slic3r::GUI::http_origin_of ( const wxString & url )

static

{
    const wxURI uri(url);
    if (!uri.HasScheme() || !uri.HasServer())
        return {};
    const wxString scheme = uri.GetScheme().Lower();
    if (scheme != "http" && scheme != "https")
        return {};
    wxString origin = scheme + "://" + uri.GetServer().Lower();
    const wxString port = uri.GetPort();
    if (!port.IsEmpty() && port != (scheme == "https" ? "443" : "80"))
        origin += ":" + port;
    return origin;
}

Referenced by Slic3r::GUI::WebViewPanel::is_cloud_origin(), Slic3r::GUI::WebViewPanel::load_cloud_url(), and Slic3r::GUI::WebViewPanel::should_divert_cloud_url().

Here is the caller graph for this function:

image_button_ex()

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 ImRect.

Referenced by Slic3r::GUI::ImGuiWrapper::image_button().

Here is the caller graph for this function:

imex_grid_shape()

void Slic3r::GUI::imex_grid_shape ( const DynamicPrintConfig * cfg, int & n_cols, int & n_rows, int & layout )

static

{
    n_cols = std::max(1, imex_cfg_int(*cfg, "imex_tools_per_gantry"));
    n_rows = std::max(1, imex_cfg_int(*cfg, "imex_gantry_count"));
    layout = IMEXModesCtrl::parse_layout(imex_cfg_enum<ImexToolLayout>(*cfg, "imex_tool_layout"));
}

References Slic3r::imex_cfg_enum(), Slic3r::imex_cfg_int(), imex_grid_shape(), and Slic3r::GUI::IMEXModesCtrl::parse_layout().

Referenced by Slic3r::GUI::TabPrinter::build_unregular_pages(), imex_grid_shape(), Slic3r::GUI::TabPrinter::reload_config(), and Slic3r::GUI::TabPrinter::update_fff().

Here is the call graph for this function:

Here is the caller graph for this function:

import_texture_to_library()

std::optional< TextureLibraryEntry > Slic3r::GUI::import_texture_to_library	(	const std::string &	source_path,
		std::string &	error )

{
    wxImage image;
    if (!image.LoadFile(from_u8(source_path)) || !image.IsOk()) {
        error = _u8L("Could not load the selected image.");
        return std::nullopt;
    }
 
    std::vector<unsigned char> bytes;
    if (!encode_png_bytes(image, bytes, error))
        return std::nullopt;
 
    return write_user_texture(bytes, boost::filesystem::path(source_path).stem().string(), error);
}

References _u8L, and from_u8().

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::import_custom_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

index_from_plane()

int Slic3r::GUI::index_from_plane ( const SketchPlane & p )

static

{
    if (std::abs(p.normal.y()) > 0.5) return 1; // XZ
    if (std::abs(p.normal.x()) > 0.5) return 2; // YZ
    return 0;                                   // XY
}

References Slic3r::SketchPlane::normal.

Referenced by Slic3r::GUI::DesignPanel::DesignPanel(), is_base_plane(), and Slic3r::GUI::DesignPanel::load_feature_into_dialog().

Here is the caller graph for this function:

init_arrange_params()

arrangement::ArrangeParams Slic3r::GUI::init_arrange_params

(

Plater *

p

)

{
    arrangement::ArrangeParams         params;
    GLCanvas3D::ArrangeSettings       &settings     = p->canvas3D()->get_arrange_settings();
    auto                              &print        = wxGetApp().plater()->get_partplate_list().get_current_fff_print();
    const PrintConfig                 &print_config = print.config();
 
    auto [object_skirt_offset, object_skirt_witdh] = print.object_skirt_offset();
 
    params.clearance_height_to_rod             = print_config.extruder_clearance_height_to_rod.value;
    params.clearance_height_to_lid             = print_config.extruder_clearance_height_to_lid.value;
    params.clearance_radius                    = print_config.extruder_clearance_radius.value + object_skirt_offset * 2;
    params.object_skirt_offset                 = object_skirt_offset;
    params.printable_height                    = print_config.printable_height.value;
    params.allow_rotations                     = settings.enable_rotation;
    params.nozzle_height                       = print_config.nozzle_height.value;
    params.align_center                        = print_config.best_object_pos.value;
    params.allow_multi_materials_on_same_plate = settings.allow_multi_materials_on_same_plate;
    params.avoid_extrusion_cali_region         = settings.avoid_extrusion_cali_region;
    params.is_seq_print                        = settings.is_seq_print;
    params.min_obj_distance                    = scaled(settings.distance);
    params.align_to_y_axis                     = settings.align_to_y_axis;
    if (print_config.belt_printer.value) {
        // Parts print in belt order: the belt runs across the gantry's tilt axis, a
        // rotation about X prints toward +Y and one about Y toward -X (see
        // BeltTransform), a negative angle flips that, and a tilted layer reaches
        // cot(angle) * height past a part's far edge.
        const BeltRotationAxis axis   = print_config.belt_slice_rotation.value;
        const double           angle  = print_config.belt_slice_rotation_angle.value;
        const bool             tilted = (axis == BeltRotationAxis::X || axis == BeltRotationAxis::Y) && std::abs(angle) > EPSILON;
        params.is_belt         = true;
        params.belt_axis       = axis == BeltRotationAxis::Y ? 0 : 1;
        params.belt_reversed   = tilted && ((axis == BeltRotationAxis::Y) != (angle < 0.));
        params.belt_tilt_slope = tilted ? float(1. / std::tan(Geometry::deg2rad(std::clamp(std::abs(angle), 5., 90.)))) : 0.f;
    }
 
    int state = p->get_prepare_state();
    if (state == Job::JobPrepareState::PREPARE_STATE_MENU) {
        PartPlateList &plate_list = p->get_partplate_list();
        PartPlate *    plate      = plate_list.get_curr_plate();
        bool plate_same_as_global = true;
        params.is_seq_print       = plate->get_real_print_seq(&plate_same_as_global) == PrintSequence::ByObject;
        // if plate's print sequence is not the same as global, the settings.distance is no longer valid, we set it to auto
        if (!plate_same_as_global)
            params.min_obj_distance = 0;
    }
 
    if (params.is_seq_print) {
        params.bed_shrink_x = BED_SHRINK_SEQ_PRINT;
        params.bed_shrink_y = BED_SHRINK_SEQ_PRINT;
    }
    return params;
}

References Slic3r::arrangement::ArrangeParams::align_center, Slic3r::arrangement::ArrangeParams::align_to_y_axis, Slic3r::GUI::GLCanvas3D::ArrangeSettings::align_to_y_axis, Slic3r::arrangement::ArrangeParams::allow_multi_materials_on_same_plate, Slic3r::GUI::GLCanvas3D::ArrangeSettings::allow_multi_materials_on_same_plate, Slic3r::arrangement::ArrangeParams::allow_rotations, Slic3r::angle(), Slic3r::arrangement::ArrangeParams::avoid_extrusion_cali_region, Slic3r::GUI::GLCanvas3D::ArrangeSettings::avoid_extrusion_cali_region, BED_SHRINK_SEQ_PRINT, Slic3r::arrangement::ArrangeParams::bed_shrink_x, Slic3r::arrangement::ArrangeParams::bed_shrink_y, Slic3r::arrangement::ArrangeParams::belt_axis, Slic3r::arrangement::ArrangeParams::belt_reversed, Slic3r::arrangement::ArrangeParams::belt_tilt_slope, Slic3r::ByObject, Slic3r::GUI::Plater::canvas3D(), Slic3r::arrangement::ArrangeParams::clearance_height_to_lid, Slic3r::arrangement::ArrangeParams::clearance_height_to_rod, Slic3r::arrangement::ArrangeParams::clearance_radius, Slic3r::Geometry::deg2rad(), Slic3r::GUI::GLCanvas3D::ArrangeSettings::distance, Slic3r::GUI::GLCanvas3D::ArrangeSettings::enable_rotation, EPSILON, Slic3r::GUI::GLCanvas3D::get_arrange_settings(), Slic3r::GUI::PartPlateList::get_curr_plate(), Slic3r::GUI::Plater::get_partplate_list(), Slic3r::GUI::Plater::get_prepare_state(), Slic3r::GUI::PartPlate::get_real_print_seq(), Slic3r::arrangement::ArrangeParams::is_belt, Slic3r::arrangement::ArrangeParams::is_seq_print, Slic3r::GUI::GLCanvas3D::ArrangeSettings::is_seq_print, Slic3r::arrangement::ArrangeParams::min_obj_distance, Slic3r::arrangement::ArrangeParams::nozzle_height, Slic3r::arrangement::ArrangeParams::object_skirt_offset, Slic3r::GUI::Job::PREPARE_STATE_MENU, Slic3r::arrangement::ArrangeParams::printable_height, Slic3r::scaled(), Slic3r::X, and Slic3r::Y.

Referenced by Slic3r::GUI::Plater::find_new_position(), 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:

init_bitmap_dc()

BitmapDC Slic3r::GUI::init_bitmap_dc ( const wxSize & size )

static

                                                   {
    return BitmapDC(size);
}

Referenced by create_dual_filament_bitmap(), create_gradient_filament_bitmap(), create_gradient_ramp_bitmap(), create_quadruple_filament_bitmap(), create_single_filament_bitmap(), create_transparent_bitmap(), and create_triple_filament_bitmap().

Here is the caller graph for this function:

init_exclusion_volume_prism_model()

bool Slic3r::GUI::init_exclusion_volume_prism_model ( GLModel & model, const std::vector< ExclusionVolumePrismPreview > & prisms )

static

{
    model.reset();
    if (prisms.empty())
        return true;
 
    GLModel::Geometry init_data;
    init_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3 };
 
    for (const ExclusionVolumePrismPreview &prism : prisms) {
        const Polygon &polygon = prism.footprint;
        const float z_min = static_cast<float>(prism.z_min);
        const float z_max = static_cast<float>(prism.z_max);
        if (polygon.points.size() < 3 || z_max <= z_min)
            continue;
 
        init_data.reserve_vertices(init_data.vertices_count() + 4 * polygon.points.size());
        init_data.reserve_indices(init_data.indices_count() + 6 * polygon.points.size());
        for (size_t i = 0; i < polygon.points.size(); ++i) {
            const Point &p0 = polygon.points[i];
            const Point &p1 = polygon.points[(i + 1) % polygon.points.size()];
 
            init_data.add_vertex(Vec3f(unscale<float>(p0.x()), unscale<float>(p0.y()), z_min));
            init_data.add_vertex(Vec3f(unscale<float>(p1.x()), unscale<float>(p1.y()), z_min));
            init_data.add_vertex(Vec3f(unscale<float>(p1.x()), unscale<float>(p1.y()), z_max));
            init_data.add_vertex(Vec3f(unscale<float>(p0.x()), unscale<float>(p0.y()), z_max));
 
            const unsigned int base = (unsigned int)init_data.vertices_count() - 4;
            init_data.add_triangle(base, base + 1, base + 2);
            init_data.add_triangle(base, base + 2, base + 3);
        }
 
        const ExPolygon expolygon = expolygon_from_polygon(polygon);
        const std::vector<Vec2f> triangles = triangulate_expolygon_2f(expolygon, NORMALS_UP);
        init_data.reserve_vertices(init_data.vertices_count() + triangles.size());
        init_data.reserve_indices(init_data.indices_count() + triangles.size());
        const unsigned int cap_base = (unsigned int)init_data.vertices_count();
        for (const Vec2f &v : triangles)
            init_data.add_vertex(Vec3f(v.x(), v.y(), z_max));
        for (size_t i = 0; i + 2 < triangles.size(); i += 3)
            init_data.add_triangle(cap_base + (unsigned int)i, cap_base + (unsigned int)i + 1, cap_base + (unsigned int)i + 2);
    }
 
    if (!init_data.is_empty())
        model.init_from(std::move(init_data));
 
    return true;
}

References Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), expolygon_from_polygon(), Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::GLModel::Geometry::indices_count(), Slic3r::GUI::GLModel::init_from(), Slic3r::GUI::GLModel::Geometry::is_empty(), Slic3r::NORMALS_UP, Slic3r::GUI::GLModel::Geometry::P3, Slic3r::MultiPoint::points, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::GUI::GLModel::reset(), Slic3r::GUI::GLModel::Geometry::Triangles, Slic3r::triangulate_expolygon_2f(), Slic3r::unscale(), and Slic3r::GUI::GLModel::Geometry::vertices_count().

Referenced by Slic3r::GUI::PartPlate::update_exclusion_volume_preview_models().

Here is the call graph for this function:

Here is the caller graph for this function:

init_from_angle_arc()

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, 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(), and Slic3r::GUI::GLModel::reset().

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()

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(), 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(), 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()

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());
}

References Slic3r::GUI::GLModel::Geometry::add_line(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::angle(), Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::GLModel::init_from(), Slic3r::GUI::GLModel::Geometry::Lines, Slic3r::GUI::GLModel::Geometry::P3, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), ScaleLongEvery, ScaleLongTooth, ScaleStepRad, ScaleStepsCount, Slic3r::GUI::GLModel::set_color(), 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_snap_radii()

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(), 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(), 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_model_from_expolygons()

bool Slic3r::GUI::init_model_from_expolygons ( GLModel & model, const ExPolygons & expolygons, float z )

static

{
    model.reset();
    if (expolygons.empty())
        return true;
 
    GLModel::Geometry init_data;
    init_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3T2 };
 
    for (const ExPolygon &expolygon : expolygons) {
        if (expolygon.contour.points.size() < 3)
            continue;
 
        append_expolygon_triangles(init_data, expolygon, z);
    }
 
    if (!init_data.is_empty())
        model.init_from(std::move(init_data));
 
    return true;
}

References append_expolygon_triangles(), Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::GLModel::init_from(), Slic3r::GUI::GLModel::Geometry::is_empty(), Slic3r::GUI::GLModel::Geometry::P3T2, Slic3r::GUI::GLModel::reset(), and Slic3r::GUI::GLModel::Geometry::Triangles.

Referenced by Slic3r::GUI::PartPlate::update_exclusion_volume_preview_models().

Here is the call graph for this function:

Here is the caller graph for this function:

init_model_from_lines() [1/2]

bool Slic3r::GUI::init_model_from_lines ( GLModel & model, const Lines & lines, float z )

static

{
 
    GLModel::Geometry init_data;
    init_data.format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3 };
    init_data.reserve_vertices(2 * lines.size());
    init_data.reserve_indices(2 * lines.size());
 
    for (const auto &l : lines) {
        init_data.add_vertex(Vec3f(unscale<float>(l.a.x()), unscale<float>(l.a.y()), z));
        init_data.add_vertex(Vec3f(unscale<float>(l.b.x()), unscale<float>(l.b.y()), z));
        const unsigned int vertices_counter = (unsigned int)init_data.vertices_count();
        init_data.add_line(vertices_counter - 2, vertices_counter - 1);
    }
 
    model.init_from(std::move(init_data));
 
    return true;
}

References Slic3r::GUI::GLModel::Geometry::add_line(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::GLModel::init_from(), Slic3r::GUI::GLModel::Geometry::Lines, Slic3r::GUI::GLModel::Geometry::P3, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::unscale(), and Slic3r::GUI::GLModel::Geometry::vertices_count().

Referenced by Slic3r::GUI::PartPlate::calc_gridlines(), and Slic3r::GUI::PartPlate::calc_height_limit().

Here is the call graph for this function:

Here is the caller graph for this function:

init_model_from_lines() [2/2]

bool Slic3r::GUI::init_model_from_lines ( GLModel & model, const Lines3 & lines )

static

{
 
    GLModel::Geometry init_data;
    init_data.format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3 };
    init_data.reserve_vertices(2 * lines.size());
    init_data.reserve_indices(2 * lines.size());
 
    for (const auto &l : lines) {
        init_data.add_vertex(Vec3f(unscale<float>(l.a.x()), unscale<float>(l.a.y()), unscale<float>(l.a.z())));
        init_data.add_vertex(Vec3f(unscale<float>(l.b.x()), unscale<float>(l.b.y()), unscale<float>(l.b.z())));
        const unsigned int vertices_counter = (unsigned int) init_data.vertices_count();
        init_data.add_line(vertices_counter - 2, vertices_counter - 1);
    }
 
    model.init_from(std::move(init_data));
 
    return true;
}

References Slic3r::GUI::GLModel::Geometry::add_line(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::GLModel::init_from(), Slic3r::GUI::GLModel::Geometry::Lines, Slic3r::GUI::GLModel::Geometry::P3, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::unscale(), and Slic3r::GUI::GLModel::Geometry::vertices_count().

Here is the call graph for this function:

init_model_from_poly()

bool Slic3r::GUI::init_model_from_poly	(	GLModel &	model,
		const ExPolygon &	poly,
		float	z )

{
    if (poly.empty())
        return false;
 
    const std::vector<Vec2f> triangles = triangulate_expolygon_2f(poly, NORMALS_UP);
    if (triangles.empty() || triangles.size() % 3 != 0)
        return false;
 
    GLModel::Geometry init_data;
    init_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3T2 };
    init_data.reserve_vertices(triangles.size());
    init_data.reserve_indices(triangles.size() / 3);
 
    Vec2f min = triangles.front();
    Vec2f max = min;
    for (const Vec2f &v : triangles) {
        min = min.cwiseMin(v).eval();
        max = max.cwiseMax(v).eval();
    }
 
    const Vec2f size = max - min;
    if (size.x() <= 0.0f || size.y() <= 0.0f)
        return false;
 
    Vec2f inv_size = size.cwiseInverse();
    inv_size.y() *= -1.0f;
 
    // vertices + indices
    unsigned int vertices_counter = 0;
    for (const Vec2f &v : triangles) {
        const Vec3f p = {v.x(), v.y(), z};
        init_data.add_vertex(p, (Vec2f)(v - min).cwiseProduct(inv_size).eval());
        ++vertices_counter;
        if (vertices_counter % 3 == 0)
            init_data.add_triangle(vertices_counter - 3, vertices_counter - 2, vertices_counter - 1);
    }
 
    model.init_from(std::move(init_data));
 
    return true;
}

References Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::GLModel::init_from(), Slic3r::NORMALS_UP, Slic3r::GUI::GLModel::Geometry::P3T2, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::GUI::GLModel::Geometry::Triangles, and Slic3r::triangulate_expolygon_2f().

Referenced by Slic3r::GUI::PartPlate::calc_exclude_triangles(), Slic3r::GUI::PartPlate::calc_imex_zones(), Slic3r::GUI::PartPlate::calc_triangles(), Slic3r::GUI::PartPlate::calc_triangles_from_polygon(), Slic3r::GUI::PartPlate::calc_vertex_for_icons(), Slic3r::GUI::PartPlate::calc_vertex_for_imex_warn_badge(), Slic3r::GUI::PartPlate::calc_vertex_for_number(), Slic3r::GUI::PartPlate::calc_vertex_for_plate_name_edit_icon(), Slic3r::GUI::PartPlate::generate_plate_name_texture(), Slic3r::GUI::PartPlate::set_shape(), Slic3r::GUI::Bed3D::update_bed_triangles(), and Slic3r::GUI::PartPlateList::BedTextureInfo::TexturePart::update_buffer().

Here is the call graph for this function:

Here is the caller graph for this function:

init_model_from_polygons()

bool Slic3r::GUI::init_model_from_polygons ( GLModel & model, const Polygons & polygons, float z )

static

{
    model.reset();
    if (polygons.empty())
        return true;
 
    GLModel::Geometry init_data;
    init_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3T2 };
 
    for (const Polygon &polygon : polygons) {
        if (polygon.points.size() < 3)
            continue;
 
        append_expolygon_triangles(init_data, expolygon_from_polygon(polygon), z);
    }
 
    if (!init_data.is_empty())
        model.init_from(std::move(init_data));
 
    return true;
}

References append_expolygon_triangles(), expolygon_from_polygon(), Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::GLModel::init_from(), Slic3r::GUI::GLModel::Geometry::is_empty(), Slic3r::GUI::GLModel::Geometry::P3T2, Slic3r::GUI::GLModel::reset(), and Slic3r::GUI::GLModel::Geometry::Triangles.

Referenced by Slic3r::GUI::PartPlate::update_exclusion_volume_preview_models().

Here is the call graph for this function:

Here is the caller graph for this function:

init_multi_extruder_params_for_cali()

void Slic3r::GUI::init_multi_extruder_params_for_cali ( DynamicPrintConfig & config, const CalibInfo & calib_info )

static

{
    int extruder_count = 1;
    auto nozzle_diameters_opt = dynamic_cast<const ConfigOptionFloats*>(config.option("nozzle_diameter"));
    if (nozzle_diameters_opt != nullptr) {
        extruder_count = (int)(nozzle_diameters_opt->size());
    }
    std::vector<int>& nozzle_volume_types =  dynamic_cast<ConfigOptionEnumsGeneric*>(config.option("nozzle_volume_type", true))->values;
    nozzle_volume_types.clear();
    nozzle_volume_types.resize(extruder_count, (int)calib_info.nozzle_volume_type);
 
    std::vector<int> physical_extruder_maps = dynamic_cast<ConfigOptionInts*>(config.option("physical_extruder_map", true))->values;
    int extruder_id = calib_info.extruder_id;
    for (size_t index = 0; index < extruder_count; ++index) {
        if (physical_extruder_maps[index] == extruder_id)
        {
            nozzle_volume_types[index] = (int) calib_info.nozzle_volume_type;
            extruder_id = index + 1;
            break;
        }
    }
 
    int num_filaments = 1;
    auto filament_colour_opt = dynamic_cast<const ConfigOptionStrings*>(config.option("filament_colour"));
    if (filament_colour_opt != nullptr) {
        num_filaments = (int)(filament_colour_opt->size());
    }
    std::vector<int>& filament_maps = config.option<ConfigOptionInts>("filament_map", true)->values;
    filament_maps.clear();
    filament_maps.resize(num_filaments, extruder_id);
 
    config.option<ConfigOptionEnum<FilamentMapMode>>("filament_map_mode", true)->value = FilamentMapMode::fmmManual;
 
}

References Slic3r::GUI::CalibInfo::extruder_id, Slic3r::fmmManual, Slic3r::GUI::CalibInfo::nozzle_volume_type, and Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::CalibUtils::calib_flowrate(), Slic3r::GUI::CalibUtils::calib_generic_PA(), Slic3r::GUI::CalibUtils::calib_max_vol_speed(), Slic3r::GUI::CalibUtils::calib_retraction(), Slic3r::GUI::CalibUtils::calib_temptue(), and Slic3r::GUI::CalibUtils::calib_VFA().

Here is the call graph for this function:

Here is the caller graph for this function:

init_plane_data()

GLModel::Geometry Slic3r::GUI::init_plane_data	(	const indexed_triangle_set &	its,
		const std::vector< int > &	triangle_indices,
		float	normal_offset )

{
    GLModel::Geometry init_data;
    init_data.format = { GUI::GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3N3 };
    init_data.reserve_indices(3 * triangle_indices.size());
    init_data.reserve_vertices(3 * triangle_indices.size());
    unsigned int i = 0;
    for (int idx : triangle_indices) {
        Vec3f v0 = its.vertices[its.indices[idx][0]];
        Vec3f v1 = its.vertices[its.indices[idx][1]];
        Vec3f v2 = its.vertices[its.indices[idx][2]];
        const Vec3f n = (v1 - v0).cross(v2 - v0).normalized();
        if (std::abs(normal_offset) > 0.0) {
            v0 = v0 + n * normal_offset;
            v1 = v1 + n * normal_offset;
            v2 = v2 + n * normal_offset;
        }
        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, Slic3r::GUI::GLModel::Geometry::P3N3, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), and Slic3r::GUI::GLModel::Geometry::Triangles.

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

Here is the call graph for this function:

Here is the caller graph for this function:

init_raycaster_from_model()

void Slic3r::GUI::init_raycaster_from_model ( PickingModel & model )

static

{
    assert(model.mesh_raycaster == nullptr);
 
  const GLModel::Geometry &geometry = model.model.get_geometry();
 
    indexed_triangle_set its;
    its.vertices.reserve(geometry.vertices_count());
    for (size_t i = 0; i < geometry.vertices_count(); ++i) {
        its.vertices.emplace_back(geometry.extract_position_3(i));
    }
    its.indices.reserve(geometry.indices_count() / 3);
    for (size_t i = 0; i < geometry.indices_count() / 3; ++i) {
        const size_t tri_id = i * 3;
        its.indices.emplace_back(geometry.extract_index(tri_id), geometry.extract_index(tri_id + 1), geometry.extract_index(tri_id + 2));
    }
 
    model.mesh_raycaster = std::make_unique<MeshRaycaster>(std::make_shared<const TriangleMesh>(std::move(its)));
}

References Slic3r::GUI::GLModel::Geometry::extract_index(), Slic3r::GUI::GLModel::Geometry::extract_position_3(), Slic3r::GUI::GLModel::get_geometry(), Slic3r::GUI::GLModel::Geometry::indices_count(), Slic3r::GUI::PickingModel::mesh_raycaster, Slic3r::GUI::PickingModel::model, and Slic3r::GUI::GLModel::Geometry::vertices_count().

Referenced by Slic3r::GUI::PartPlate::calc_vertex_for_icons(), Slic3r::GUI::PartPlate::calc_vertex_for_plate_name_edit_icon(), and Slic3r::GUI::PartPlate::set_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

init_torus_data()

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 )

{
    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 Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::center(), Slic3r::GUI::GLModel::Geometry::format, M_PI, Slic3r::GUI::GLModel::Geometry::P3N3, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::Geometry::translation_transform(), and Slic3r::GUI::GLModel::Geometry::Triangles.

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

Here is the call graph for this function:

Here is the caller graph for this function:

initGestures()

void Slic3r::GUI::initGestures	(	void *	view,
		wxEvtHandler *	handler )

{
    wxNSCustomOpenGLView * glView = (wxNSCustomOpenGLView *) view;
    [glView initGesturesWithHandler: handler];
}

References initGestures(), and wxNSCustomOpenGLView::initGesturesWithHandler:.

Referenced by Slic3r::GUI::GLCanvas3D::bind_event_handlers(), initGestures(), and Slic3r::GUI::GLCanvas3D::unbind_event_handlers().

Here is the call graph for this function:

Here is the caller graph for this function:

initial_zip_archive()

mz_bool Slic3r::GUI::initial_zip_archive ( mz_zip_archive & zip_archive, const std::string & file_path )

static

{
    mz_zip_zero_struct(&zip_archive);
    mz_bool status;
 
    // Initialize the ZIP file to write to the structure, using memory storage
 
    std::string export_dir = encode_path(file_path.c_str());
    status                 = mz_zip_writer_init_file(&zip_archive, export_dir.c_str(), 0);
    return status;
}

References Slic3r::encode_path().

Referenced by Slic3r::GUI::ExportPresetBundleDialog::OnExportData().

Here is the call graph for this function:

Here is the caller graph for this function:

input_optional()

template<typename T, typename Func>

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:

input_shaper_types_for_flavor()

std::vector< InputShaperType > Slic3r::GUI::input_shaper_types_for_flavor

(

GCodeFlavor

flavor

)

{
    switch (flavor) {
    case GCodeFlavor::gcfKlipper:
        return {
            InputShaperType::Default,
            InputShaperType::ZV,
            InputShaperType::MZV,
            InputShaperType::ZVD,
            InputShaperType::EI,
            InputShaperType::TwoHumpEI,
            InputShaperType::ThreeHumpEI,
            InputShaperType::Disable
        };
    case GCodeFlavor::gcfRepRapFirmware:
        return {
            InputShaperType::Default,
            InputShaperType::MZV,
            InputShaperType::ZVD,
            InputShaperType::ZVDD,
            InputShaperType::ZVDDD,
            InputShaperType::EI2,
            InputShaperType::EI3,
            InputShaperType::DAA,
            InputShaperType::Disable
        };
    case GCodeFlavor::gcfMarlinFirmware:
        return {
            InputShaperType::ZV,
            InputShaperType::Disable
        };
    default:
        return {
            InputShaperType::Default,
            InputShaperType::Disable
        };
    }
}

References Slic3r::DAA, Slic3r::Default, Slic3r::Disable, Slic3r::EI, Slic3r::EI2, Slic3r::EI3, Slic3r::gcfKlipper, Slic3r::gcfMarlinFirmware, Slic3r::gcfRepRapFirmware, input_shaper_types_for_flavor(), Slic3r::MZV, Slic3r::ThreeHumpEI, Slic3r::TwoHumpEI, Slic3r::ZV, Slic3r::ZVD, Slic3r::ZVDD, and Slic3r::ZVDDD.

Referenced by Slic3r::GUI::anonymous_namespace{calib_dlg.cpp}::get_shaper_type_values(), input_shaper_types_for_flavor(), and Slic3r::GUI::TabPrinter::update_input_shaper_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

install_local_plugin_package()

bool Slic3r::GUI::install_local_plugin_package	(	const boost::filesystem::path &	package_file,
		wxWindow *	parent,
		wxString &	message )

{
    message.clear();
    if (package_file.empty())
        return false;
 
    // ---- pre-flight (main thread): validate + inspect + overwrite prompt ----
    const wxString package_name = from_u8(package_file.filename().string());
 
    std::string extension = package_file.extension().string();
    std::transform(extension.begin(), extension.end(), extension.begin(),
                   [](unsigned char ch) { return static_cast<char>(std::tolower(ch)); });
    if (extension != ".py" && extension != ".whl") {
        message = _L("Select a .py or .whl plugin package.");
        return false;
    }
 
    PluginDescriptor plugin_descriptor;
    bool             existing_installation = false;
    std::string      error;
    try {
        if (!PluginManager::instance().inspect_local_plugin_package(package_file, plugin_descriptor, existing_installation, error)) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": Plugin package inspection failed for " << package_file << " error=" << error;
            message = _L("Failed to install plugin package. See the log for details.");
            return false;
        }
    } catch (const std::exception& ex) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": Plugin package inspection failed for " << package_file << " error=" << ex.what();
        message = _L("Failed to install plugin package. See the log for details.");
        return false;
    } catch (...) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": Plugin package inspection failed for " << package_file;
        message = _L("Failed to install plugin package. See the log for details.");
        return false;
    }
 
    if (existing_installation) {
        const wxString plugin_name = from_u8(plugin_descriptor.name.empty() ? package_file.filename().string() : plugin_descriptor.name);
        wxMessageDialog dialog(parent,
                               wxString::Format(_L("Plugin \"%s\" is already installed.\n\nInstalling this package will overwrite the existing plugin."),
                                                plugin_name),
                               kOverwritePluginTitle, wxOK | wxCANCEL | wxCANCEL_DEFAULT | wxICON_WARNING);
        dialog.SetOKCancelLabels(_L("Overwrite"), _L("Cancel"));
        if (dialog.ShowModal() != wxID_OK) {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Plugin package installation cancelled before overwrite. package=" << package_file
                                    << " plugin=" << plugin_descriptor.name;
            return false; // cancelled: message stays empty so callers stay silent
        }
    }
 
    // ---- install + refresh on a worker behind a modal progress dialog (keeps the UI live) ----
    bool installed = false;
    {
        struct Result
        {
            std::mutex  mutex;
            bool        ok = false;
            std::string error;
        };
        auto state = std::make_shared<Result>();
 
        detail::run_wait_with_progress(
            [state, package_file]() {
                std::string error;
                bool        ok = false;
                try {
                    ok = PluginManager::instance().install_plugin(package_file, error);
                } catch (const std::exception& ex) {
                    error = ex.what();
                } catch (...) {
                    error = "Unknown error";
                }
                if (ok) {
                    // Reflect the new package in discovery/cloud metadata without blocking the caller.
                    try { refresh_plugin_metadata_blocking(kUseCurrentCloudMeta); } catch (...) {}
                }
                std::lock_guard<std::mutex> lock(state->mutex);
                state->ok    = ok;
                state->error = std::move(error);
            },
            parent, _L("Installing plugin"), _L("Installing plugin") + ": " + package_name, 100,
            wxPD_APP_MODAL | wxPD_AUTO_HIDE | wxPD_ELAPSED_TIME, /*alive=*/nullptr, /*restore=*/{});
 
        std::lock_guard<std::mutex> lock(state->mutex);
        installed = state->ok;
        error     = std::move(state->error);
    }
 
    if (!installed) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": Plugin package installation failed for " << package_file << " error=" << error;
        message = _L("Failed to install plugin package. See the log for details.");
        return false;
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Plugin package installed successfully from " << package_file;
    const wxString installed_name = from_u8(plugin_descriptor.name.empty() ? package_file.filename().string() : plugin_descriptor.name);
    message = wxString::Format(_L("Installed \"%s\"."), installed_name);
    return true;
}

References _L, from_u8(), Slic3r::PluginManager::install_plugin(), Slic3r::PluginManager::instance(), Slic3r::PluginDescriptor::name, refresh_plugin_metadata_blocking(), and Slic3r::GUI::detail::run_wait_with_progress().

Referenced by Slic3r::GUI::GUI_App::install_local_plugin(), and Slic3r::GUI::PluginsDialog::install_plugin_package().

Here is the call graph for this function:

Here is the caller graph for this function:

intersect()

std::vector< std::string > Slic3r::GUI::intersect ( std::vector< std::string > const & l, std::vector< std::string > const & r )

static

{
    std::vector<std::string> t;
    std::copy_if(r.begin(), r.end(), std::back_inserter(t), [&l](auto & e) { return std::find(l.begin(), l.end(), e) != l.end(); });
    return t;
}

References intersect().

Referenced by Slic3r::GUI::TabPrintModel::TabPrintModel(), intersect(), Slic3r::GUI::TabPrintModel::reset_model_config(), Slic3r::GUI::TabPrintPlate::reset_model_config(), and Slic3r::GUI::TabPrintModel::update_model_config().

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());
}

Referenced by Slic3r::GUI::Plater::add_file(), Slic3r::GUI::Plater::add_model(), Slic3r::anonymous_namespace{PluginHostApp.cpp}::export_3mf_copy(), Slic3r::GUI::Plater::export_gcode(), Slic3r::GUI::Plater::export_gcode_3mf(), Slic3r::GUI::Plater::export_published_3mf(), Slic3r::GUI::Plater::extract_config_from_project(), Slic3r::GUI::PrintHostSendDialog::filename(), Slic3r::GUI::Plater::priv::get_export_file(), Slic3r::GUI::Plater::priv::get_export_file_path(), Slic3r::GUI::Plater::load_files(), Slic3r::GUI::Plater::load_project(), Slic3r::GUI::AuFile::on_set_cover(), Slic3r::GUI::Plater::save_project(), Slic3r::GUI::MainFrame::save_project_as(), Slic3r::GUI::Plater::send_gcode_legacy(), Slic3r::GUI::Plater::priv::set_project_filename(), and start_new_slicer_or_gcodeviewer().

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());
}

Referenced by Slic3r::GUI::SavePresetDialog::Item::Item(), Slic3r::GUI::PhysicalPrinterDialog::PhysicalPrinterDialog(), Slic3r::GUI::PrivacyUpdateDialog::PrivacyUpdateDialog(), Slic3r::GUI::MainFrame::add_to_recent_projects(), Slic3r::GUI::MainFrame::FileHistory::AddFileToHistory(), Slic3r::anonymous_namespace{PluginHostApp.cpp}::app_info(), Slic3r::GUI::GUI_App::associate_url(), Slic3r::GUI::ImGuiWrapper::bbl_button(), Slic3r::GUI::GizmoObjectManipulation::bbl_checkbox(), Slic3r::GUI::ImGuiWrapper::bbl_checkbox(), Slic3r::GUI::ImGuiWrapper::bbl_combo_with_filter(), Slic3r::GUI::NotificationManager::PopNotification::bbl_render_block_notif_buttons(), Slic3r::GUI::ImGuiWrapper::bbl_slider_float(), Slic3r::GUI::ImGuiWrapper::begin(), Slic3r::GUI::ImGuiWrapper::begin(), Slic3r::GUI::Sidebar::build_filament_ams_list(), Slic3r::GUI::GuideFrame::BuildProfileJson(), Slic3r::GUI::ImGuiWrapper::button(), Slic3r::GUI::ImGuiWrapper::button(), Slic3r::GUI::ImGuiWrapper::button(), Slic3r::GUI::ImGuiWrapper::calc_text_size(), Slic3r::GUI::ImGuiWrapper::checkbox(), anonymous_namespace{GLGizmoSVG.cpp}::choose_svg_file(), Slic3r::GUI::ImGuiWrapper::clipboard_get(), Slic3r::GUI::Sidebar::collect_physical_filament_info(), color_string(), Slic3r::GUI::ImGuiWrapper::combo(), Slic3r::GUI::Mouse3DController::connect_device(), Slic3r::GUI::NotificationManager::PopNotification::count_lines(), create_checkbox(), Slic3r::GUI::CreateFilamentPresetDialog::create_dialog_buttons(), Slic3r::GUI::CreatePresetForPrinterDialog::create_dialog_buttons(), Slic3r::GUI::ExportConfigsDialog::create_dialog_buttons(), Slic3r::PluginPages::create_page(), Slic3r::GUI::CreatePrinterPresetDialog::create_printer_item(), Slic3r::GUI::CreatePresetForPrinterDialog::create_selected_filament_preset_sizer(), Slic3r::GUI::CreatePrinterPresetDialog::data_init(), Slic3r::GUI::IMSlider::draw_custom_label_block(), Slic3r::GUI::anonymous_namespace{Plater.cpp}::emboss_svg(), Slic3r::GUI::PrintHostSendDialog::EndModal(), Slic3r::GUI::Plater::export_3mf(), Slic3r::GUI::MainFrame::export_config(), Slic3r::GUI::Plater::export_core_3mf(), Slic3r::GUI::Plater::export_stl(), Slic3r::GUI::Plater::export_toolpaths_to_obj(), Slic3r::GUI::IMEXModesCtrl::fix_row_name(), Slic3r::GUI::ObjectList::fix_through_cgal(), generate_system_info_json(), Slic3r::GUI::ModelNode::get_bitmap(), Slic3r::GUI::ScoreDialog::get_button_sizer(), Slic3r::PluginConfig::get_config_response(), Slic3r::GUI::ConfigOptionsGroup::get_config_value2(), Slic3r::GUI::CreatePrinterPresetDialog::get_custom_printer_model(), Slic3r::GUI::MainFrame::get_dir_name(), Slic3r::GUI::Plater::priv::get_export_file(), Slic3r::GUI::CreateFilamentPresetDialog::get_filament_preset_choices(), Slic3r::GUI::CreateFilamentPresetDialog::get_filament_presets_by_machine(), Slic3r::GUI::IMEXModesCtrl::get_mode_data(), Slic3r::GUI::CreatePrinterPresetDialog::get_nozzle_diameter(), Slic3r::ElegooLink::get_print_host_webui(), Slic3r::GUI::CreatePrinterPresetDialog::get_printer_model(), Slic3r::GUI::CreatePrinterPresetDialog::get_printer_vendor(), Slic3r::GUI::CaliPASaveManualPanel::get_result(), Slic3r::GUI::CaliSavePresetValuePanel::get_save_name(), get_selection(), Slic3r::PrusaLink::get_storage(), Slic3r::GUI::PrinterAgentChoice::get_value(), Slic3r::GUI::Field::get_value_by_opt_type(), Slic3r::GUI::ImGuiWrapper::glyph_button(), Slic3r::GUI::PrintHostSendDialog::group(), Slic3r::GUI::PluginsConfigDialog::handle_web_command(), Slic3r::GUI::Plater::has_illegal_filename_characters(), Slic3r::GUI::GLGizmoTextureDisplacement::import_custom_texture(), Slic3r::GUI::Plater::import_model_id(), Slic3r::GUI::MainFrame::init_menubar_as_editor(), Slic3r::GUI::ExportConfigsDialog::initial_file_name(), Slic3r::GUI::ExportConfigsDialog::initial_file_path(), Slic3r::GUI::ImGuiWrapper::input_double(), Slic3r::GUI::PluginsDialog::install_cloud_plugin(), Slic3r::GUI::GUI_App::install_local_plugin(), Slic3r::GUI::MainFrame::load_config_file(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::Plater::load_gcode(), Slic3r::GUI::ObjectList::load_generic_subobject(), Slic3r::GUI::GUI_App::load_language(), Slic3r::GUI::ObjectList::load_mesh_object(), Slic3r::GUI::Plater::load_project(), Slic3r::GUI::CreatePrinterPresetDialog::load_system_and_user_presets_with_curr_model(), Slic3r::GUI::WebViewHostDialog::load_url(), Slic3r::GUI::GuideFrame::LoadProfileFamily(), Slic3r::GUI::MarkdownTip::LoadStyle(), Slic3r::GUI::MainFrame::FileHistory::LoadThumbnails(), make_string_bold(), Slic3r::GUI::ActionRegistry::materialize_setting_actions(), Slic3r::GUI::anonymous_namespace{ActionRegistry.cpp}::notify_script_outcome(), Slic3r::GUI::FlowRateWizard::on_cali_save(), Slic3r::GUI::PrintHostQueueDialog::on_cancel(), Slic3r::GUI::Downloader::on_error(), Slic3r::GUI::PrintHostQueueDialog::on_error(), Slic3r::GUI::Downloader::on_progress(), Slic3r::GUI::PrintHostQueueDialog::on_progress(), Slic3r::GUI::GLGizmoMeshBoolean::on_render_input_window(), Slic3r::GUI::WebViewHostDialog::on_script_message_parse_error(), Slic3r::GUI::CreatePrinterPresetDialog::on_select_printer_model(), Slic3r::GUI::ExportPresetBundleDialog::OnExportData(), Slic3r::GUI::OG_CustomCtrl::OnMotion(), Slic3r::GUI::PrinterCloudAuthDialog::OnScriptMessage(), Slic3r::GUI::ZUserLogin::OnScriptMessage(), Slic3r::GUI::MainFrame::open_recent_project(), Slic3r::GUI::GLGizmoTextureDisplacement::panel_tooltip(), Slic3r::GUI::GUI_App::persist_window_geometry(), Slic3r::GUI::MediaPlayCtrl::Play(), Slic3r::GUI::GUI_App::post_init(), Slic3r::GUI::ArrangeJob::prepare_all(), Slic3r::GUI::ArrangeJob::prepare_partplate(), Slic3r::GUI::OrientJob::prepare_partplate(), Slic3r::GUI::ArrangeJob::prepare_selected(), Slic3r::GUI::OrientJob::prepare_selection(), Slic3r::GUI::CreatePrinterPresetDialog::printer_preset_sort_with_nozzle_diameter(), Slic3r::GUI::PageCustom::profile_name(), Slic3r::GUI::ImGuiWrapper::radio_button(), Slic3r::GUI::GUI_App::refresh_plugins(), Slic3r::GUI::MainFrame::remove_recent_project(), Slic3r::GUI::IMSlider::render_add_menu(), Slic3r::GUI::NotificationManager::PrintHostUploadNotification::render_bar(), Slic3r::GUI::NotificationManager::HintNotification::render_close_button(), Slic3r::GUI::NotificationManager::PopNotification::render_close_button(), Slic3r::GUI::IMSlider::render_edit_menu(), Slic3r::GUI::GLGizmoTextureDisplacement::render_image_adjust_window(), Slic3r::GUI::GCodeViewer::render_legend(), Slic3r::GUI::NotificationManager::PopNotification::render_minimize_button(), Slic3r::GUI::NotificationManager::URLDownloadNotification::render_open_button_inner(), Slic3r::GUI::NotificationManager::URLDownloadNotification::render_pause_button_inner(), Slic3r::GUI::NotificationManager::HintNotification::render_preferences_button(), Slic3r::GUI::NotificationManager::HintNotification::render_right_arrow_button(), Slic3r::GUI::GLGizmoTextureDisplacement::render_tip_media(), Slic3r::GUI::Plater::priv::reset(), Slic3r::GUI::DesignSketchTool::resolve_live_drag(), Slic3r::PluginConfig::restore_config_response(), Slic3r::GUI::SpeedDialWebDialog::run_action(), Slic3r::GUI::Plater::priv::run_textured_mesh_import_dialog(), Slic3r::PluginConfig::save_config_response(), Slic3r::GUI::CreatePrinterPresetDialog::save_printable_area_config(), Slic3r::GUI::Plater::save_project(), Slic3r::GUI::CaliPASaveAutoPanel::save_to_result_from_widgets(), Slic3r::GUI::PluginsConfigDialog::send_capability_config(), Slic3r::GUI::MainFrame::set_max_recent_count(), Slic3r::GUI::PluginConfigField::set_value(), Slic3r::GUI::PluginField::set_value(), Slic3r::GUI::PrinterAgentChoice::set_value(), Slic3r::GUI::PrinterAgentChoice::set_value(), Slic3r::GUI::GuideFrame::SetStartPage(), Slic3r::GUI::anonymous_namespace{ActionRegistry.cpp}::setting_text(), Slic3r::GUI::ObjectGridTable::SetValue(), Slic3r::GUI::Plater::priv::show_install_plugin_hint(), Slic3r::GUI::Plater::show_object_info(), Slic3r::GUI::Plater::priv::show_preview_only_hint(), Slic3r::GUI::PluginsConfigDialog::show_status(), Slic3r::GUI::PluginsDialog::show_status(), Slic3r::GUI::ImGuiWrapper::slider_float(), Slic3r::GUI::IMEXModesCtrl::snapshot_row(), start_new_slicer_or_gcodeviewer(), Slic3r::GUI::MediaPlayCtrl::Stop(), Slic3r::GUI::PrintHostSendDialog::storage(), Slic3r::GUI::IMEXModesCtrl::suggested_mode_names(), Slic3r::GUI::ImGuiWrapper::text(), Slic3r::GUI::ImGuiWrapper::text_colored(), Slic3r::GUI::ImGuiWrapper::text_wrapped(), Slic3r::GUI::MediaPlayCtrl::ToggleStream(), Slic3r::GUI::IMEXModesCtrl::unique_mode_name(), Slic3r::GUI::PlaterPresetComboBox::update(), Slic3r::GUI::PresetComboBox::update(), Slic3r::GUI::SavePresetDialog::Item::update(), Slic3r::GUI::TabPresetComboBox::update(), Slic3r::GUI::ObjectTableSettings::update_config_values(), update_custom_filaments(), Slic3r::GUI::PhysicalPrinterDialog::update_preset_input(), Slic3r::GUI::UnsavedChangesDialog::update_tree(), Slic3r::GUI::ModelNode::UpdateEnabling(), Slic3r::ElegooLink::upload_inner_with_host(), Slic3r::OctoPrint::upload_inner_with_host(), Slic3r::PrusaLink::upload_inner_with_host(), Slic3r::GUI::CreatePrinterPresetDialog::validate_input_valid(), validate_thumbnails_string(), Slic3r::GUI::IMSlider::vertical_slider(), Slic3r::GUI::ImGuiWrapper::warning_text(), and Slic3r::wxDEFINE_EVENT().

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.

{ return obj->getSizer() == nullptr && obj->getWindow() == nullptr; }

References Slic3r::GUI::Field::getSizer(), and Slic3r::GUI::Field::getWindow().

Referenced by is_sizer_field(), and is_window_field().

Here is the call graph for this function:

Here is the caller graph for this function:

is_base_plane()

bool Slic3r::GUI::is_base_plane ( const SketchPlane & p, const Vec3d & modeling_origin )

static

{
    SketchPlane  b = plane_from_index(index_from_plane(p));
    b.origin += modeling_origin;
    const double e = 1e-6;
    return (p.origin - b.origin).norm() < e && (p.normal - b.normal).norm() < e
        && (p.x_axis - b.x_axis).norm() < e && (p.y_axis - b.y_axis).norm() < e;
}

References index_from_plane(), Slic3r::SketchPlane::normal, Slic3r::SketchPlane::origin, plane_from_index(), Slic3r::SketchPlane::x_axis, and Slic3r::SketchPlane::y_axis.

Referenced by Slic3r::GUI::DesignSketchTool::hit_test_base_pick(), Slic3r::GUI::DesignPanel::load_feature_into_dialog(), reference_square(), and Slic3r::GUI::DesignSketchTool::render_base_pick().

Here is the call graph for this function:

Here is the caller graph for this function:

is_belt_purge_prism()

bool Slic3r::GUI::is_belt_purge_prism ( const ModelObject * mo )

static

{
    const ConfigOption *opt = mo->config.option("belt_purge_tower_object");
    return opt != nullptr && opt->getBool();
}

References Slic3r::ModelObject::config, and Slic3r::ModelConfig::option().

Referenced by Slic3r::GUI::ArrangeJob::prepare_all(), Slic3r::GUI::ArrangeJob::prepare_partplate(), and Slic3r::GUI::ArrangeJob::prepare_selected().

Here is the call graph for this function:

Here is the caller graph for this function:

is_caret_line()

bool Slic3r::GUI::is_caret_line ( const std::string & line )

static

{
    return std::count(line.begin(), line.end(), '^') == 1 &&
           std::all_of(line.begin(), line.end(), [](char c) { return c == ' ' || c == '^'; });
}

Referenced by classify_code_lines().

Here is the caller graph for this function:

is_debugger_present()

bool Slic3r::GUI::is_debugger_present

(

)

{
    int                 junk;
    int                 mib[4];
    struct kinfo_proc   info;
    size_t              size;
 
    // Initialize the flags so that, if sysctl fails for some bizarre
    // reason, we get a predictable result.
 
    info.kp_proc.p_flag = 0;
 
    // Initialize mib, which tells sysctl the info we want, in this case
    // we're looking for information about a specific process ID.
 
    mib[0] = CTL_KERN;
    mib[1] = KERN_PROC;
    mib[2] = KERN_PROC_PID;
    mib[3] = getpid();
 
    // Call sysctl.
 
    size = sizeof(info);
    junk = sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, NULL, 0);
    assert(junk == 0);
 
    // We're being debugged if the P_TRACED flag is set.
 
    return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
}

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 && type != coPoint))
        return false;
    return true;
}

References Slic3r::coPoint, Slic3r::coPoints, Slic3r::coString, Slic3r::coStrings, and Slic3r::empty().

Referenced by Slic3r::GUI::Choice::propagate_value(), and Slic3r::GUI::TextCtrl::propagate_value().

Here is the call graph for this function:

Here is the caller graph for this function:

is_improper_category()

bool Slic3r::GUI::is_improper_category ( const std::string & category, const int filaments_cnt, const bool is_object_settings = true )

static

{
    return  category.empty() ||
        (filaments_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]

bool Slic3r::GUI::is_left_handed ( const Transform3d & m )

static

{
    return is_left_handed(m.linear());
}

References is_left_handed().

Here is the call graph for this function:

is_left_handed() [2/2]

bool Slic3r::GUI::is_left_handed ( const Transform3d::ConstLinearPart & m )

static

{
    return m.determinant() < 0;
}

Referenced by Slic3r::GUI::GLCanvas3D::_load_sla_shells(), Slic3r::GUI::Plater::export_stl(), is_left_handed(), Slic3r::GUI::GLGizmoPainterBase::render_cursor_sphere(), Slic3r::GUI::GLGizmoPainterBase::render_triangles(), Slic3r::GUI::Selection::synchronize_unselected_instances(), and Slic3r::GUI::GLGizmoFlatten::update_planes().

Here is the caller graph for this function:

is_pa_params_valid()

bool Slic3r::GUI::is_pa_params_valid

(

const Calib_Params &

params

)

{
    if (params.start < MIN_PA_K_VALUE || params.end > MAX_PA_K_VALUE || params.step < EPSILON || params.end < params.start + params.step) {
        MessageDialog msg_dlg(nullptr,
            wxString::Format(_L("Please input valid values:\nStart value: >= %.1f\nEnd value: <= %.1f\nEnd value: > Start value\nValue step: >= %.3f"), MIN_PA_K_VALUE, MAX_PA_K_VALUE, MIN_PA_K_VALUE_STEP),
            wxEmptyString, wxICON_WARNING | wxOK);
        msg_dlg.ShowModal();
        return false;
    }
    return true;
}

References _L, Slic3r::Calib_Params::end, EPSILON, MAX_PA_K_VALUE, MIN_PA_K_VALUE, MIN_PA_K_VALUE_STEP, Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::Calib_Params::start, and Slic3r::Calib_Params::step.

Referenced by Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

Here is the call graph for this function:

Here is the caller graph for this function:

is_point_in_rect()

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()

bool Slic3r::GUI::is_rotation_xy_synchronized ( const Transform3d & rot_xyz_from, const Transform3d & rot_xyz_to )

static

{
    const Eigen::AngleAxisd angle_axis((rot_xyz_from * rot_xyz_to.inverse()).rotation());
    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 Slic3r::angle().

Referenced by 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_running_in_msix()

bool Slic3r::GUI::is_running_in_msix

(

)

{
#ifdef _WIN32
    // The package identity APIs are Win8+ - resolved dynamically so the exe still loads on Win7
    // (same treatment as the DPI APIs below). Null-buffer probe: returns ERROR_INSUFFICIENT_BUFFER
    // when packaged, APPMODEL_ERROR_NO_PACKAGE when running unpackaged.
    struct GetCurrentPackageFullName_t { typedef LONG (WINAPI *FN)(UINT32 *length, PWSTR full_name); };
    static const bool packaged = []() {
        auto fn = winapi_get_function<GetCurrentPackageFullName_t>(L"Kernel32.dll", "GetCurrentPackageFullName");
        UINT32 length = 0;
        return fn != nullptr && fn(&length, nullptr) != APPMODEL_ERROR_NO_PACKAGE;
    }();
    return packaged;
#else
    return false;
#endif
}

References L, and Slic3r::length().

Referenced by Slic3r::GUI::UpdateVersionDialog::UpdateVersionDialog(), Slic3r::GUI::GUI_App::associate_files(), Slic3r::GUI::GUI_App::associate_url(), Slic3r::GUI::PreferencesDialog::create_items(), Slic3r::GUI::GUI_App::disassociate_files(), Slic3r::GUI::GUI_App::disassociate_url(), Slic3r::GUI::GUI_App::on_init_inner(), and Slic3r::GUI::UpdateVersionDialog::update_version_info().

Here is the call graph for this function:

Here is the caller graph for this function:

is_same_nozzle_config()

bool Slic3r::GUI::is_same_nozzle_config ( const std::map< int, std::vector< DevNozzle > > & config1, const std::map< int, std::vector< DevNozzle > > & config2 )

static

{
    if (config1.size() != config2.size()) return false;
 
    for (const auto& [eid, nozzles1] : config1) {
        auto it = config2.find(eid);
        if (it == config2.end()) return false;
 
        const auto &nozzles2 = it->second;
        if (nozzles1.size() != nozzles2.size()) return false;
 
        auto sorted_nozzles1 = nozzles1;
        auto sorted_nozzles2 = nozzles2;
 
        auto compare_nozzle = [](const DevNozzle &a, const DevNozzle &b) {
            float dia_a = a.GetNozzleDiameter();
            float dia_b = b.GetNozzleDiameter();
            if (std::abs(dia_a - dia_b) > EPSILON) {
                return dia_a < dia_b;
            }
            return static_cast<int>(a.GetNozzleFlowType()) < static_cast<int>(b.GetNozzleFlowType());
        };
 
        std::sort(sorted_nozzles1.begin(), sorted_nozzles1.end(), compare_nozzle);
        std::sort(sorted_nozzles2.begin(), sorted_nozzles2.end(), compare_nozzle);
 
        for (size_t i = 0; i < sorted_nozzles1.size(); ++i) {
            if (std::abs(sorted_nozzles1[i].GetNozzleDiameter() - sorted_nozzles2[i].GetNozzleDiameter()) > EPSILON ||
                sorted_nozzles1[i].GetNozzleFlowType() != sorted_nozzles2[i].GetNozzleFlowType()) {
                return false;
            }
        }
    }
 
    return true;
}

References EPSILON, Slic3r::DevNozzle::GetNozzleDiameter(), and Slic3r::DevNozzle::GetNozzleFlowType().

Referenced by Slic3r::GUI::Sidebar::priv::get_nozzle_options().

Here is the call graph for this function:

Here is the caller graph for this function:

is_same_nozzle_type()

bool Slic3r::GUI::is_same_nozzle_type ( const DynamicPrintConfig & full_config, const MachineObject * obj, wxString & error_msg )

static

{
    if (obj == nullptr)
        return true;
 
    NozzleType nozzle_type = obj->GetExtderSystem()->GetNozzleType(0);
    int printer_nozzle_hrc = Print::get_hrc_by_nozzle_type(nozzle_type);
 
    if (full_config.has("required_nozzle_HRC")) {
        int filament_nozzle_hrc = full_config.opt_int("required_nozzle_HRC", 0);
        if (abs(filament_nozzle_hrc) > abs(printer_nozzle_hrc)) {
            BOOST_LOG_TRIVIAL(info) << "filaments hardness mismatch:  printer_nozzle_hrc = " << printer_nozzle_hrc << ", filament_nozzle_hrc = " << filament_nozzle_hrc;
            std::string filament_type = full_config.opt_string("filament_type", 0);
            error_msg = format_wxstr(_L("Printing %1% material with %2% nozzle may cause nozzle damage."), filament_type, to_wstring_name(NozzleTypeEumnToStr[obj->GetExtderSystem()->GetNozzleType(0)]));
            error_msg += "\n";
 
            MessageDialog msg_dlg(nullptr, error_msg, wxEmptyString, wxICON_WARNING | wxOK | wxCANCEL);
            auto          result = msg_dlg.ShowModal();
            if (result == wxID_OK) {
                error_msg.clear();
                return true;
            } else {
                error_msg.clear();
                return false;
            }
        }
    }
 
    return true;
}

References _L, Slic3r::filament_type(), format_wxstr(), Slic3r::Print::get_hrc_by_nozzle_type(), Slic3r::MachineObject::GetExtderSystem(), Slic3r::DevExtderSystem::GetNozzleType(), Slic3r::ConfigOptionResolver::has(), Slic3r::nozzle_type(), Slic3r::NozzleTypeEumnToStr, Slic3r::DynamicConfig::opt_int(), Slic3r::DynamicConfig::opt_string(), Slic3r::GUI::DPIAware< P >::ShowModal(), and to_wstring_name().

Referenced by check_nozzle_diameter_and_type(), and Slic3r::GUI::Sidebar::priv::update_sync_status().

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.

{ return !is_bad_field(obj) && obj->getSizer() != nullptr; }

References Slic3r::GUI::Field::getSizer(), and 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_skip_high_flow_printer()

bool Slic3r::GUI::is_skip_high_flow_printer ( const std::string & printer )

static

{
    static const std::set<std::string> invalidate_list = {
        "Bambu Lab X1E"
    };
    return invalidate_list.count(printer);
};

Referenced by Slic3r::GUI::Sidebar::update_presets().

Here is the caller graph for this function:

is_soluble_filament()

bool Slic3r::GUI::is_soluble_filament

(

int

extruder_id

)

{
    auto &filament_presets = Slic3r::GUI::wxGetApp().preset_bundle->filament_presets;
    auto &filaments        = Slic3r::GUI::wxGetApp().preset_bundle->filaments;
 
    if (extruder_id >= filament_presets.size()) return false;
 
    Slic3r::Preset *filament = filaments.find_preset(filament_presets[extruder_id]);
    if (filament == nullptr) return false;
 
    Slic3r::ConfigOptionBools *support_option = dynamic_cast<Slic3r::ConfigOptionBools *>(filament->config.option("filament_soluble"));
    if (support_option == nullptr) return false;
 
    return support_option->get_at(0);
};

References Slic3r::Preset::config, Slic3r::ConfigOptionBoolsTempl< NULLABLE >::get_at(), is_soluble_filament(), and Slic3r::ConfigBase::option().

Referenced by is_soluble_filament(), Slic3r::GUI::Tab::on_value_change(), and wxDECLARE_EVENT().

Here is the call graph for this function:

Here is the caller graph for this function:

is_support_filament()

bool Slic3r::GUI::is_support_filament	(	int	extruder_id,
		bool	strict_check )

{
    auto &filament_presets = Slic3r::GUI::wxGetApp().preset_bundle->filament_presets;
    auto &filaments        = Slic3r::GUI::wxGetApp().preset_bundle->filaments;
 
    if (extruder_id >= filament_presets.size()) return false;
 
    Slic3r::Preset *filament = filaments.find_preset(filament_presets[extruder_id]);
    if (filament == nullptr) return false;
 
    std::string filament_type = filament->config.option<ConfigOptionStrings>("filament_type")->values[0];
 
    Slic3r::ConfigOptionBools *support_option = dynamic_cast<Slic3r::ConfigOptionBools *>(filament->config.option("filament_is_support"));
 
    if(!strict_check &&(filament_type == "PETG" || filament_type == "PLA")) {
        std::vector<std::string> model_filaments;
        if (filament_type == "PETG")
            model_filaments.emplace_back("PLA");
        else {
            model_filaments = {"PETG", "TPU", "TPU-AMS"};
        }
        if (has_filaments(model_filaments)) return true;
    }
    if (support_option == nullptr) return false;
    return support_option->get_at(0);
};

References Slic3r::Preset::config, Slic3r::filament_type(), has_filaments(), is_support_filament(), and Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::Sidebar::auto_calc_flushing_volumes_internal(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_filament_target(), WipingDialog::CalcFlushingVolumes(), is_support_filament(), Slic3r::GUI::Plater::priv::on_select_preset(), Slic3r::GUI::Tab::on_value_change(), Slic3r::GUI::Sidebar::sync_ams_list(), and wxDECLARE_EVENT().

Here is the call graph for this function:

Here is the caller graph for this function:

is_transparent_color()

bool Slic3r::GUI::is_transparent_color ( const wxColour & color )

static

                                                        {
    return color.Alpha() == 0;
}

Referenced by create_single_filament_bitmap().

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.

{ return !is_bad_field(obj) && obj->getWindow() != nullptr && obj->getSizer() == nullptr; }

References Slic3r::GUI::Field::getSizer(), Slic3r::GUI::Field::getWindow(), and 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()

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:

key_released()

void Slic3r::GUI::key_released ( int key )

static

{ s_keys_down.erase(key); }

References s_keys_down.

Referenced by Slic3r::GUI::GLCanvas3D::on_key().

Here is the caller graph for this function:

key_repeats()

bool Slic3r::GUI::key_repeats ( int key )

static

{
    for (auto it = s_keys_down.begin(); it != s_keys_down.end();)   // drops keys released while no canvas had the focus
        it = wxGetKeyState(wxKeyCode(*it)) ? std::next(it) : s_keys_down.erase(it);
    return !s_keys_down.insert(key).second;
}

References s_keys_down.

Referenced by Slic3r::GUI::GLCanvas3D::on_key().

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()

std::string Slic3r::GUI::libslic3r_translate_callback ( const char * s )

static

{ return wxGetTranslation(wxString(s, wxConvUTF8)).utf8_str().data(); }

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

Here is the caller graph for this function:

list_model()

ObjectDataViewModel * Slic3r::GUI::list_model ( )

static

{
    return wxGetApp().obj_list()->GetModel();
}

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_settings(), Slic3r::GUI::MenuFactory::assemble_multi_selection_menu(), and Slic3r::GUI::MenuFactory::multi_selection_menu().

Here is the caller graph for this function:

load_filament_id_sources()

void Slic3r::GUI::load_filament_id_sources ( PresetBundle & temp_preset_bundle )

static

{
    temp_preset_bundle.load_system_filaments_json(Slic3r::ForwardCompatibilitySubstitutionRule::EnableSilent);
    std::string dir_user_presets = wxGetApp().app_config->get("preset_folder");
    if (dir_user_presets.empty()) {
        temp_preset_bundle.load_user_presets(DEFAULT_USER_FOLDER_NAME, ForwardCompatibilitySubstitutionRule::EnableSilent);
    } else {
        temp_preset_bundle.load_user_presets(dir_user_presets, ForwardCompatibilitySubstitutionRule::EnableSilent);
    }
}

References DEFAULT_USER_FOLDER_NAME, Slic3r::EnableSilent, Slic3r::PresetBundle::load_system_filaments_json(), and Slic3r::PresetBundle::load_user_presets().

Referenced by Slic3r::GUI::CreateFilamentPresetDialog::create_dialog_buttons(), and Slic3r::GUI::CreatePrinterPresetDialog::create_page2_dialog_buttons().

Here is the call graph for this function:

Here is the caller graph for this function:

load_image()

bool Slic3r::GUI::load_image	(	const std::string &	filename,
		wxImage &	image )

{
    bool    result = true;
    if (boost::algorithm::iends_with(filename, ".png")) {
        result = image.LoadFile(wxString::FromUTF8(filename.c_str()), wxBITMAP_TYPE_PNG);
    } else if (boost::algorithm::iends_with(filename, ".bmp")) {
        result = image.LoadFile(wxString::FromUTF8(filename.c_str()), wxBITMAP_TYPE_BMP);
    } else if (boost::algorithm::iends_with(filename, ".jpg")) {
        result = image.LoadFile(wxString::FromUTF8(filename.c_str()), wxBITMAP_TYPE_JPEG);
    } else if (boost::algorithm::iends_with(filename, ".jpeg")) {
        result = image.LoadFile(wxString::FromUTF8(filename.c_str()), wxBITMAP_TYPE_JPEG);
    }
    else {
        return false;
    }
    return result;
}

Referenced by generate_image().

Here is the caller graph for this function:

load_next_part_texture()

bool Slic3r::GUI::load_next_part_texture ( PartPlateList::BedTextureInfo * infos, size_t count, size_t & next, bool compress_and_filter )

static

{
  size_t k = next;
  for (size_t i = 0; i < count; ++i) {
    if (k >= infos[i].parts.size()) {
      k -= infos[i].parts.size();
      continue;
    }
    ++next;
    PartPlateList::BedTextureInfo::TexturePart& part = infos[i].parts[k];
    const std::string filename = resources_dir() + "/images/" + part.filename;
    if (boost::filesystem::exists(filename)) {
      part.texture = new GLTexture();
      if (!part.texture->load_from_svg_file(filename, true, compress_and_filter, compress_and_filter, logo_texture_size()))
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": load texture from %1% failed!") % filename;
    } else {
      BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": load texture from %1% failed!") % filename;
    }
    return true;
  }
  return false;
}

References count, Slic3r::GUI::PartPlateList::BedTextureInfo::TexturePart::filename, Slic3r::GUI::GLTexture::load_from_svg_file(), logo_texture_size(), Slic3r::GUI::PartPlateList::BedTextureInfo::parts, Slic3r::resources_dir(), and Slic3r::GUI::PartPlateList::BedTextureInfo::TexturePart::texture.

Referenced by Slic3r::GUI::PartPlateList::load_next_bedtype_texture(), Slic3r::GUI::PartPlateList::load_next_cali_texture(), and Slic3r::GUI::PartPlateList::load_next_extruder_only_area_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

load_texture_image_data()

std::shared_ptr< std::vector< unsigned char > > Slic3r::GUI::load_texture_image_data	(	const std::string &	path,
		std::string &	error )

{
    std::vector<unsigned char> bytes = read_file_bytes(path);
    if (bytes.empty()) {
        error = _u8L("Could not read the texture file.");
        return nullptr;
    }
    if (is_supported_height_map(bytes))
        return std::make_shared<std::vector<unsigned char>>(std::move(bytes));
 
    // Not a PNG at all (a jpg somebody copied into the folder by hand, say): convert it the same way
    // an import would - keeping its colour if it has any - but leave the file on disk alone.
    wxImage image;
    if (!image.LoadFile(from_u8(path)) || !image.IsOk()) {
        error = _u8L("Could not load the selected image.");
        return nullptr;
    }
    std::vector<unsigned char> converted;
    if (!encode_png_bytes(image, converted, error))
        return nullptr;
    return std::make_shared<std::vector<unsigned char>>(std::move(converted));
}

References _u8L, and from_u8().

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::get_library_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

log_substitutions() [1/2]

void Slic3r::GUI::log_substitutions ( const ConfigSubstitutions & substitutions, const std::string & source )

static

{
    for (const ConfigSubstitution& substitution : substitutions)
        BOOST_LOG_TRIVIAL(warning) << "Loading " << source << ": " << substitution.opt_def->opt_key << " = \"" << substitution.old_value
                                   << "\" replaced with \"" << substitution.new_value->serialize() << "\"";
}

Referenced by Slic3r::GUI::Plater::priv::load_files(), and log_substitutions().

Here is the caller graph for this function:

log_substitutions() [2/2]

void Slic3r::GUI::log_substitutions ( const PresetsConfigSubstitutions & substitutions, const std::string & source )

static

{
    for (const PresetConfigSubstitutions& preset : substitutions)
        log_substitutions(preset.substitutions, source + " (preset " + preset.preset_name + ")");
}

References log_substitutions().

Here is the call graph for this function:

logo_texture_size()

GLint Slic3r::GUI::logo_texture_size ( )

static

{
  return std::min<GLint>(OpenGLManager::get_gl_info().get_max_tex_size(), 2048);
}

References Slic3r::GUI::OpenGLManager::get_gl_info().

Referenced by Slic3r::GUI::PartPlateList::load_logo_texture(), and load_next_part_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

lookup_decompose_official_component()

DecomposeOfficialComponent Slic3r::GUI::lookup_decompose_official_component	(	const std::string &	basic_type,
		DecomposeBaseColor	base_color,
		const wxColour &	fallback )

{
    DecomposeOfficialComponent result;
    result.base_color  = base_color;
    result.color_hex   = decompose_normalize_color_hex(fallback.GetAsString(wxC2S_HTML_SYNTAX).ToStdString());
    result.filament_id = decompose_basic_filament_id(basic_type);
 
    const char* color_name = decompose_base_color_en(base_color);
    if (color_name[0] == '\0')
        return result;
 
    // Some materials name a standard base color differently in the color-code
    // table. PETG Basic's RYBW blue base is "Reflex Blue" (deep blue, B00,
    // #001489), not "Blue". Match by an ordered list of exact English names so
    // "Navy Blue" (B01, #0086D6) is never picked up by mistake.
    std::vector<std::string> candidate_names;
    candidate_names.emplace_back(color_name);
    if (base_color == DecomposeBaseColor::Blue && basic_type == kDecomposePetgBasicType)
        candidate_names.emplace_back("Reflex Blue");
 
    std::ifstream ifs(resources_dir() + "/profiles/BBL/filament/filaments_color_codes.json");
    if (!ifs)
        return result;
 
    json root = json::parse(ifs, nullptr, false);
    if (root.is_discarded() || !root.contains("data") || !root["data"].is_array())
        return result;
 
    for (const std::string& candidate : candidate_names) {
        for (const auto& item : root["data"]) {
            if (!item.is_object() || item.value("fila_type", "") != basic_type)
                continue;
            if (!item.contains("fila_color_name"))
                continue;
            const auto& names = item["fila_color_name"];
            if (!names.is_object() || names.value("en", "") != candidate)
                continue;
            if (item.contains("fila_color") && item["fila_color"].is_array() && !item["fila_color"].empty())
                result.color_hex = decompose_normalize_color_hex(item["fila_color"][0].get<std::string>());
            // fila_id from this shipped, Bambu-keyed color table is a printer-side id; translate it so
            // result.filament_id stays an OF id like the rest of this struct (the fallback default,
            // result.filament_id, is already OF and passes through unchanged).
            const std::string fila_id = item.value("fila_id", result.filament_id);
            auto* agent = wxGetApp().getAgent();
            result.filament_id = agent ? agent->to_orca_filament_id(fila_id) : fila_id;
            return result;
        }
    }
    return result;
}

References Slic3r::GUI::DecomposeOfficialComponent::base_color, Blue, Slic3r::GUI::DecomposeOfficialComponent::color_hex, decompose_base_color_en(), decompose_basic_filament_id(), decompose_normalize_color_hex(), Slic3r::GUI::DecomposeOfficialComponent::filament_id, kDecomposePetgBasicType, and Slic3r::resources_dir().

Referenced by count_decompose_new_physical_filaments(), prepare_decompose_mixed_result(), and Slic3r::GUI::ColorDecomposeDialog::try_build_single_base_result().

Here is the call graph for this function:

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_ime_owns_key()

bool Slic3r::GUI::mac_ime_owns_key

(

void *

ns_view

)

{
    NSView* view = (NSView*) ns_view;
    NSEvent* event = [NSApp currentEvent];
    return view != nil && is_active(view) && event.type == NSEventTypeKeyDown &&
           (marked_text(view) != nil || get(view, &key_ime_event) == event);
}

Referenced by Slic3r::GUI::GLCanvas3D::on_key().

Here is the caller graph for this function:

mac_ime_set_active()

void Slic3r::GUI::mac_ime_set_active	(	void *	ns_view,
		bool	active )

{
    NSView* view = (NSView*) ns_view;
    if (view == nil || active == is_active(view))
        return;
    NSTextInputContext* context = get(view, &key_context);
    if (context == nil) {
        install([view class]);
        context = [[[NSTextInputContext alloc] initWithClient:(id<NSTextInputClient>) view] autorelease];
        set(view, &key_context, context);
    }
    // An open composition belongs to the field that lost input or to an earlier session; dropping it
    // first keeps the input method's callbacks from committing it.
    set_marked_text(view, nil, {});
    set(view, &key_active, @(active));
    if (active)
        [context activate];
    else {
        [context discardMarkedText];
        [context deactivate];
    }
}

Referenced by Slic3r::GUI::GLCanvas3D::bind_event_handlers(), and Slic3r::GUI::ImGuiWrapper::end_frame().

Here is the caller graph for this function:

mac_ime_set_caret()

void Slic3r::GUI::mac_ime_set_caret	(	void *	ns_view,
		int	x,
		int	y,
		int	height )

{
    NSView* view = (NSView*) ns_view;
    if (view == nil)
        return;
    const CGFloat scale = view.window != nil ? view.window.backingScaleFactor : 1.0;
    set(view, &key_caret, [NSValue valueWithRect:NSMakeRect(x / scale, y / scale, 1.0, height / scale)]);
}

References scale().

Referenced by Slic3r::GUI::ImGuiWrapper::init_input().

Here is the call graph for this function:

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(), ModeSwitchButton::doRender(), Slic3r::GUI::OpenGLManager::GLInfo::get_max_tex_size(), and SwitchButton::Rescale().

Here is the caller graph for this function:

main_frame_icon()

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());
        //BBS: remove GCodeViewer as seperate APP logic
        /*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("OrcaSlicer_128px.png"), wxBITMAP_TYPE_PNG);
#endif // _WIN32
}

References Slic3r::var().

Here is the call graph for this function:

make_alpha_bitmap()

wxBitmap Slic3r::GUI::make_alpha_bitmap ( int w, int h, const std::function< void(wxDC &dc)> & draw_fn )

static

{
    wxBitmap bmp(w, h);
    wxMemoryDC memdc;
#ifdef __WXOSX__
    bmp.UseAlpha();
    memdc.SelectObject(bmp);
#else
    {
        wxImage img(w, h);
        img.InitAlpha();
        memset(img.GetAlpha(), 0, w * h);
        bmp = wxBitmap(std::move(img));
    }
    memdc.SelectObject(bmp);
#endif
    {
#ifdef __WXMSW__
        wxGCDC dc(memdc);
#else
        wxDC& dc = memdc;
#endif
        draw_fn(dc);
    }
    memdc.SelectObject(wxNullBitmap);
    return bmp;
}

References make_alpha_bitmap().

Referenced by make_alpha_bitmap(), Slic3r::GUI::MixedFilamentDialog::make_swatch_bitmap(), and Slic3r::GUI::MixedFilamentDialog::update_gradient_direction_items().

Here is the call graph for this function:

Here is the caller graph for this function:

make_arc_through()

SketchEntity Slic3r::GUI::make_arc_through ( const Vec2d & center, double radius, const Vec2d & start, const Vec2d & end, const Vec2d & through, bool construction )

static

{
    const double a_start = std::atan2(start.y()  - center.y(), start.x()  - center.x());
    const double a_end   = std::atan2(end.y()    - center.y(), end.x()    - center.x());
    const double a_thru  = std::atan2(through.y() - center.y(), through.x() - center.x());
    const double de = wrap_2pi(a_end  - a_start);   // CCW sweep to end (0,2π)
    const double d3 = wrap_2pi(a_thru - a_start);   // CCW position of through
    SketchEntity e;
    e.type   = SketchEntity::Type::Arc;
    e.center = center;
    e.radius = radius;
    e.p0     = start;
    e.p1     = end;
    e.start_angle = a_start;
    e.end_angle   = (d3 <= de) ? (a_start + de) : (a_start + de - 2.0 * M_PI);
    e.construction = construction;
    return e;
}

References Slic3r::SketchEntity::Arc, Slic3r::center(), Slic3r::SketchEntity::center, Slic3r::SketchEntity::construction, Slic3r::SketchEntity::end_angle, M_PI, make_arc_through(), Slic3r::SketchEntity::p0, Slic3r::SketchEntity::p1, Slic3r::SketchEntity::radius, Slic3r::SketchEntity::start_angle, Slic3r::SketchEntity::type, and Slic3r::wrap_2pi().

Referenced by Slic3r::GUI::DesignSketchTool::make_arc_slot(), make_arc_through(), Slic3r::GUI::DesignSketchTool::make_center_arc(), Slic3r::GUI::DesignSketchTool::make_slot(), Slic3r::GUI::DesignSketchTool::make_tangent_arc(), Slic3r::GUI::DesignSketchTool::make_three_point_arc(), and Slic3r::GUI::DesignSketchTool::rounded_rect_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

make_bold()

void Slic3r::GUI::make_bold ( wxString & str )

static

{
#if defined(SUPPORTS_MARKUP) && !defined(__APPLE__)
    str = format_wxstr("<b>%1%</b>", str);
#endif
}

References format_wxstr().

Referenced by Slic3r::GUI::ParamsNode::GetFormattedText().

Here is the call graph for this function:

Here is the caller graph for this function:

make_card()

StaticBox * Slic3r::GUI::make_card ( wxWindow * parent )

static

{
    auto* c = new StaticBox(parent);
    c->SetCornerRadius(8);
    // The light literal in a StateColor is mapped to the dark one at paint time, so the frame
    // follows a theme switch by itself. No hover accent: the frame is not clickable.
    c->SetBorderColor(StateColor(kDpTokens[TokBorder].light));
    return c;
}

References kDpTokens, and TokBorder.

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

Here is the caller graph for this function:

make_combo()

ComboBox * Slic3r::GUI::make_combo ( wxWindow * parent )

static

{
    // Explicit width: ComboBox's natural best size is its widest item, which inflated the
  // sidebar's virtual width past the viewport and left the panel horizontally scrolled —
  // that is what clipped the first letter of every label. The form column grows anyway.
    auto* c = new ComboBox(parent, wxID_ANY, wxEmptyString, wxDefaultPosition,
                           wxSize(parent->FromDIP(90), parent->FromDIP(24)), 0, nullptr, wxCB_READONLY);
    c->SetMinSize(wxSize(parent->FromDIP(90), parent->FromDIP(24)));
    return c;
}

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

Here is the caller graph for this function:

make_spin()

wxSpinCtrlDouble * Slic3r::GUI::make_spin ( wxWindow * parent, double val, double mn = 0.1, double mx = 1000.0 )

static

{
    auto* box = new StaticBox(parent);
    box->SetCornerRadius(4);
    box->SetBorderColor(StateColor(kDpTokens[TokBorder].light));
    auto* s = new wxSpinCtrlDouble(box, wxID_ANY, "", wxDefaultPosition, parent->FromDIP(wxSize(90, -1)),
                                   wxSP_ARROW_KEYS | wxBORDER_NONE);
    s->SetRange(mn, mx);
    s->SetDigits(2);
    s->SetValue(val);
    // THE WHEEL SCROLLS THE PANEL, IT DOES NOT EDIT THE VALUE. wxSpinCtrlDouble takes the wheel
    // whenever the pointer is over it, so a card taller than the panel could not be scrolled past
    // without silently incrementing whatever field happened to be under the cursor — measured:
    // eight notches turned an X hint from 1,00 into 6,00, and the same gesture over an Extrude
    // distance or a mate Offset is a silent model change made by someone who thought they were
    // navigating. Skipping the event lets it reach the scrolled cards panel. A spin the user has
    // deliberately focused still takes the wheel, which is the one case where editing is meant.
    s->Bind(wxEVT_MOUSEWHEEL, [s](wxMouseEvent& e) {
        if (wxWindow::FindFocus() == s) e.Skip();          // focused: wheel edits, as expected
        else if (wxWindow* p = s->GetParent())             // otherwise hand it to the panel
            wxPostEvent(p, e);
    });
    auto* sz = new wxBoxSizer(wxHORIZONTAL);
    sz->Add(s, 1, wxEXPAND | wxALL, parent->FromDIP(2));
    box->SetSizer(sz);
    return s;
}

References kDpTokens, TokBorder, and wxMouseEvent.

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

Here is the caller graph for this function:

make_string_bold()

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:

manuallySetNozzleCount()

void Slic3r::GUI::manuallySetNozzleCount

(

int

extruder_id

)

{
    PresetBundle *preset_bundle = wxGetApp().preset_bundle;
    if (!preset_bundle)
        return;
 
    DynamicPrintConfig full_config      = preset_bundle->full_config();
    auto              *max_nozzle_count = full_config.option<ConfigOptionIntsNullable>("extruder_max_nozzle_count");
    // Multi-nozzle gate: no-op for every single-nozzle / dual-extruder ({1,1}) printer.
    // Skip nil entries: a nullable-int nil is INT_MAX (> 1) and would otherwise falsely pass the gate.
    if (!max_nozzle_count ||
        !std::any_of(max_nozzle_count->values.begin(), max_nozzle_count->values.end(),
                     [](int v) { return v > 1 && v != ConfigOptionIntsNullable::nil_value(); }))
        return;
 
    auto *nozzle_volume_type_opt = full_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
    if (!nozzle_volume_type_opt || extruder_id < 0 || extruder_id >= (int) nozzle_volume_type_opt->values.size() ||
        extruder_id >= (int) max_nozzle_count->values.size())
        return;
 
    const NozzleVolumeType volume_type    = NozzleVolumeType(nozzle_volume_type_opt->values[extruder_id]);
    const int              standard_count = getExtruderNozzleCount(preset_bundle, extruder_id, nvtStandard);
    const int              highflow_count = getExtruderNozzleCount(preset_bundle, extruder_id, nvtHighFlow);
    const int              e3d_count      = getExtruderNozzleCount(preset_bundle, extruder_id, nvtE3DHighFlow);
 
    // Require at least one nozzle for a Hybrid extruder (an empty mix is meaningless) and when the other
    // extruder currently has none.
    bool force_no_zero = volume_type == nvtHybrid;
    if (nozzle_volume_type_opt->values.size() > 1)
        force_no_zero |= getExtruderNozzleCountTotal(preset_bundle, 1 - extruder_id) == 0;
 
    // The printer profile's variant list is the authority on which volume types an extruder provides. An
    // empty set means the profile could not be read, and the dialog then skips filtering instead of hiding
    // everything.
    const std::set<NozzleVolumeType> supported_types =
        get_extruder_supported_nozzle_volume_types(preset_bundle->printers.get_edited_preset().config, extruder_id);
 
    ManualNozzleCountDialog dialog(wxGetApp().plater(), volume_type, standard_count, highflow_count, e3d_count,
                                   max_nozzle_count->values[extruder_id], force_no_zero, supported_types);
    if (dialog.ShowModal() == wxID_OK) {
        if (volume_type == nvtHybrid) {
            setExtruderNozzleCount(preset_bundle, extruder_id, nvtStandard, dialog.GetNozzleCount(nvtStandard), true);
            setExtruderNozzleCount(preset_bundle, extruder_id, nvtHighFlow, dialog.GetNozzleCount(nvtHighFlow), false);
            setExtruderNozzleCount(preset_bundle, extruder_id, nvtE3DHighFlow, dialog.GetNozzleCount(nvtE3DHighFlow), false);
        } else {
            setExtruderNozzleCount(preset_bundle, extruder_id, volume_type, dialog.GetNozzleCount(volume_type), true);
        }
        updateNozzleCountDisplay(preset_bundle, extruder_id, volume_type);
        wxGetApp().plater()->update();
    }
}

References Slic3r::Preset::config, Slic3r::PresetBundle::full_config(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::get_extruder_supported_nozzle_volume_types(), getExtruderNozzleCount(), getExtruderNozzleCountTotal(), Slic3r::GUI::ManualNozzleCountDialog::GetNozzleCount(), Slic3r::nvtE3DHighFlow, Slic3r::nvtHighFlow, Slic3r::nvtHybrid, Slic3r::nvtStandard, Slic3r::ConfigBase::option(), plater(), Slic3r::PresetBundle::printers, setExtruderNozzleCount(), Slic3r::GUI::DPIAware< P >::ShowModal(), and updateNozzleCountDisplay().

Referenced by Slic3r::GUI::FilamentMapManualPanel::FilamentMapManualPanel(), Slic3r::GUI::Sidebar::Sidebar(), and Slic3r::GUI::FilamentMapManualPanel::OnSuggestionClicked().

Here is the call graph for this function:

Here is the caller graph for this function:

marker_scale()

double Slic3r::GUI::marker_scale ( const GLCanvas3D & canvas )

static

{
    double scale = canvas.get_scale();
#ifdef WIN32
    scale *= double(get_dpi_for_window(wxGetApp().GetTopWindow())) / double(DPI_DEFAULT);
#endif // WIN32
    return scale;
}

References DPI_DEFAULT, get_dpi_for_window(), Slic3r::GUI::GLCanvas3D::get_scale(), marker_scale(), and scale().

Referenced by marker_scale(), Slic3r::GUI::GLCanvas3D::CenterOfMass::on_left_down(), and Slic3r::GUI::GLCanvas3D::CenterOfMass::render_details().

Here is the call graph for this function:

Here is the caller graph for this function:

market_model_scoring_page()

void Slic3r::GUI::market_model_scoring_page ( int design_id )

static

{
    std::string url;
    std::string country_code   = GUI::wxGetApp().app_config->get_country_code();
    std::string model_http_url = GUI::wxGetApp().get_model_http_url(country_code);
    if (GUI::wxGetApp().getAgent()->get_model_mall_detail_url(&url, std::to_string(design_id), GUI::wxGetApp().get_printer_cloud_provider()) == 0) {
        std::string user_id = GUI::wxGetApp().getAgent()->get_user_id(GUI::wxGetApp().get_printer_cloud_provider());
        boost::algorithm::replace_first(url, "models", "u/" + user_id + "/rating");
        // Prevent user_id from containing design_id
        size_t      sign_in = url.find("/rating");
        std::string sub_url = url.substr(0, sign_in + 7);
        url.erase(0, sign_in + 7);
        boost::algorithm::replace_first(url, std::to_string(design_id), "");
        url = sub_url + url;
        try {
            if (!url.empty()) { wxLaunchDefaultBrowser(url); }
        } catch (...) {
            return;
        }
    }
}

Referenced by Slic3r::GUI::ScoreDialog::get_button_sizer().

Here is the caller graph for this function:

mass_sum()

GCodeProcessorResult::ObjectMass::Sum Slic3r::GUI::mass_sum ( const MassProperties & solid )

static

{
    return { solid.mass, solid.volume, solid.mass * solid.center,
             solid.mass * (solid.spread.diagonal() + solid.center.cwiseProduct(solid.center)) };
}

References Slic3r::MassProperties::center, Slic3r::MassProperties::mass, mass_sum(), Slic3r::MassProperties::spread, and Slic3r::MassProperties::volume.

Referenced by mass_sum(), and Slic3r::GUI::GLCanvas3D::CenterOfMass::model_markers().

Here is the call graph for this function:

Here is the caller graph for this function:

match_parent_bg()

void Slic3r::GUI::match_parent_bg ( wxWindow * w, const wxColour & bg )

static

{
    w->SetBackgroundColour(bg);
}

Referenced by Slic3r::GUI::ColorDecomposeDialog::create_mode_card(), and Slic3r::GUI::ColorDecomposeDialog::update_mode_card_content().

Here is the caller graph for this function:

material_type_matches()

bool Slic3r::GUI::material_type_matches ( const std::string & a, const std::string & b )

static

{
    if (a.empty() || b.empty())
        return false;
    return a == b || a == b + " Basic" || b == a + " Basic";
}

Referenced by Slic3r::GUI::ColorDecomposeDialog::update_card_visibility().

Here is the caller graph for this function:

measure_mixed_text()

wxSize Slic3r::GUI::measure_mixed_text ( wxWindow * parent, const std::string & msg, const wxFont & prose_font, const wxFont & code_font )

static

{
    wxClientDC dc(parent);
    int width = 0, height = 0;
    for (const auto &[text, is_code] : classify_code_lines(msg)) {
        dc.SetFont(is_code ? code_font : prose_font);
        width   = std::max(width, dc.GetTextExtent(wxString::FromUTF8(text.c_str())).GetWidth());
        height += dc.GetCharHeight();
    }
    return wxSize(width, height);
}

References classify_code_lines().

Referenced by add_msg_content().

Here is the call graph for this function:

Here is the caller graph for this function:

menu_item_with_icon()

bool Slic3r::GUI::menu_item_with_icon	(	const char *	label,
		const char *	shortcut,
		ImVec2	icon_size,
		ImU32	icon_color,
		bool	selected,
		bool	enabled,
		bool *	hovered )

{
    ImGuiWindow *window = ImGui::GetCurrentWindow();
    if (window->SkipItems) return false;
 
    ImGuiContext &g          = *GImGui;
    ImGuiStyle &  style      = g.Style;
    ImVec2        pos        = window->DC.CursorPos;
    ImVec2        label_size = ImGui::CalcTextSize(label, NULL, true);
 
    // We've been using the equivalent of ImGuiSelectableFlags_SetNavIdOnHover on all Selectable() since early Nav system days (commit 43ee5d73),
    // but I am unsure whether this should be kept at all. For now moved it to be an opt-in feature used by menus only.
    ImGuiSelectableFlags flags = ImGuiSelectableFlags_SelectOnRelease | ImGuiSelectableFlags_SetNavIdOnHover | (enabled ? 0 : ImGuiSelectableFlags_Disabled);
    bool                 pressed;
    if (window->DC.LayoutType == ImGuiLayoutType_Horizontal) {
        // Mimic the exact layout spacing of BeginMenu() to allow MenuItem() inside a menu bar, which is a little misleading but may be useful
        // Note that in this situation: we don't render the shortcut, we render a highlight instead of the selected tick mark.
        float w = label_size.x;
        window->DC.CursorPos.x += IM_FLOOR(style.ItemSpacing.x * 0.5f);
        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(style.ItemSpacing.x * 2.0f, style.ItemSpacing.y));
        pressed = ImGui::Selectable(label, selected, flags, ImVec2(w, 0.0f));
        ImGui::PopStyleVar();
        window->DC.CursorPos.x += IM_FLOOR(
            style.ItemSpacing.x *
            (-1.0f +
             0.5f)); // -1 spacing to compensate the spacing added when Selectable() did a SameLine(). It would also work to call SameLine() ourselves after the PopStyleVar().
    } else {
        // Menu item inside a vertical menu
        // (In a typical menu window where all items are BeginMenu() or MenuItem() calls, extra_w will always be 0.0f.
        //  Only when they are other items sticking out we're going to add spacing, yet only register minimum width into the layout system.
        float shortcut_w = shortcut ? ImGui::CalcTextSize(shortcut, NULL).x : 0.0f;
        float min_w      = window->DC.MenuColumns.DeclColumns(label_size.x, shortcut_w, IM_FLOOR(g.FontSize * 1.20f)); // Feedback for next frame
        float extra_w    = std::max(0.0f, ImGui::GetContentRegionAvail().x - min_w);
        pressed          = selectable(label, false, flags | ImGuiSelectableFlags_SpanAvailWidth, ImVec2(min_w, 0.0f), hovered);
 
        if (icon_size.x != 0 && icon_size.y != 0) {
            float selectable_pos_y = pos.y + -0.5f * style.ItemSpacing.y;
            float icon_pos_y = selectable_pos_y + (label_size.y + style.ItemSpacing.y - icon_size.y) / 2;
            float icon_pos_x = pos.x + window->DC.MenuColumns.Pos[2] + extra_w + g.FontSize * 0.40f;
            ImVec2 icon_pos = ImVec2(icon_pos_x, icon_pos_y);
            if (icon_color != 0)
                ImGui::RenderFrame(icon_pos, icon_pos + icon_size, icon_color);
            else {
                static ImTextureID transparent;
                IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/transparent.svg", icon_size.x, icon_size.y, transparent);
                window->DrawList->AddImage(transparent, icon_pos, icon_pos + icon_size, { 0,0 }, { 1,1 }, ImGui::GetColorU32(ImVec4(1.f, 1.f, 1.f, 1.f)));
            }
        }
 
        if (shortcut_w > 0.0f) {
            ImGui::PushStyleColor(ImGuiCol_Text, g.Style.Colors[ImGuiCol_TextDisabled]);
            ImGui::RenderText(pos + ImVec2(window->DC.MenuColumns.Pos[1] + extra_w, 0.0f), shortcut, NULL, false);
            ImGui::PopStyleColor();
        }
        if (selected) {
            //ImGui::RenderCheckMark(window->DrawList, pos + ImVec2(window->DC.MenuColumns.Pos[2] + extra_w + g.FontSize * 0.40f, g.FontSize * 0.134f * 0.5f),
            //                       ImGui::GetColorU32(enabled ? ImGuiCol_Text : ImGuiCol_TextDisabled), g.FontSize * 0.866f);
        }
    }
 
    IMGUI_TEST_ENGINE_ITEM_INFO(window->DC.LastItemId, label, window->DC.LastItemStatusFlags | ImGuiItemStatusFlags_Checkable | (selected ? ImGuiItemStatusFlags_Checked : 0));
    return pressed;
}

References Slic3r::GUI::IMTexture::load_from_svg_file(), Slic3r::resources_dir(), selectable(), and style.

Referenced by Slic3r::GUI::IMSlider::render_add_menu(), and Slic3r::GUI::IMSlider::render_edit_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

min_delta_area()

double Slic3r::GUI::min_delta_area ( )

inline

{ return scale_(scale_(25)); }

References scale_.

Referenced by check_color_change().

Here is the caller graph for this function:

miscalculation()

double Slic3r::GUI::miscalculation ( )

inline

{ return scale_(scale_(1)); }

References scale_.

Referenced by equivalent_areas().

Here is the caller graph for this function:

mix_colour()

wxColour Slic3r::GUI::mix_colour ( const wxColour & left, const wxColour & right, double ratio )

static

{
    ratio = std::max(0.0, std::min(1.0, ratio));
    auto mix_channel = [ratio](unsigned char l, unsigned char r) {
        return static_cast<unsigned char>(std::round(l + (r - l) * ratio));
    };
    return wxColour(mix_channel(left.Red(), right.Red()),
                    mix_channel(left.Green(), right.Green()),
                    mix_channel(left.Blue(), right.Blue()),
                    mix_channel(left.Alpha(), right.Alpha()));
}

Referenced by Slic3r::GUI::ColorPicker::doRender().

Here is the caller graph for this function:

mixed_gradient_curve()

Slic3r::GradientCurve Slic3r::GUI::mixed_gradient_curve	(	const Slic3r::DynamicPrintConfig &	cfg,
		size_t	slot )

{
    const auto* curve_opt = cfg.option<ConfigOptionStrings>("filament_mixed_gradient_curve");
    if (curve_opt && slot < curve_opt->values.size() && !curve_opt->values[slot].empty()) {
        Slic3r::GradientCurve custom = Slic3r::parse_gradient_curve(curve_opt->values[slot]);
        if (custom.points.size() >= 2) return custom;
    }
 
    double start = kGradientMinRatio, end = kGradientMaxRatio;
    const auto* range_opt = cfg.option<ConfigOptionStrings>("filament_mixed_gradient_range");
    if (range_opt && slot < range_opt->values.size() && !range_opt->values[slot].empty()) {
        CNumericLocalesSetter c_locale_setter;
        float v0 = 0, v1 = 0;
        if (std::sscanf(range_opt->values[slot].c_str(), "%f,%f", &v0, &v1) == 2 &&
            v0 > 0 && v0 < 1.0 && v1 > 0 && v1 < 1.0) {
            start = v0;
            end   = v1;
        }
    }
 
    Slic3r::GradientCurve curve;
    curve.points = {{0.0, start, NAN, NAN}, {1.0, end, NAN, NAN}};
    return curve;
}

References Slic3r::kGradientMaxRatio, Slic3r::kGradientMinRatio, Slic3r::ConfigBase::option(), Slic3r::parse_gradient_curve(), and Slic3r::GradientCurve::points.

Referenced by Slic3r::GUI::PublishSettingsDialog::make_mixed_visual_spec(), and mixed_gradient_ramp().

Here is the call graph for this function:

Here is the caller graph for this function:

mixed_gradient_plot_rect()

wxRect Slic3r::GUI::mixed_gradient_plot_rect

(

const wxSize &

sz

)

{
    const int x  = static_cast<int>(std::lround(sz.x * kPlotLeftRatio));
    const int y  = static_cast<int>(std::lround(sz.y * kPlotTopRatio));
    const int x2 = static_cast<int>(std::lround(sz.x * kPlotRightRatio));
    const int y2 = static_cast<int>(std::lround(sz.y * kPlotBottomRatio));
    const int side = std::max(1, std::min(x2 - x, y2 - y));
    return wxRect(x, y, side, side);
}

Referenced by Slic3r::GUI::PublishSettingsDialog::add_mixed_visual(), draw_mixed_gradient_plot(), and Slic3r::GUI::GradientCurveEditor::plot_rect().

Here is the caller graph for this function:

mixed_gradient_ramp()

std::vector< wxColour > Slic3r::GUI::mixed_gradient_ramp	(	const Slic3r::DynamicPrintConfig &	cfg,
		size_t	slot,
		int	steps )

{
    const auto* is_mixed_opt = cfg.option<ConfigOptionBools>("filament_is_mixed");
    const auto* grad_opt     = cfg.option<ConfigOptionBools>("filament_mixed_gradient");
    const auto* comp_opt     = cfg.option<ConfigOptionStrings>("filament_mixed_components");
    const auto* colour_opt   = cfg.option<ConfigOptionStrings>("filament_colour");
    if (!is_mixed_opt || !grad_opt || !comp_opt || !colour_opt) return {};
    if (slot >= is_mixed_opt->values.size() || !is_mixed_opt->values[slot]) return {};
    if (slot >= grad_opt->values.size() || !grad_opt->values[slot]) return {};
    if (slot >= comp_opt->values.size()) return {};
 
    // Only two-component slots fade; anything else stays on the plain blended swatch.
    const auto comp_ids = Slic3r::parse_mixed_components(comp_opt->values[slot]);
    if (comp_ids.size() != 2) return {};
 
    auto component_colour = [&](unsigned int id) {
        wxColour c = (id >= 1 && id <= colour_opt->values.size()) ? wxColour(colour_opt->values[id - 1]) : wxColour();
        return c.IsOk() ? c : wxColour("#D9D9D9");
    };
 
    // Both gradient_range and the curve express the *first* component's ratio over Z, so
    // the components stay in config order and the curve alone decides which end is which.
    return sample_gradient_ramp(component_colour(comp_ids[0]), component_colour(comp_ids[1]),
                                mixed_gradient_curve(cfg, slot), steps);
}

References mixed_gradient_curve(), Slic3r::ConfigBase::option(), Slic3r::parse_mixed_components(), sample_gradient_ramp(), Slic3r::ConfigOptionVector< T >::values, and Slic3r::ConfigOptionVector< unsigned char >::values.

Referenced by Slic3r::GUI::Plater::get_filament_gradient_ramps(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::mixed_filament_chip_bitmap(), and Slic3r::GUI::Sidebar::update_mixed_filament_list().

Here is the call graph for this function:

Here is the caller graph for this function:

mixed_triangle_vertices()

std::array< TriPoint, 3 > Slic3r::GUI::mixed_triangle_vertices	(	const wxSize &	size,
		double	margin_dip )

{
    const double pw = size.GetWidth(), ph = size.GetHeight();
    const double margin = dip_px(int(margin_dip));
    const double avail  = std::min(pw, ph) - 2.0 * margin;
    const double side   = avail;
    const double tri_h  = side * std::sqrt(3.0) / 2.0;
    const double cx     = pw / 2.0;
    const double top_y  = (ph - tri_h) / 2.0;
    return {{{cx, top_y}, {cx - side / 2.0, top_y + tri_h}, {cx + side / 2.0, top_y + tri_h}}};
}

Referenced by draw_mixed_triangle_labels(), and draw_mixed_triangle_picker().

Here is the caller graph for this function:

mode_index()

size_t Slic3r::GUI::mode_index ( DecomposeMode mode )

static

{
    return static_cast<size_t>(mode);
}

Referenced by Slic3r::GUI::ColorDecomposeDialog::compute_decomposition(), Slic3r::GUI::ColorDecomposeDialog::create_mode_card(), Slic3r::GUI::ColorDecomposeDialog::select_mode(), and Slic3r::GUI::ColorDecomposeDialog::update_mode_card_content().

Here is the caller graph for this function:

move_volume_to_end()

void Slic3r::GUI::move_volume_to_end ( ModelObject * obj, ModelVolume * volume )

static

{
    if (obj == nullptr || volume == nullptr)
        return;
    auto it = std::find(obj->volumes.begin(), obj->volumes.end(), volume);
    if (it != obj->volumes.end()) {
        obj->volumes.erase(it);
        obj->volumes.push_back(volume);
    }
}

References Slic3r::ModelObject::volumes.

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

Here is the caller graph for this function:

my_stof()

float Slic3r::GUI::my_stof ( std::string str )

static

                                    {
 
    const char dec_sep     = is_decimal_separator_point() ? '.' : ',';
    const char dec_sep_alt = dec_sep == '.' ? ',' : '.';
 
    size_t alt_pos = str.find(dec_sep_alt);
    if (alt_pos != std::string::npos) { str.replace(alt_pos, 1, 1, dec_sep); }
 
    if (str == std::string(1, dec_sep)) { return 0.0f; }
 
    try {
        return static_cast<float>(std::stod(str));
    } catch (...) {
        return 0.f;
    }
}

References Slic3r::is_decimal_separator_point().

Referenced by Slic3r::GUI::CreatePrinterPresetDialog::create_page2_dialog_buttons(), Slic3r::GUI::CreatePrinterPresetDialog::generate_process_presets_data(), Slic3r::GUI::CreatePrinterPresetDialog::get_nozzle_diameter(), Slic3r::GUI::CreatePrinterPresetDialog::printer_preset_sort_with_nozzle_diameter(), and Slic3r::GUI::CreatePrinterPresetDialog::validate_input_valid().

Here is the call graph for this function:

Here is the caller graph for this function:

network_version_label()

wxString Slic3r::GUI::network_version_label

(

const NetworkLibraryVersionInfo &

ver

)

{
    wxString label = wxString::FromUTF8(ver.display_name);
    if (!ver.suffix.empty())
        label = wxString::FromUTF8("\xE2\x94\x94 ") + label;
    // Both can apply: the loaded build may also be the highest listed one.
    if (ver.is_latest)
        label += wxString(" ") + _L("(Latest)");
    if (ver.is_loaded)
        label += wxString(" ") + _L("(installed)");
    return label;
}

References _L, Slic3r::NetworkLibraryVersionInfo::display_name, Slic3r::NetworkLibraryVersionInfo::is_latest, Slic3r::NetworkLibraryVersionInfo::is_loaded, and Slic3r::NetworkLibraryVersionInfo::suffix.

Referenced by Slic3r::GUI::PreferencesDialog::create_item_network_plugin_version(), and Slic3r::GUI::NetworkPluginDownloadDialog::setup_version_selector().

Here is the caller graph for this function:

nop_deleter()

void Slic3r::GUI::nop_deleter ( InputIpAddressDialog * )

static

{}

Referenced by Slic3r::GUI::InputIpAddressDialog::on_ok().

Here is the caller graph for this function:

nop_deleter_fan_control()

void Slic3r::GUI::nop_deleter_fan_control ( FanControlNew * )

static

{}

nop_deleter_fan_control_popup()

void Slic3r::GUI::nop_deleter_fan_control_popup ( FanControlPopupNew * )

static

{}

nozzle_diameter_supports_tpu_high_flow()

bool Slic3r::GUI::nozzle_diameter_supports_tpu_high_flow

(

double

nozzle_diameter

)

{
    // "Direct Drive TPU High Flow" is offered only on the H2D/H2D Pro 0.4 and 0.6 nozzles.
    constexpr double kEps = 0.01;
    return std::fabs(nozzle_diameter - 0.4) < kEps || std::fabs(nozzle_diameter - 0.6) < kEps;
}

References Slic3r::nozzle_diameter().

Referenced by extruder_supports_tpu_high_flow().

Here is the call graph for this function:

Here is the caller graph for this function:

nozzle_id_code_to_string()

wxString Slic3r::GUI::nozzle_id_code_to_string ( int code )

static

{
    if (code == 0) {
        return "R";
    } else if (code >= 0x10) {
        return wxString::Format("%d", code - 0x10 + 1);
    } else {
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << "Nozzle position id is -1 or invalid.";
        return "N/A";
    }
}

Referenced by Slic3r::GUI::EditCalibrationHistoryDialog::EditCalibrationHistoryDialog(), and Slic3r::GUI::HistoryWindow::sync_history_data().

Here is the caller graph for this function:

obj_list()

ObjectList * Slic3r::GUI::obj_list ( )

static

{
    return wxGetApp().obj_list();
}

Referenced by _collect_sorted_machines(), Slic3r::GUI::MenuFactory::append_menu_item_auto_drop(), Slic3r::GUI::MenuFactory::append_menu_item_change_extruder(), Slic3r::GUI::MenuFactory::append_menu_item_change_filament(), Slic3r::GUI::MenuFactory::append_menu_item_fix_through_cgal(), Slic3r::GUI::MenuFactory::append_menu_item_instance_to_object(), Slic3r::GUI::MenuFactory::append_menu_item_invalidate_cut_info(), Slic3r::GUI::MenuFactory::append_menu_item_layers_editing(), Slic3r::GUI::MenuFactory::append_menu_item_merge_to_multipart_object(), Slic3r::GUI::MenuFactory::append_menu_item_merge_to_single_object(), Slic3r::GUI::MenuFactory::append_menu_item_modify(), Slic3r::GUI::MenuFactory::append_menu_item_precise_seam_submenu(), Slic3r::GUI::MenuFactory::append_menu_item_printable(), Slic3r::GUI::MenuFactory::append_menu_item_rename(), Slic3r::GUI::MenuFactory::append_menu_item_set_printable(), Slic3r::GUI::MenuFactory::append_menu_item_settings(), Slic3r::GUI::MenuFactory::append_menu_item_simplify(), Slic3r::GUI::MenuFactory::append_menu_item_smooth_mesh(), Slic3r::GUI::MenuFactory::append_menu_items_convert_unit(), Slic3r::GUI::MenuFactory::append_menu_items_flush_options(), Slic3r::GUI::MenuFactory::append_submenu_add_generic(), Slic3r::GUI::Plater::priv::apply_textured_mesh_import_result(), Slic3r::GUI::MenuFactory::assemble_multi_selection_menu(), Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), create_freq_settings_popupmenu(), Slic3r::GUI::MenuFactory::create_plate_menu(), create_settings_popupmenu(), anonymous_namespace{EmbossJob.cpp}::create_volume(), Slic3r::GUI::GLGizmoEmboss::draw_model_type(), Slic3r::GUI::GLGizmoSVG::draw_model_type(), ensure_belt_purge_tower(), Slic3r::GUI::FillBedJob::finalize(), Slic3r::GUI::TextureDisplacementPrepareJob::finalize(), Slic3r::GUI::GLGizmoEmboss::init_create(), Slic3r::GUI::MenuFactory::multi_selection_menu(), Slic3r::GUI::GLCanvas3D::on_char(), Slic3r::GUI::DesignPanel::on_commit(), Slic3r::GUI::GLCanvas3D::on_set_color_timer(), Slic3r::GUI::NotificationManager::push_slicing_serious_warning_notification(), Slic3r::GUI::ObjectGridTable::SetValue(), Slic3r::GUI::GLGizmoTextureDisplacement::smooth_model(), Slic3r::GUI::GLGizmoTextureDisplacement::subdivide_model(), Slic3r::GUI::GizmoObjectManipulation::update_settings_value(), and Slic3r::GUI::Emboss::UpdateJob::update_volume().

Here is the caller graph for this function:

offer_bit()

uint32_t Slic3r::GUI::offer_bit ( OfferSel s )

inline

{ return 1u << int(s); }

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_list_verbs(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_run_verb(), and Slic3r::GUI::DesignPanel::show_offer_menu().

Here is the caller graph for this function:

offer_trace()

void Slic3r::GUI::offer_trace ( const char * fmt, ... )

static

{
    static const bool on = std::getenv("ORCA_CAD_KEYTRACE") != nullptr;
    if (!on) return;
    va_list ap;
    va_start(ap, fmt);
    fprintf(stderr, "[OFFER] ");
    vfprintf(stderr, fmt, ap);
    fprintf(stderr, "\n");
    va_end(ap);
    fflush(stderr);
}

Referenced by Slic3r::GUI::DesignPanel::show_offer_menu().

Here is the caller graph for this function:

official_basic_type_from_preset_name()

std::string Slic3r::GUI::official_basic_type_from_preset_name

(

const std::string &

preset_name

)

{
    if (preset_name.find(std::string(kDecomposeBambuPresetPrefix) + kDecomposePlaBasicType) != std::string::npos)
        return kDecomposePlaBasicType;
    if (preset_name.find(std::string(kDecomposeBambuPresetPrefix) + kDecomposePetgBasicType) != std::string::npos)
        return kDecomposePetgBasicType;
    return {};
}

References kDecomposeBambuPresetPrefix, kDecomposePetgBasicType, and kDecomposePlaBasicType.

Referenced by filament_type_for_color_decompose(), and texture_entry_official_basic().

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,
		const 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("Move over surface"));
        wxGetApp().obj_manipul()->set_dirty();
 
        // 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;
 
    if (mouse_event.LeftDown())
        return start_dragging(mouse_position(mouse_event), camera, surface_drag, canvas, raycast_manager, up_limit);
 
    // Dragging starts out of window
    if (!surface_drag.has_value())
        return false;
 
    if (mouse_event.Dragging())
        return dragging(mouse_position(mouse_event), camera, *surface_drag, canvas, raycast_manager, up_limit);
 
    return false;
}

References Slic3r::GUI::GLCanvas3D::do_move(), Slic3r::GUI::GLCanvas3D::enable_moving(), Slic3r::GUI::GLCanvas3D::enable_picking(), L, and wxMouseEvent.

Referenced by Slic3r::GUI::GLGizmoEmboss::on_mouse_for_translate(), and Slic3r::GUI::GLGizmoSVG::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:

onNozzleVolumeTypeSwitch()

void Slic3r::GUI::onNozzleVolumeTypeSwitch	(	PresetBundle *	preset_bundle,
		int	extruder_id,
		NozzleVolumeType	type )

{
    if (!preset_bundle)
        return;
    // Machine-synced stats carry the device's per-type breakdown; a flow switch must not collapse it.
    if (s_nozzle_stats_from_machine)
        return;
    // Hybrid is a mix, not a type every nozzle shares, so there is nothing to carry over.
    if (type == nvtHybrid)
        return;
    const int total = getExtruderNozzleCountTotal(preset_bundle, extruder_id);
    setExtruderNozzleCount(preset_bundle, extruder_id, type, total, true);
}

References getExtruderNozzleCountTotal(), Slic3r::nvtHybrid, s_nozzle_stats_from_machine, and setExtruderNozzleCount().

Referenced by Slic3r::GUI::TabPrinter::set_extruder_volume_type().

Here is the call graph for this function:

Here is the caller graph for this function:

open_cloud_url_externally()

void Slic3r::GUI::open_cloud_url_externally ( const wxString & url )

static

{
    if (url.empty())
        return;
    BOOST_LOG_TRIVIAL(info) << "cloud pane: opening externally " << WebView::RedactUrl(url).ToUTF8().data();
    wxGetApp().CallAfter([url] { wxLaunchDefaultBrowser(url); });
}

References WebView::RedactUrl().

Referenced by Slic3r::GUI::WebViewPanel::OnCloudWebViewEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

open_filament_group_wiki()

bool Slic3r::GUI::open_filament_group_wiki

(

)

{
    if (wxLaunchDefaultBrowser("https://e.bambulab.com/t?c=mOkvsXkJ9pldGYp9")) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("Wiki is being displayed using the system's default browser.");
        return true;
    }
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format("launch system's default browser failed");
    return false;
}

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

Here is the caller graph for this function:

open_ms_store_product_page()

void Slic3r::GUI::open_ms_store_product_page

(

)

{
#ifdef _WIN32
    struct GetCurrentPackageFamilyName_t { typedef LONG (WINAPI *FN)(UINT32 *length, PWSTR family_name); };
    static auto fn = winapi_get_function<GetCurrentPackageFamilyName_t>(L"Kernel32.dll", "GetCurrentPackageFamilyName");
    if (fn == nullptr)
        return;
    UINT32 length = 0;
    if (fn(&length, nullptr) != ERROR_INSUFFICIENT_BUFFER)
        return;
    std::wstring family_name(length, L'\0');
    if (fn(&length, family_name.data()) != ERROR_SUCCESS)
        return;
    family_name.resize(length > 0 ? length - 1 : 0); // drop the terminating null
    wxLaunchDefaultBrowser(wxString(L"ms-windows-store://pdp/?PFN=") + family_name.c_str());
#endif
}

References L, and Slic3r::length().

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

Here is the call graph for this function:

Here is the caller graph for this function:

open_plugin_hub()

void Slic3r::GUI::open_plugin_hub

(

)

{
    std::string cloud_base_url = "https://cloud.orcaslicer.com";
 
    if (wxGetApp().getAgent()) {
        auto orca_agent = std::dynamic_pointer_cast<OrcaCloudServiceAgent>(wxGetApp().getAgent()->get_cloud_agent());
        if (orca_agent && !orca_agent->get_cloud_base_url().empty())
            cloud_base_url = orca_agent->get_cloud_base_url();
    }
 
    while (!cloud_base_url.empty() && cloud_base_url.back() == '/')
        cloud_base_url.pop_back();
    if (cloud_base_url.empty())
        cloud_base_url = "https://cloud.orcaslicer.com";
 
    wxLaunchDefaultBrowser(wxString::FromUTF8(cloud_base_url + "/app/plugins/plugin-hub"));
}

Referenced by Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), and Slic3r::GUI::PluginsDialog::open_plugin_hub().

Here is the caller graph for this function:

openFolderForFile()

void Slic3r::GUI::openFolderForFile

(

wxString const &

file

)

{
    NSArray *fileURLs = [NSArray arrayWithObjects:wxCFStringRef(file).AsNSString(), /* ... */ nil];
    [[NSWorkspace sharedWorkspace] activateFileViewerSelectingURLs:fileURLs];
}

Referenced by desktop_open_any_folder().

Here is the caller graph for this function:

operator<()

bool Slic3r::GUI::operator< ( const DriveData & lhs, const DriveData & rhs )

inline

{ return lhs.path < rhs.path; }

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

{ return lhs.path == rhs.path; }

References Slic3r::GUI::DriveData::path.

Referenced by Slic3r::GUI::Sidebar::priv::update_sync_status().

Here is the caller graph for this function:

operator>()

bool Slic3r::GUI::operator> ( const DriveData & lhs, const DriveData & rhs )

inline

{ return lhs.path > rhs.path; }

References Slic3r::GUI::DriveData::path.

option_id_in_map()

std::string Slic3r::GUI::option_id_in_map ( const t_opt_map & options, const t_config_option_key & opt_key, int & opt_index )

inline

{
    if (opt_index >= 0) {
        for (const auto& opt : options) {
            if (opt.second.first == opt_key && opt.second.second == opt_index) {
                opt_index = opt.second.second;
                return opt.first;
            }
        }
        return {};
    }
 
    std::string opt_id;
    for (const auto& opt : options) {
        if (opt.second.first != opt_key)
            continue;
        if (!opt_id.empty())
            return {}; // several entries: a vector option, not one value
        opt_id    = opt.first;
        opt_index = opt.second.second;
    }
    return opt_id;
}

Referenced by Slic3r::GUI::ConfigOptionsGroup::commit_config_value().

Here is the caller graph for this function:

organize_cannot_reasons_text()

wxString Slic3r::GUI::organize_cannot_reasons_text

(

std::vector< DevAms::CannotDryReason > &

reasons

)

{
    wxString cannot_reasons_text;
    if (std::find(reasons.begin(), reasons.end(), DevAms::CannotDryReason::DryingInProgress) != reasons.end()) {
        cannot_reasons_text += get_cannot_reason_text(DevAms::CannotDryReason::DryingInProgress);
    } else if (std::find(reasons.begin(), reasons.end(), DevAms::CannotDryReason::AmsBusy) != reasons.end()) {
        cannot_reasons_text += get_cannot_reason_text(DevAms::CannotDryReason::AmsBusy);
    } else if (std::find(reasons.begin(), reasons.end(), DevAms::CannotDryReason::ConsumableAtAmsOutlet) != reasons.end()) {
        cannot_reasons_text += get_cannot_reason_text(DevAms::CannotDryReason::ConsumableAtAmsOutlet);
    } else if (std::find(reasons.begin(), reasons.end(), DevAms::CannotDryReason::FilamentAtAmsOutletManualUnload) != reasons.end()) {
        cannot_reasons_text += get_cannot_reason_text(DevAms::CannotDryReason::FilamentAtAmsOutletManualUnload);
    }
 
    if (std::find(reasons.begin(), reasons.end(), DevAms::CannotDryReason::InsufficientPower) != reasons.end()) {
        cannot_reasons_text += get_cannot_reason_text(DevAms::CannotDryReason::InsufficientPower);
    }
 
    for (auto reason : reasons) {
        if (reason == DevAms::CannotDryReason::InsufficientPowerNeedPluginPower) {
            cannot_reasons_text += get_cannot_reason_text(DevAms::CannotDryReason::InsufficientPowerNeedPluginPower);
        } else if (reason == DevAms::CannotDryReason::NotSupportedIn2dMode) {
            cannot_reasons_text += get_cannot_reason_text(DevAms::CannotDryReason::NotSupportedIn2dMode);
        } else if (reason == DevAms::CannotDryReason::InitiatingAmsDrying) {
            cannot_reasons_text += get_cannot_reason_text(DevAms::CannotDryReason::InitiatingAmsDrying);
        } else if (reason == DevAms::CannotDryReason::Upgrading) {
            cannot_reasons_text += get_cannot_reason_text(DevAms::CannotDryReason::Upgrading);
        }
    }
 
    if (cannot_reasons_text.empty()) {
        cannot_reasons_text += "*" + _L("System is busy") + "\n";
        cannot_reasons_text += _L("  Initiating other drying processes, please wait a few seconds...") + "\n";
    }
 
    return cannot_reasons_text;
}

References _L, Slic3r::DevAms::AmsBusy, Slic3r::DevAms::ConsumableAtAmsOutlet, Slic3r::DevAms::DryingInProgress, Slic3r::DevAms::FilamentAtAmsOutletManualUnload, get_cannot_reason_text(), Slic3r::DevAms::InitiatingAmsDrying, Slic3r::DevAms::InsufficientPower, Slic3r::DevAms::InsufficientPowerNeedPluginPower, Slic3r::DevAms::NotSupportedIn2dMode, and Slic3r::DevAms::Upgrading.

Referenced by Slic3r::GUI::AMSDryCtrWin::update_state().

Here is the call graph for this function:

Here is the caller graph for this function:

origin_toggle_text()

wxString Slic3r::GUI::origin_toggle_text ( bool shown )

static

{
    return shown ? _L("Hide reference planes and axes") : _L("Show reference planes and axes");
}

References _L.

Referenced by Slic3r::GUI::DesignPanel::DesignPanel(), and Slic3r::GUI::DesignPanel::refresh_pinned().

Here is the caller graph for this function:

pad_combo_value_for_config()

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::DynamicConfig::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:

page_label()

wxStaticText * Slic3r::GUI::page_label ( wxStaticText * lbl )

static

{
    lbl->SetForegroundColour(wxColour("#363636"));
    wxGetApp().UpdateDarkUI(lbl);
    return lbl;
}

References wxStaticText.

Referenced by Slic3r::GUI::IMEXModesCtrl::add_row(), and Slic3r::GUI::IMEXModesCtrl::rebuild_info_and_header().

Here is the caller graph for this function:

pan_camera()

void Slic3r::GUI::pan_camera ( Camera & camera, const Vec2d & screen_delta, const Vec3d & anchor )

static

{
    // Orca: Derive world-units-per-pixel from the projection which produced the visible frame.
    // Perspective additionally scales with the eye-space depth of the point being dragged.
    const auto& viewport = camera.get_viewport();
    const auto& projection = camera.get_projection_matrix().matrix();
    const double depth_scale = camera.get_type() == Camera::EType::Perspective ?
        (anchor - camera.get_position()).dot(camera.get_dir_forward()) : 1.0;
    const double projection_x = projection(0, 0) * viewport[2];
    const double projection_y = projection(1, 1) * viewport[3];
 
    // Orca: X/Y projection coefficients already include zoom. Using them directly avoids a
    // project/unproject round-trip through window depth, whose precision depends on the scene frustum.
    if (viewport[2] > 0 && viewport[3] > 0 && anchor.allFinite() && depth_scale > EPSILON &&
        std::abs(projection_x) > EPSILON && std::abs(projection_y) > EPSILON) {
        const Vec3d displacement = 2.0 * depth_scale *
            (screen_delta.y() / projection_y * camera.get_dir_up() -
             screen_delta.x() / projection_x * camera.get_dir_right());
        if (displacement.allFinite()) {
            camera.translate(displacement);
            return;
        }
    }
 
    // Orca: Preserve the former target-plane behavior if the projection or anchor is invalid.
    // Screen Y grows downward, and the camera moves opposite to the drag.
    camera.translate(camera.get_inv_zoom() *
        (screen_delta.y() * camera.get_dir_up() - screen_delta.x() * camera.get_dir_right()));
}

References EPSILON, Slic3r::GUI::Camera::get_dir_forward(), Slic3r::GUI::Camera::get_dir_right(), Slic3r::GUI::Camera::get_dir_up(), Slic3r::GUI::Camera::get_inv_zoom(), Slic3r::GUI::Camera::get_position(), Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::GUI::Camera::get_type(), Slic3r::GUI::Camera::get_viewport(), Slic3r::GUI::Camera::Perspective, and Slic3r::GUI::Camera::translate().

Referenced by Slic3r::GUI::GLCanvas3D::on_gesture(), and Slic3r::GUI::GLCanvas3D::on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_color_string()

std::array< float, 4 > Slic3r::GUI::parse_color_string ( const std::string & hex )

static

{
    std::array<float, 4> c = {1.f, 1.f, 1.f, 1.f};
    if (hex.size() >= 7 && hex[0] == '#') {
        unsigned long val = std::strtoul(hex.c_str() + 1, nullptr, 16);
        c[0] = ((val >> 16) & 0xFF) / 255.f;
        c[1] = ((val >>  8) & 0xFF) / 255.f;
        c[2] = ((val      ) & 0xFF) / 255.f;
    }
    return c;
}

Referenced by Slic3r::GUI::TextureImportDialog::add_decomposed_mixed_filament(), Slic3r::GUI::TextureImportDialog::add_virtual_mixed_filament(), Slic3r::GUI::TextureImportDialog::apply_auto_standard_mix(), and wxBEGIN_EVENT_TABLE().

Here is the caller graph for this function:

parse_lscpu_etc()

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_mm()

bool Slic3r::GUI::parse_mm ( wxString t, double & out )

static

{
    t.Replace(",", ".");
    return t.Trim(true).Trim(false).ToCDouble(&out) && out >= 0.5 && out <= 500.0;
}

Referenced by Slic3r::GUI::DesignTextDialog::height_mm().

Here is the caller graph for this function:

parse_semver_from_ini()

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("OrcaSlicer ");
    if (start == std::string::npos) {
        start = body.find("OrcaSlicer ");
        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(), and parse_semver_from_ini().

Referenced by parse_semver_from_ini().

Here is the call graph for this function:

Here is the caller graph for this function:

ParseErrorCode()

wxString Slic3r::GUI::ParseErrorCode ( int errorcde )

static

{
    auto it = error_messages.find(errorcde);
    if (it != error_messages.end()) { return _L(it->second); }
    return "";
}

References _L, and error_messages.

Referenced by Slic3r::GUI::SendToPrinterDialog::CreateMediaAbilityJob(), and Slic3r::GUI::SendToPrinterDialog::UploadFileRessultCallback().

Here is the caller graph for this function:

pick_reference_square()

int Slic3r::GUI::pick_reference_square	(	const std::vector< SketchPlane > &	squares,
		double	half,
		const Vec3d &	from,
		const Vec3d &	dir )

{
    int    best   = -1;
    double best_t = std::numeric_limits<double>::max();
    for (int i = 0; i < int(squares.size()); ++i) {
        const SketchPlane& s  = squares[i];
        const Vec3d        n  = s.x_axis.cross(s.y_axis);
        const double       dn = n.dot(dir);
        if (std::abs(dn) < 1e-12)
            continue;   // the ray runs along the square
        const double t = n.dot(s.origin - from) / dn;
        if (t <= 0. || t >= best_t)
            continue;   // behind the eye, or no nearer than one already hit
        const Vec3d d = from + dir * t - s.origin;
        if (std::abs(d.dot(s.x_axis)) <= half && std::abs(d.dot(s.y_axis)) <= half) {
            best   = i;
            best_t = t;
        }
    }
    return best;
}

References Slic3r::SketchPlane::origin, pick_reference_square(), Slic3r::SketchPlane::x_axis, and Slic3r::SketchPlane::y_axis.

Referenced by Slic3r::GUI::DesignSketchTool::hit_test_base_pick(), and pick_reference_square().

Here is the call graph for this function:

Here is the caller graph for this function:

plane_from_index()

SketchPlane Slic3r::GUI::plane_from_index ( int i )

static

{
    switch (i) {
        case 1:  return SketchPlane::XZ();
        case 2:  return SketchPlane::YZ();
        default: return SketchPlane::XY();
    }
}

References Slic3r::SketchPlane::XY(), Slic3r::SketchPlane::XZ(), and Slic3r::SketchPlane::YZ().

Referenced by Slic3r::GUI::DesignPanel::hole_plane(), is_base_plane(), Slic3r::GUI::DesignPanel::plane_from_choice(), and Slic3r::GUI::DesignPanel::thread_plane().

Here is the call graph for this function:

Here is the caller graph for this function:

planes_back_to_front()

std::vector< PlanePiece > Slic3r::GUI::planes_back_to_front	(	const std::vector< SketchPlane > &	planes,
		double	half,
		const Vec3d &	eye,
		const Vec3d &	forward,
		bool	perspective )

{
    std::vector<PlanePiece> squares;
    for (int i = 0; i < int(planes.size()); ++i) {
        const SketchPlane& p = planes[i];
        squares.push_back({ i, { p.to_world(Vec2d(-half, -half)), p.to_world(Vec2d(half, -half)),
                                 p.to_world(Vec2d(half, half)),   p.to_world(Vec2d(-half, half)) } });
    }
    std::vector<PlanePiece> out;
    paint_back_to_front(std::move(squares), 0, planes, 1e-6 * std::max(half, 1.), eye, forward, perspective, out);
    return out;
}

References planes_back_to_front(), and Slic3r::SketchPlane::to_world().

Referenced by planes_back_to_front(), and Slic3r::GUI::DesignSketchTool::render_base_pick().

Here is the call graph for this function:

Here is the caller graph for this function:

plate_toolbar_hover_color()

ImVec4 Slic3r::GUI::plate_toolbar_hover_color ( bool is_dark )

static

{
    return ImVec4(0.67f, 0.67f, 0.67f, is_dark ? .6f : 1.f);
}

References is_dark(), and plate_toolbar_hover_color().

Referenced by Slic3r::GUI::GLCanvas3D::_render_imgui_select_plate_toolbar(), Slic3r::GUI::GLCanvas3D::_render_plate_switcher(), and plate_toolbar_hover_color().

Here is the call graph for this function:

Here is the caller graph for this function:

plate_toolbar_keeps_scrollbar()

bool Slic3r::GUI::plate_toolbar_keeps_scrollbar ( bool shown, float scrollbar_size )

static

{
    const ImVec2 pos = ImGui::GetWindowPos();
    return ImGui::IsMouseHoveringRect(pos, pos + ImGui::GetWindowSize() + ImVec2(shown ? scrollbar_size : 0.f, 0.f), !shown) ||
           (ImGui::GetIO().MouseDown[0] && GImGui->ActiveId != 0 && GImGui->ActiveIdWindow == ImGui::GetCurrentWindow());
}

References plate_toolbar_keeps_scrollbar().

Referenced by Slic3r::GUI::GLCanvas3D::_render_imgui_select_plate_toolbar(), Slic3r::GUI::GLCanvas3D::_render_plate_switcher(), and plate_toolbar_keeps_scrollbar().

Here is the call graph for this function:

Here is the caller graph for this function:

plater()

Plater * Slic3r::GUI::plater ( )

static

{
    return wxGetApp().plater();
}

Referenced by Slic3r::GUI::ArrangeJob::ArrangeJob(), Slic3r::GUI::BindMachineDialog::BindMachineDialog(), Slic3r::GUI::CalibrationDialog::CalibrationDialog(), Slic3r::GUI::Cornering_Test_Dlg::Cornering_Test_Dlg(), Slic3r::GUI::DesignCanvas::DesignCanvas(), Slic3r::GUI::EditDevNameDialog::EditDevNameDialog(), Slic3r::GUI::FillBedJob::FillBedJob(), Slic3r::GUI::FlowRateCalibrationDialog::FlowRateCalibrationDialog(), Slic3r::GUI::Input_Shaping_Damp_Test_Dlg::Input_Shaping_Damp_Test_Dlg(), Slic3r::GUI::Input_Shaping_Freq_Test_Dlg::Input_Shaping_Freq_Test_Dlg(), Slic3r::GUI::MaxVolumetricSpeed_Test_Dlg::MaxVolumetricSpeed_Test_Dlg(), Slic3r::GUI::ModelMallDialog::ModelMallDialog(), Slic3r::GUI::MultiMachinePickPage::MultiMachinePickPage(), Slic3r::GUI::ObjectList::ObjectList(), Slic3r::GUI::OrientJob::OrientJob(), Slic3r::GUI::PA_Calibration_Dlg::PA_Calibration_Dlg(), Slic3r::GUI::ParamsDialog::ParamsDialog(), Slic3r::GUI::PingCodeBindDialog::PingCodeBindDialog(), Slic3r::GUI::PlaterDropTarget::PlaterDropTarget(), Slic3r::GUI::PlaterPresetComboBox::PlaterPresetComboBox(), Slic3r::GUI::PlaterWorker< WorkerSubclass >::PlaterWorker(), Slic3r::GUI::PrintJob::PrintJob(), Slic3r::GUI::ReleaseNoteDialog::ReleaseNoteDialog(), Slic3r::GUI::Retraction_Test_Dlg::Retraction_Test_Dlg(), Slic3r::GUI::RotoptimizeJob::RotoptimizeJob(), Slic3r::GUI::GLGizmoRotate3D::RotoptimzeWindow::RotoptimzeWindow(), Slic3r::GUI::SelectMachineDialog::SelectMachineDialog(), Slic3r::GUI::SendJob::SendJob(), Slic3r::GUI::SendMultiMachinePage::SendMultiMachinePage(), Slic3r::GUI::SendToPrinterDialog::SendToPrinterDialog(), Slic3r::GUI::Plater::SingleSnapshot::SingleSnapshot(), Slic3r::GUI::SLAImportDialog::SLAImportDialog(), Slic3r::GUI::SLAImportJob::SLAImportJob(), Slic3r::GUI::SuppressBackgroundProcessingUpdate::SuppressBackgroundProcessingUpdate(), Slic3r::GUI::Plater::SuppressSnapshots::SuppressSnapshots(), Slic3r::GUI::Plater::TakeSnapshot::TakeSnapshot(), Slic3r::GUI::Plater::TakeSnapshot::TakeSnapshot(), Slic3r::GUI::Temp_Calibration_Dlg::Temp_Calibration_Dlg(), Slic3r::GUI::UnBindMachineDialog::UnBindMachineDialog(), Slic3r::GUI::VFA_Test_Dlg::VFA_Test_Dlg(), Slic3r::GUI::GLCanvas3D::_is_xray_view_active(), Slic3r::GUI::GLCanvas3D::_max_bounding_box(), Slic3r::GUI::GLCanvas3D::_mouse_to_3d(), Slic3r::GUI::GLCanvas3D::_picking_pass(), Slic3r::GUI::GLCanvas3D::_render_arrange_menu(), Slic3r::GUI::GLCanvas3D::_render_frame(), Slic3r::GUI::GLCanvas3D::_render_imgui_select_plate_toolbar(), Slic3r::GUI::GLCanvas3D::_render_orient_menu(), Slic3r::GUI::GLCanvas3D::_render_plate_switcher(), Slic3r::GUI::GLCanvas3D::_render_return_toolbar(), Slic3r::GUI::GLCanvas3D::_render_wireframe_overlay(), Slic3r::GUI::GLCanvas3D::_set_warning_notification(), Slic3r::GUI::GLCanvas3D::_update_selection_from_hover(), Slic3r::GUI::GLGizmosManager::activate_gizmo(), Slic3r::GUI::Selection::add(), Slic3r::GUI::GLGizmoCut3D::add_connector(), Slic3r::GUI::Selection::add_curr_plate(), Slic3r::GUI::Sidebar::add_custom_filament(), Slic3r::GUI::ObjectList::add_layer_range_after_current(), Slic3r::GUI::ObjectTableSettings::add_missed_options(), Slic3r::GUI::Sidebar::add_mixed_filament(), Slic3r::GUI::GLGizmoSimplify::add_simplify_suggestion_notification(), Slic3r::GUI::GLGizmoTextureDisplacement::add_texture_layer(), add_volume_with_gizmo(), Slic3r::GUI::MenuFactory::append_menu_item_align_distribute(), Slic3r::GUI::MenuFactory::append_menu_item_center(), Slic3r::GUI::MenuFactory::append_menu_item_clone(), Slic3r::GUI::MenuFactory::append_menu_item_delete(), Slic3r::GUI::MenuFactory::append_menu_item_drop(), Slic3r::GUI::MenuFactory::append_menu_item_edit_svg(), Slic3r::GUI::MenuFactory::append_menu_item_edit_text(), Slic3r::GUI::MenuFactory::append_menu_item_export_drc(), Slic3r::GUI::MenuFactory::append_menu_item_export_stl(), Slic3r::GUI::MenuFactory::append_menu_item_fill_bed(), Slic3r::GUI::MenuFactory::append_menu_item_fix_through_cgal(), Slic3r::GUI::MenuFactory::append_menu_item_instance_to_object(), Slic3r::GUI::MenuFactory::append_menu_item_locked(), Slic3r::GUI::MenuFactory::append_menu_item_modify(), Slic3r::GUI::MenuFactory::append_menu_item_per_object_process(), Slic3r::GUI::MenuFactory::append_menu_item_per_object_settings(), Slic3r::GUI::MenuFactory::append_menu_item_plate_delete(), Slic3r::GUI::MenuFactory::append_menu_item_plate_name(), Slic3r::GUI::MenuFactory::append_menu_item_printable(), Slic3r::GUI::MenuFactory::append_menu_item_reload_from_disk(), Slic3r::GUI::MenuFactory::append_menu_item_replace_all_with_stl(), Slic3r::GUI::MenuFactory::append_menu_item_replace_with_stl(), Slic3r::GUI::MenuFactory::append_menu_item_scale_selection_to_fit_print_volume(), Slic3r::GUI::MenuFactory::append_menu_item_set_auto_drop(), Slic3r::GUI::MenuFactory::append_menu_item_set_printable(), Slic3r::GUI::MenuFactory::append_menu_item_set_visible(), Slic3r::GUI::MenuFactory::append_menu_item_simplify(), Slic3r::GUI::MenuFactory::append_menu_item_smooth_mesh(), Slic3r::GUI::MenuFactory::append_menu_item_transform(), Slic3r::GUI::MenuFactory::append_menu_items_flush_options(), Slic3r::GUI::MenuFactory::append_menu_items_instance_manipulation(), Slic3r::GUI::Tab::apply_preset_config_values(), Slic3r::GUI::GLGizmoTextureDisplacement::apply_projection_frame(), Slic3r::GUI::GLGizmoBrimEars::apply_radius_change(), Slic3r::GUI::GLGizmoSimplify::apply_simplify(), Slic3r::GUI::GLGizmoBrimEars::auto_generate(), Slic3r::GUI::NotificationManager::bbl_show_filament_map_invalid_notification_after_slice(), Slic3r::GUI::NotificationManager::bbl_show_filament_map_invalid_notification_before_slice(), Slic3r::GUI::NotificationManager::bbl_show_objectsinfo_notification(), Slic3r::GUI::NotificationManager::bbl_show_plugin_install_notification(), bed_stride_x(), bed_stride_y(), Slic3r::GUI::ObjectList::boolean(), Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), Slic3r::GUI::GLGizmoTextureDisplacement::build_island_move_set(), Slic3r::GUI::PublishSettingsDialog::build_option_model(), Slic3r::GUI::TabPrinter::build_unregular_pages(), Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::calib_command(), call_after_if_active(), Slic3r::GUI::ConfigManipulation::check_layer_height(), check_nozzle_diameter_and_type(), check_objects_after_cut(), Slic3r::GUI::PartPlate::check_objects_empty_and_gcode3mf(), Slic3r::GUI::Plater::check_printer_initialized(), Slic3r::GUI::ObjectList::clone(), Slic3r::GUI::GLCanvas3D::collapse_side(), Slic3r::GUI::ObjectList::copy(), Slic3r::GUI::MenuFactory::create_default_menu(), Slic3r::GUI::MenuFactory::create_filament_action_menu(), create_freq_settings_popupmenu(), anonymous_namespace{GLGizmoEmboss.cpp}::create_input(), anonymous_namespace{GLGizmoSVG.cpp}::create_input(), Slic3r::GUI::PreferencesDialog::create_item_checkbox(), Slic3r::GUI::PreferencesDialog::create_item_darkmode(), Slic3r::GUI::PreferencesDialog::create_item_language_combobox(), Slic3r::GUI::PreferencesDialog::create_items(), Slic3r::GUI::ExtruderGroup::create_nozzle_row(), Slic3r::GUI::ObjectList::create_objects_ctrl(), Slic3r::GUI::MenuFactory::create_plate_menu(), create_settings_popupmenu(), Slic3r::GUI::MenuFactory::create_sla_object_menu(), anonymous_namespace{EmbossJob.cpp}::create_volume(), Slic3r::GUI::ObjectList::cut(), Slic3r::GUI::GLGizmoMmuSegmentation::data_changed(), Slic3r::GUI::DesignSketchTool::dbp_half_extent(), Slic3r::GUI::ObjectList::del_from_cut_object(), Slic3r::GUI::ObjectList::del_info_item(), Slic3r::GUI::Sidebar::delete_mixed_filament_at(), Slic3r::GUI::GLGizmoCut3D::delete_selected_connectors(), Slic3r::GUI::GLGizmoBrimEars::delete_selected_points(), desktop_open_project_attachment(), Slic3r::GUI::Mouse3DController::disconnect_device(), Slic3r::GUI::MediaFilePanel::doAction(), Slic3r::GUI::GLGizmoEmboss::draw_delete_style_button(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), Slic3r::GUI::GLGizmoEmboss::draw_model_type(), Slic3r::GUI::GLGizmoSVG::draw_model_type(), Slic3r::GUI::GLGizmoEmboss::draw_style_rename_popup(), Slic3r::GUI::GLGizmoEmboss::draw_text_input(), Slic3r::GUI::Sidebar::edit_mixed_filament(), Slic3r::GUI::anonymous_namespace{Plater.cpp}::emboss_svg(), Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::ensure_3d_view(), anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::finalize(), Slic3r::GUI::TextureDisplacementBakeJob::finalize(), Slic3r::GUI::TextureDisplacementPrepareJob::finalize(), Slic3r::GUI::ObjectList::fix_all_through_cgal(), Slic3r::GUI::ObjectList::fix_cut_selection(), Slic3r::GUI::ObjectList::fix_through_cgal(), Slic3r::GUI::GLGizmoCut3D::flip_cut_plane(), Slic3r::GUI::SyncAmsInfoDialog::generate_override_fix_ams_list(), Slic3r::GUI::SelectMachineDialog::get_ams_mapping_result(), Slic3r::GUI::SendMultiMachinePage::get_ams_mapping_result(), Slic3r::GUI::SyncAmsInfoDialog::get_ams_mapping_result(), Slic3r::GUI::SyncAmsInfoDialog::get_is_double_extruder(), get_selection(), get_wipe_tower(), get_wipe_tower_arrangepoly(), Slic3r::GUI::GLGizmoBrimEars::gizmo_event(), Slic3r::GUI::GLGizmoPainterBase::gizmo_event(), Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::go_to_layer(), Slic3r::GUI::GLCanvas3D::handle_shortcut(), Slic3r::GUI::Sidebar::has_broken_mixed_filament(), Slic3r::GUI::Sidebar::has_broken_mixed_filament(), has_filaments(), Slic3r::GUI::DesignPanel::hydrate_from_model(), Slic3r::GUI::GCodeViewer::init(), Slic3r::GUI::Plater::priv::init_collapse_toolbar(), Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::is_fff_plater(), Slic3r::GUI::Sidebar::priv::is_fila_switch_ready(), Slic3r::GUI::Selection::is_from_fully_selected_instance(), Slic3r::GUI::Sidebar::is_new_project_in_gcode3mf(), Slic3r::GUI::ConfigManipulation::layer_height_out_of_range_dialog(), Slic3r::GUI::ObjectList::layers_editing(), Slic3r::GUI::DesignCanvas::leave_viewport(), Slic3r::GUI::ObjectList::list_manipulation(), Slic3r::GUI::GCodeViewer::load_as_gcode(), Slic3r::GUI::DesignPanel::load_default_layout(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::GLCanvas3D::load_gcode_preview(), Slic3r::GUI::ObjectList::load_generic_subobject(), Slic3r::GUI::MenuFactory::load_handy_model(), Slic3r::GUI::ObjectList::load_shape_object(), manuallySetNozzleCount(), Slic3r::GUI::GLGizmoTextureDisplacement::mark_seam_path(), Slic3r::GUI::ActionRegistry::materialize_plate_actions(), Slic3r::GUI::Tab::may_discard_current_dirty_preset(), Slic3r::GUI::ObjectList::merge(), Slic3r::GUI::GLCanvas3D::mouse_up_cleanup(), Slic3r::GUI::GLGizmoTextureDisplacement::move_texture_layer(), Slic3r::GUI::anonymous_namespace{ActionRegistry.cpp}::notify_script_outcome(), Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::object_op(), Slic3r::GUI::GLGizmoAssembly::on_get_name(), Slic3r::GUI::GLGizmoMeasure::on_get_name(), Slic3r::GUI::GLCanvas3D::on_idle(), Slic3r::GUI::GLGizmoAssembly::on_is_activable(), Slic3r::GUI::GLGizmoCut3D::on_is_activable(), Slic3r::GUI::GLGizmoMeasure::on_is_activable(), Slic3r::GUI::GLGizmoTextureDisplacement::on_island_edited(), Slic3r::GUI::GLCanvas3D::on_mouse(), Slic3r::GUI::GLCanvas3D::on_mouse_wheel(), Slic3r::GUI::SendToPrinterDialog::on_ok(), Slic3r::GUI::TabPrinter::on_preset_loaded(), Slic3r::GUI::Tab::on_presets_changed(), Slic3r::GUI::ProjectPanel::on_reload(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoSimplify::on_render_input_window(), Slic3r::GUI::GLGizmoSVG::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window(), Slic3r::GUI::AuFile::on_set_delete(), Slic3r::GUI::GLGizmoBrimEars::on_set_state(), Slic3r::GUI::GLGizmoCut3D::on_start_dragging(), Slic3r::GUI::GLGizmoBrimEars::on_stop_dragging(), Slic3r::GUI::GLGizmoCut3D::on_stop_dragging(), Slic3r::GUI::anonymous_namespace{SceneBenchmark.cpp}::SceneBenchmarkDialog::on_timer(), Slic3r::GUI::GLGizmoTextureDisplacement::on_uv_vertex_edited(), Slic3r::GUI::Tab::on_value_change(), Slic3r::GUI::TabFilament::on_value_change(), Slic3r::GUI::TabPrinter::on_value_change(), Slic3r::GUI::TabPrintPlate::on_value_change(), Slic3r::GUI::ObjectList::OnEditingDone(), Slic3r::GUI::ObjectList::OnEditingStarted(), BBLTopbar::OnOpenProject(), BBLTopbar::OnRedo(), BBLTopbar::OnSaveProject(), Slic3r::GUI::GuideFrame::OnScriptMessage(), BBLTopbar::OnUndo(), Slic3r::GUI::TroubleshootDialog::PackAll(), Slic3r::GUI::ObjectList::paste(), Slic3r::GUI::GLGizmoCut3D::perform_cut(), Slic3r::GUI::PrintJob::process(), Slic3r::GUI::SendJob::process(), Slic3r::GUI::GLGizmoCut3D::process_cut_line(), Slic3r::GUI::TroubleshootDialog::RebuildSystemProfiles(), refresh_plugin_metadata_blocking(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::GLGizmoMmuSegmentation::remap_filament_assignments(), Slic3r::GUI::ObjectList::remove(), Slic3r::GUI::Sidebar::remove_all_mixed_filaments(), Slic3r::GUI::Selection::remove_curr_plate(), Slic3r::GUI::DockPanel::remove_pane(), Slic3r::GUI::GLGizmoTextureDisplacement::remove_texture_layer(), Slic3r::GUI::PartPlate::render(), Slic3r::GUI::Selection::render(), Slic3r::GUI::TriangleSelectorPatch::render(), Slic3r::GUI::GCodeViewer::render_all_plates_stats(), Slic3r::GUI::GLGizmoCut3D::render_angle_input(), Slic3r::GUI::GLGizmoCut3D::render_connectors_input_window(), Slic3r::GUI::GLGizmoPainterBase::render_cursor_circle(), Slic3r::GUI::GLGizmoCut3D::render_cut_line(), Slic3r::GUI::GLGizmoCut3D::render_cut_mode_combo(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane_input_window(), Slic3r::GUI::GLCanvas3D::CenterOfMass::render_details(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::GLGizmoPainterBase::render_follows_cursor(), Slic3r::GUI::GLGizmoCut3D::render_groove_float_input(), Slic3r::GUI::GLGizmoCut3D::render_groove_int_input(), Slic3r::GUI::GLGizmoCut3D::render_groove_two_float_input(), Slic3r::GUI::GCodeViewer::render_legend_color_arr_recommen(), Slic3r::GUI::GLGizmoCut3D::render_line(), Slic3r::GUI::GLGizmoCut3D::render_model(), Slic3r::GUI::GLGizmoCut3D::render_move_center_input(), Slic3r::GUI::Mouse3DController::render_settings_dialog(), Slic3r::GUI::GLCanvas3D::render_thumbnail(), Slic3r::GUI::GLCanvas3D::render_thumbnail(), Slic3r::GUI::GLCanvas3D::render_thumbnail_internal(), Slic3r::GUI::SyncAmsInfoDialog::reset_and_sync_ams_list(), Slic3r::GUI::GizmoObjectManipulation::reset_scale_value(), Slic3r::GUI::Selection::rotate(), Slic3r::GUI::ConfigWizard::run(), Slic3r::GUI::GuideFrame::run(), Slic3r::GUI::SpeedDialWebDialog::run_action(), run_scene_benchmark(), Slic3r::GUI::GLGizmoTextureDisplacement::run_uv_command(), s_get_slicing_extuder_nozzles(), Slic3r::GUI::Selection::scale_and_translate(), scene_selection(), Slic3r::GUI::GLGizmoFdmSupports::select_facets_by_angle(), Slic3r::GUI::ObjectList::select_item_all_children(), Slic3r::GUI::Tab::select_preset(), Slic3r::GUI::GLGizmoTextureDisplacement::select_visible_faces(), Slic3r::GUI::GLGizmoTextureDisplacement::select_whole_model(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::Plater::priv::set_current_panel(), Slic3r::GUI::SyncAmsInfoDialog::set_default_normal(), Slic3r::GUI::GLGizmoTextureDisplacement::set_layer_texture(), Slic3r::GUI::DesignCanvas::set_view(), Slic3r::GUI::ObjectList::set_volume_type(), Slic3r::GUI::IMSlider::SetTicksValues(), setup_dialog_position(), Slic3r::GUI::GLGizmoCut3D::shift_cut(), Slic3r::GUI::MonitorPanel::Show(), Slic3r::GUI::ObjectList::show_context_menu(), Slic3r::GUI::ConfigManipulation::show_spiral_mode_settings_dialog(), Slic3r::GUI::ObjectList::simplify(), Slic3r::GUI::ObjectList::smooth_mesh(), Slic3r::GUI::GLGizmoTextureDisplacement::smooth_model(), Slic3r::GUI::ObjectList::split_instances(), Slic3r::GUI::Downloader::start_download(), Slic3r::GUI::anonymous_namespace{SceneBenchmark.cpp}::SceneBenchmarkDialog::start_slicing(), Slic3r::GUI::GLGizmoTextureDisplacement::subdivide_model(), Slic3r::GUI::DesignCanvas::swap_camera(), Slic3r::GUI::Sidebar::sync_ams_list(), Slic3r::GUI::Tab::sync_excluder(), Slic3r::GUI::DesignPanel::sync_recipe_to_model(), take_snapshot(), Slic3r::GUI::GLCanvas3D::toggle_model_objects_visibility(), Slic3r::GUI::GLGizmoTextureDisplacement::toggle_seam_at(), Slic3r::GUI::GLCanvas3D::toggle_selected_volume_visibility(), Slic3r::GUI::GLCanvas3D::toggle_sla_auxiliaries_visibility(), Slic3r::GUI::Selection::translate(), Slic3r::GUI::FilamentGroupPopup::tryPopup(), Slic3r::GUI::TabPrint::update(), Slic3r::GUI::TabSLAPrint::update(), Slic3r::GUI::ObjectList::update_after_undo_redo(), Slic3r::GUI::PresetComboBox::update_ams_color(), Slic3r::GUI::GLGizmoCut3D::update_bb(), Slic3r::GUI::AuFolderPanel::update_cover(), Slic3r::GUI::Sidebar::priv::update_extruder_separator_icon(), Slic3r::GUI::GLGizmoMmuSegmentation::update_from_model_object(), Slic3r::GUI::ProjectDirtyStateManager::update_from_undo_redo_stack(), Slic3r::GUI::DesignerPanel::update_info(), Slic3r::GUI::ObjectList::update_info_items(), Slic3r::GUI::Preview::update_layers_slider(), Slic3r::GUI::Sidebar::update_mixed_filament_list(), Slic3r::GUI::Sidebar::update_presets(), Slic3r::GUI::ObjectList::update_selections_on_canvas(), Slic3r::GUI::GLGizmoTextureDisplacement::update_uv_editor(), anonymous_namespace{EmbossJob.cpp}::update_volume(), Slic3r::GUI::Emboss::UpdateJob::update_volume(), updateNozzleCountDisplay(), Slic3r::GUI::PreferencesDialog::UpdateSidebarLayout(), Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::view_command(), and Slic3r::GUI::GLCanvas3D::zoom_to_plate().

play_dual_extruder_print_tpu_video()

bool Slic3r::GUI::play_dual_extruder_print_tpu_video

(

)

{
    const wxString video_url = "https://e.bambulab.com/t?c=fwWqpBg37Liel92N";
    if (wxLaunchDefaultBrowser(video_url)){
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("Print Tpu Video is being played using the system's default browser.");
        return true;
    }
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format("launch system's default browser failed");
    return false;
}

play_dual_extruder_slice_video()

bool Slic3r::GUI::play_dual_extruder_slice_video

(

)

{
    if (wxLaunchDefaultBrowser("https://e.bambulab.com/t?c=HDB24RlwSmt77YFH")) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("Video is being played using the system's default browser.");
        return true;
    }
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format("launch system's default browser failed");
    return false;
}

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

Here is the caller graph for this function:

plugin_pane_name()

std::string Slic3r::GUI::plugin_pane_name	(	const std::string &	plugin_key,
		const std::string &	title )

{
    std::string name = "plugin:" + plugin_key + ":" + title;
    std::replace_if(name.begin(), name.end(), [](char c) { return c == '|' || c == ';' || c == '=' || c == '\\'; }, '_');
    return name;
}

Referenced by Slic3r::anonymous_namespace{PluginHostUi.cpp}::ui_create_dock_panel().

Here is the caller graph for this function:

plugin_sort_key_from_string()

PluginSortKey Slic3r::GUI::plugin_sort_key_from_string ( const std::string & sort_key, PluginSortKey fallback )

inline

    {
        if (sort_key == "status")
            return PluginSortKey::Status;
        if (sort_key == "name")
            return PluginSortKey::Name;
        if (sort_key == "source")
            return PluginSortKey::Source;
        if (sort_key == "version")
            return PluginSortKey::Version;
        if (sort_key == "none")
            return PluginSortKey::None;
        return fallback;
    }

References Name, None, Source, Status, and Version.

Referenced by Slic3r::GUI::PluginsDialog::set_plugin_sort().

Here is the caller graph for this function:

plugin_sort_order_from_string()

PluginSortOrder Slic3r::GUI::plugin_sort_order_from_string ( const std::string & sort_order, PluginSortOrder fallback )

inline

    {
        if (sort_order == "asc")
            return PluginSortOrder::Asc;
        if (sort_order == "desc")
            return PluginSortOrder::Desc;
        return fallback;
    }

References Asc, and Desc.

Referenced by Slic3r::GUI::PluginsDialog::set_plugin_sort().

Here is the caller graph for this function:

point_in_poly()

bool Slic3r::GUI::point_in_poly ( const Vec2d & q, const std::vector< Vec2d > & poly )

static

{
    if (poly.size() < 3) return false;
    bool in = false;
    for (size_t i = 0, j = poly.size() - 1; i < poly.size(); j = i++) {
        const Vec2d& a = poly[i];
        const Vec2d& b = poly[j];
        if (((a.y() > q.y()) != (b.y() > q.y())) &&
            (q.x() < (b.x() - a.x()) * (q.y() - a.y()) / (b.y() - a.y()) + a.x()))
            in = !in;
    }
    return in;
}

References point_in_poly().

Referenced by Slic3r::GUI::DesignSketchTool::hit_display_sketch(), and point_in_poly().

Here is the call graph for this function:

Here is the caller graph for this function:

point_segment_dist()

double Slic3r::GUI::point_segment_dist ( const Vec2d & p, const Vec2d & a, const Vec2d & b )

static

{
    const Vec2d ab = b - a;
    const double len2 = ab.squaredNorm();
    if (len2 < 1e-12)
        return (p - a).norm();
    double t = (p - a).dot(ab) / len2;
    t = std::max(0.0, std::min(1.0, t));
    return (p - (a + t * ab)).norm();
}

References Slic3r::dot(), and point_segment_dist().

Referenced by entity_pick_dist(), Slic3r::GUI::DesignSketchTool::hit_test_op_arrow(), Slic3r::GUI::DesignSketchTool::on_mouse_impl(), and point_segment_dist().

Here is the call graph for this function:

Here is the caller graph for this function:

precise_seam_group_changed()

bool Slic3r::GUI::precise_seam_group_changed ( ModelVolumeType old_type, ModelVolumeType new_type )

static

{
    const bool old_is_ps = is_precise_seam(old_type);
    const bool new_is_ps = is_precise_seam(new_type);
    if (old_is_ps != new_is_ps)
        return true;                 // non-PS ↔ PS transition
    if (!old_is_ps)
        return false;                // both non-PS — regular enum ordering is enough
    return is_precise_seam_strong(old_type) != is_precise_seam_strong(new_type);
}

References Slic3r::is_precise_seam(), and Slic3r::is_precise_seam_strong().

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

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_decompose_mixed_result()

bool Slic3r::GUI::prepare_decompose_mixed_result	(	const ColorDecomposeResult &	result,
		size_t	source_config_idx,
		size_t	source_physical_idx,
		const std::vector< std::string > &	physical_colors,
		const std::vector< std::string > &	physical_types,
		const std::vector< size_t > &	physical_config_indices,
		MixedFilamentResult &	out_result,
		std::vector< DecomposeMissingComponent > &	missing )

{
    out_result = {};
    missing.clear();
    if (result.components.size() < 2) {
        return false;
    }
 
    const bool standard_mode = result.mode == DecomposeMode::CMYW || result.mode == DecomposeMode::RYBW;
    std::string basic_type;
    std::string preset_name;
    if (standard_mode) {
        basic_type = decompose_basic_type_from_source(source_config_idx, source_physical_idx, physical_types);
        preset_name = find_decompose_standard_preset_name(source_config_idx, basic_type);
    }
 
    for (size_t i = 0; i < result.components.size(); ++i) {
        const DecomposeComponent& comp = result.components[i];
        out_result.ratios.push_back(comp.ratio);
        if (!standard_mode) {
            if (comp.filament_index <= 0) {
                return false;
            }
            const size_t physical_idx = static_cast<size_t>(comp.filament_index - 1);
            if (physical_idx >= physical_config_indices.size()) {
                return false;
            }
            out_result.components.push_back(static_cast<unsigned int>(physical_config_indices[physical_idx] + 1));
            continue;
        }
 
        if (comp.base_color == DecomposeBaseColor::None) {
            return false;
        }
        DecomposeOfficialComponent official_component =
            lookup_decompose_official_component(basic_type, comp.base_color, comp.colour);
        int existing_idx = find_existing_decompose_component(official_component, physical_colors,
                                                             physical_config_indices, source_config_idx);
        if (existing_idx > 0) {
            out_result.components.push_back(static_cast<unsigned int>(existing_idx));
            continue;
        }
 
        DecomposeMissingComponent missing_comp;
        missing_comp.component_idx = out_result.components.size();
        missing_comp.official_component = official_component;
        missing_comp.preset_name = preset_name;
        // TRN %1% is a color name such as "Cyan", %2% is a filament type such as "PLA Basic"
        missing_comp.display_name = format_wxstr(_L_CONTEXT("%1% %2%", "Color and filament type"),
                                                 decompose_base_color_display(comp.base_color), wxString::FromUTF8(basic_type));
        missing.push_back(std::move(missing_comp));
        out_result.components.push_back(0);
    }
 
    const bool ok = out_result.components.size() == out_result.ratios.size() && out_result.components.size() >= 2;
    return ok;
}

References _L_CONTEXT, Slic3r::GUI::DecomposeComponent::base_color, Slic3r::GUI::DecomposeComponent::colour, Slic3r::GUI::DecomposeMissingComponent::component_idx, Slic3r::GUI::ColorDecomposeResult::components, Slic3r::GUI::MixedFilamentResult::components, decompose_base_color_display(), decompose_basic_type_from_source(), Slic3r::GUI::DecomposeMissingComponent::display_name, Slic3r::GUI::DecomposeComponent::filament_index, find_decompose_standard_preset_name(), find_existing_decompose_component(), format_wxstr(), lookup_decompose_official_component(), Slic3r::GUI::ColorDecomposeResult::mode, None, Slic3r::GUI::DecomposeMissingComponent::official_component, Slic3r::GUI::DecomposeMissingComponent::preset_name, Slic3r::GUI::DecomposeComponent::ratio, and Slic3r::GUI::MixedFilamentResult::ratios.

Referenced by Slic3r::GUI::Sidebar::decompose_filament_color().

Here is the call graph for this function:

Here is the caller graph for this function:

preset_type_name()

const char * Slic3r::GUI::preset_type_name ( Preset::Type type )

static

{
    switch (type) {
    case Preset::TYPE_PRINT:    return "process";
    case Preset::TYPE_FILAMENT: return "filament";
    case Preset::TYPE_PRINTER:  return "printer";
    default:                    return "preset";
    }
}

References preset_type_name(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, and Slic3r::Preset::TYPE_PRINTER.

Referenced by Slic3r::GUI::Tab::apply_preset_config_values(), preset_type_name(), and show_substitutions_info().

Here is the call graph for this function:

Here is the caller graph for this function:

preset_type_options()

const std::vector< std::string > & Slic3r::GUI::preset_type_options ( Preset::Type type )

static

{
    static const std::vector<std::string> none;
    switch (type) {
    case Preset::TYPE_PRINT:    return Preset::print_options();
    case Preset::TYPE_FILAMENT: return Preset::filament_options();
    case Preset::TYPE_PRINTER:  return Preset::printer_options();
    default:                    return none;
    }
}

References Slic3r::Preset::filament_options(), none, preset_type_options(), Slic3r::Preset::print_options(), Slic3r::Preset::printer_options(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, and Slic3r::Preset::TYPE_PRINTER.

Referenced by Slic3r::GUI::Tab::apply_preset_config_values(), and preset_type_options().

Here is the call graph for this function:

Here is the caller graph for this function:

print_ams_mapping_result()

void Slic3r::GUI::print_ams_mapping_result

(

std::vector< FilamentInfo > &

result

)

{
    if (result.empty()) {
        BOOST_LOG_TRIVIAL(info) << "print_ams_mapping_result: empty";
    }
 
    char buffer[256];
    for (int i = 0; i < result.size(); i++) {
        ::sprintf(buffer, "print_ams_mapping: F(%02d) -> A(%02d)", result[i].id+1, result[i].tray_id+1);
        BOOST_LOG_TRIVIAL(info) << std::string(buffer);
    }
}

Referenced by Slic3r::GUI::SelectMachineDialog::do_ams_mapping(), and Slic3r::GUI::SyncAmsInfoDialog::do_ams_mapping().

Here is the caller graph for this function:

printer_config()

DynamicPrintConfig & Slic3r::GUI::printer_config ( )

static

{
    return wxGetApp().preset_bundle->printers.get_edited_preset().config;
}

Referenced by Slic3r::GUI::PlateSettingsDialog::PlateSettingsDialog(), Slic3r::GUI::Plater::_calib_pa_pattern(), Slic3r::GUI::Plater::_calib_pa_tower(), Slic3r::GUI::Plater::_calib_temp_belt_sectioned(), Slic3r::GUI::TabFilament::add_filament_overrides_page(), adjust_settings_for_flowrate_calib(), Slic3r::GUI::ExportConfigsDialog::archive_preset_bundle_to_file(), belt_calib_rotation_params(), Slic3r::GUI::Plater::Calib_Cornering(), Slic3r::GUI::CalibUtils::calib_flowrate(), Slic3r::GUI::Plater::calib_flowrate(), Slic3r::GUI::CalibUtils::calib_generic_auto_pa_cali(), Slic3r::GUI::CalibUtils::calib_generic_PA(), Slic3r::GUI::Plater::calib_input_shaping_damp(), Slic3r::GUI::Plater::calib_input_shaping_freq(), Slic3r::GUI::CalibUtils::calib_max_vol_speed(), Slic3r::GUI::Plater::calib_max_vol_speed(), Slic3r::GUI::Plater::calib_pa(), Slic3r::GUI::CalibUtils::calib_pa_pattern(), Slic3r::GUI::CalibUtils::calib_retraction(), Slic3r::GUI::Plater::calib_retraction(), Slic3r::GUI::Plater::calib_temp(), Slic3r::GUI::CalibUtils::calib_temptue(), Slic3r::GUI::CalibUtils::calib_VFA(), Slic3r::GUI::Plater::calib_VFA(), ensure_belt_purge_tower(), Slic3r::GUI::Plater::export_gcode(), generate_max_speed_parameter_value(), Slic3r::GUI::anonymous_namespace{calib_dlg.cpp}::get_shaper_type_values(), has_junction_deviation(), Slic3r::GUI::ConfigManipulation::layer_height_limits(), Slic3r::GUI::Plater::normalize_bed_types(), Slic3r::GUI::VFA_Test_Dlg::on_start(), Slic3r::GUI::TabFilament::on_value_change(), Slic3r::GUI::ExportPresetBundleDialog::OnExportData(), Slic3r::GUI::ObjectList::split(), Slic3r::GUI::TabPrint::toggle_options(), and update_speed_parameter().

Here is the caller graph for this function:

printer_has_multi_nozzle_extruder()

bool Slic3r::GUI::printer_has_multi_nozzle_extruder ( )

static

{
    auto *max_nozzle_counts_opt = wxGetApp().preset_bundle->printers.get_edited_preset().config.option<ConfigOptionIntsNullable>("extruder_max_nozzle_count");
    // Skip nil entries: a nullable-int nil is INT_MAX (> 1) and would otherwise falsely pass the gate.
    return max_nozzle_counts_opt &&
           std::any_of(max_nozzle_counts_opt->values.begin(), max_nozzle_counts_opt->values.end(),
                       [](int v) { return v > 1 && v != ConfigOptionIntsNullable::nil_value(); });
}

Referenced by Slic3r::GUI::FilamentMapManualPanel::FilamentMapManualPanel(), Slic3r::GUI::FilamentMapManualPanel::OnTimer(), and Slic3r::GUI::FilamentMapManualPanel::UpdateNozzleCountDisplay().

Here is the caller graph for this function:

printer_technology() [1/2]

PrinterTechnology Slic3r::GUI::printer_technology ( )

static

{
    return wxGetApp().preset_bundle->printers.get_selected_preset().printer_technology();
}

Referenced by Slic3r::GUI::ObjectList::add_category_to_settings_from_selection(), Slic3r::GUI::ObjectList::add_layer_root_item(), Slic3r::GUI::ObjectTableSettings::add_missed_options(), Slic3r::GUI::GUI_App::apply_keeped_preset_modifications(), Slic3r::GUI::ObjectList::can_merge_to_multipart_object(), Slic3r::GUI::GUI_App::check_and_keep_current_preset_changes(), Slic3r::GUI::Tab::compatible_widget_create(), create_freq_settings_popupmenu(), Slic3r::GUI::ObjectList::delete_from_model_and_list(), Slic3r::GUI::GLGizmoEmboss::draw_model_type(), Slic3r::GUI::GLGizmoSVG::draw_model_type(), Slic3r::GUI::SettingsFactory::get_options(), Slic3r::GUI::GUI_App::get_selected_presets(), Slic3r::GUI::GUI_App::has_current_preset_changes(), Slic3r::GUI::GUI_App::has_unsaved_preset_changes(), Slic3r::GUI::MainFrame::load_config(), Slic3r::GUI::Tab::load_current_preset(), Slic3r::GUI::GUI_App::load_current_presets(), Slic3r::GUI::ObjectList::part_selection_changed(), Slic3r::GUI::ObjectList::paste_layers_into_list(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::UnsavedChangesDialog::save(), Slic3r::GUI::Tab::select_preset(), Slic3r::GUI::ObjectList::show_context_menu(), Slic3r::GUI::UnsavedChangesDialog::update(), Slic3r::GUI::ObjectSettings::update_config_values(), Slic3r::GUI::ObjectTableSettings::update_config_values(), Slic3r::GUI::ObjectList::update_info_items(), Slic3r::GUI::ObjectList::update_object_list_by_printer_technology(), Slic3r::GUI::ObjectList::update_objects_list_filament_column(), Slic3r::GUI::GUI_App::update_saved_preset_from_current_preset(), Slic3r::GUI::ObjectTableSettings::update_settings_list(), and Slic3r::GUI::UnsavedChangesDialog::update_tree().

Here is the caller graph for this function:

printer_technology() [2/2]

PrinterTechnology Slic3r::GUI::printer_technology ( )

static

{
    return wxGetApp().preset_bundle->printers.get_selected_preset().printer_technology();
}

process_key_down()

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().

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()

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:

project_page_strings()

json Slic3r::GUI::project_page_strings ( )

static

{
    return {
        {"no_model_info", _u8L("No model information")},
        {"edit_project_info", _u8L("Edit Project Info")},
        {"model_information", _u8L("Model Information")},
        {"accessories", _u8L("Accessories")},
        {"profile_information", _u8L("Profile Information")},
        {"model_name", _u8L("Model name")},
        {"created_by", _u8L("Created by")},
        {"remixed_by", _u8L("Remixed by")},
        {"shared_by", _u8L("Shared by")},
        {"model_description", _u8L("Model description")},
        {"bom", _u8L("BOM")},
        {"assembly_guide", _u8L("Assembly Guide")},
        {"other", _u8L("Other")},
        {"profile_name", _u8L("Profile name")},
        {"profile_author", _u8L("Profile Author")},
        {"profile_description", _u8L("Profile description")},
    };
}

References _u8L.

Referenced by Slic3r::GUI::ProjectPanel::create_browser().

Here is the caller graph for this function:

pt_linear_len()

double Slic3r::GUI::pt_linear_len ( double spacing, int count )

static

{
    return std::max(spacing * double(std::max(1, count) - 1), spacing);
}

References count, and pt_linear_len().

Referenced by Slic3r::GUI::DesignSketchTool::hit_test_pattern_handle(), pt_linear_len(), and Slic3r::GUI::DesignSketchTool::render_pattern_gizmo().

Here is the call graph for this function:

Here is the caller graph for this function:

pure_color_for_base()

wxColour Slic3r::GUI::pure_color_for_base ( DecomposeBaseColor base )

static

{
    switch (base) {
    case DecomposeBaseColor::Cyan:    return CMYW_CYAN;
    case DecomposeBaseColor::Magenta: return CMYW_MAGENTA;
    case DecomposeBaseColor::Yellow:  return CMYW_YELLOW;
    case DecomposeBaseColor::White:   return CMYW_WHITE;
    case DecomposeBaseColor::Red:     return RYBW_RED;
    case DecomposeBaseColor::Blue:    return RYBW_BLUE;
    default:                          return *wxBLACK;
    }
}

References Blue, CMYW_CYAN(), CMYW_MAGENTA(), CMYW_WHITE(), CMYW_YELLOW(), Cyan, Magenta, Red, RYBW_BLUE(), RYBW_RED(), White, and Yellow.

Referenced by Slic3r::GUI::ColorDecomposeDialog::try_build_single_base_result().

Here is the call graph for this function:

Here is the caller graph for this function:

push_plate_toolbar_scrollbar_style()

void Slic3r::GUI::push_plate_toolbar_scrollbar_style ( bool is_dark, float scrollbar_size )

static

{
    const ImVec4 grab(0.77f, 0.77f, 0.77f, is_dark ? .6f : 1.f);
    // A background with opacity over the window's would make a second color.
    ImGui::PushStyleColor(ImGuiCol_ScrollbarBg, ImVec4(0.f, 0.f, 0.f, 0.f));
    ImGui::PushStyleColor(ImGuiCol_ScrollbarGrab, grab);
    ImGui::PushStyleColor(ImGuiCol_ScrollbarGrabHovered, grab);
    ImGui::PushStyleColor(ImGuiCol_ScrollbarGrabActive, grab);
    ImGui::PushStyleVar(ImGuiStyleVar_ScrollbarSize, scrollbar_size);
}

References is_dark(), and push_plate_toolbar_scrollbar_style().

Referenced by Slic3r::GUI::GLCanvas3D::_render_imgui_select_plate_toolbar(), Slic3r::GUI::GLCanvas3D::_render_plate_switcher(), and push_plate_toolbar_scrollbar_style().

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_shared<LambdaJob>(std::move(fn), std::move(finishfn));
    return w.push(std::move(j));
}

References queue_job().

Referenced by anonymous_namespace{GLGizmoEmboss.cpp}::draw_font_preview(), Slic3r::GUI::Emboss::StyleManager::init_style_images(), queue_job(), queue_job(), Slic3r::GUI::GLGizmoTextureDisplacement::queue_preview_job(), queue_texture_displacement_bake(), queue_texture_displacement_debug(), queue_texture_displacement_prepare(), replace_job(), anonymous_namespace{EmbossJob.cpp}::start_create_object_job(), anonymous_namespace{EmbossJob.cpp}::start_create_volume_job(), and Slic3r::GUI::Emboss::start_update_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

queue_job() [3/3]

bool Slic3r::GUI::queue_job ( Worker & w, std::shared_ptr< Job > j )

inline

{
    return w.push(std::move(j));
}

References Slic3r::GUI::Worker::push().

Here is the call graph for this function:

queue_texture_displacement_bake()

void Slic3r::GUI::queue_texture_displacement_bake	(	std::vector< TextureDisplacementBakeVolume >	volumes,
		const TextureColorSettings &	color,
		std::function< void()>	on_finished,
		bool	take_snapshot )

{
    TextureDisplacementBakeInput input;
    input.volumes       = std::move(volumes);
    input.color         = color;
    input.take_snapshot = take_snapshot;
 
    auto &worker = wxGetApp().plater()->get_ui_job_worker();
    queue_job(worker, std::make_unique<TextureDisplacementBakeJob>(std::move(input), std::move(on_finished)));
}

References Slic3r::GUI::TextureDisplacementBakeInput::color, queue_job(), queue_texture_displacement_bake(), take_snapshot(), Slic3r::GUI::TextureDisplacementBakeInput::take_snapshot, and Slic3r::GUI::TextureDisplacementBakeInput::volumes.

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::bake(), and queue_texture_displacement_bake().

Here is the call graph for this function:

Here is the caller graph for this function:

queue_texture_displacement_debug()

void Slic3r::GUI::queue_texture_displacement_debug	(	const ModelVolume &	volume,
		const TextureColorSettings &	color,
		const TextureDisplacementPrepareParams &	prepare_params,
		const Transform3d &	prepare_texture_frame,
		float	resting_drop,
		bool	run_prepare,
		bool	check_topology,
		std::function< void(std::vector< BakeStageSnapshot >)>	on_finished )

{
    TextureDisplacementDebugInput input;
    input.volume_id       = volume.id();
    input.base_mesh       = volume.mesh().its;
    input.layers          = volume.texture_displacement_layers;
    input.options         = volume.texture_displacement_options;
    input.prepare_params  = prepare_params;
    input.run_prepare     = run_prepare;
    input.check_topology  = check_topology;
    input.color           = color;
    input.volume_to_world = texture_displacement_volume_to_world(volume);
    input.prepare_texture_frame = prepare_texture_frame;
    input.resting_drop          = resting_drop;
    if (volume.has_texture_uv())
        input.model_uv = volume.texture_uv;
    for (int i = 0; i < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++i)
        input.facets_data[size_t(i)] = volume.texture_displacement_facet(i).get_data();
 
    auto &worker = wxGetApp().plater()->get_ui_job_worker();
    queue_job(worker, std::make_unique<TextureDisplacementDebugJob>(std::move(input), std::move(on_finished)));
}

References Slic3r::GUI::TextureDisplacementDebugInput::base_mesh, Slic3r::GUI::TextureDisplacementDebugInput::check_topology, Slic3r::GUI::TextureDisplacementDebugInput::color, Slic3r::GUI::TextureDisplacementDebugInput::facets_data, Slic3r::FacetsAnnotation::get_data(), Slic3r::ModelVolume::has_texture_uv(), Slic3r::ObjectBase::id(), Slic3r::TriangleMesh::its, Slic3r::GUI::TextureDisplacementDebugInput::layers, Slic3r::ModelVolume::mesh(), Slic3r::GUI::TextureDisplacementDebugInput::model_uv, Slic3r::GUI::TextureDisplacementDebugInput::options, Slic3r::GUI::TextureDisplacementDebugInput::prepare_params, Slic3r::GUI::TextureDisplacementDebugInput::prepare_texture_frame, queue_job(), Slic3r::GUI::TextureDisplacementDebugInput::resting_drop, Slic3r::GUI::TextureDisplacementDebugInput::run_prepare, Slic3r::ModelVolume::texture_displacement_facet(), Slic3r::ModelVolume::texture_displacement_layers, Slic3r::TEXTURE_DISPLACEMENT_MAX_LAYERS, Slic3r::ModelVolume::texture_displacement_options, Slic3r::texture_displacement_volume_to_world(), Slic3r::ModelVolume::texture_uv, Slic3r::GUI::TextureDisplacementDebugInput::volume_id, and Slic3r::GUI::TextureDisplacementDebugInput::volume_to_world.

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::run_stage_debug().

Here is the call graph for this function:

Here is the caller graph for this function:

queue_texture_displacement_prepare()

void Slic3r::GUI::queue_texture_displacement_prepare	(	TextureDisplacementPrepareInput &&	input,
		std::function< void(TextureDisplacementPrepareOutcome)>	on_finished )

{
    auto &worker = wxGetApp().plater()->get_ui_job_worker();
    queue_job(worker, std::make_unique<TextureDisplacementPrepareJob>(std::move(input), std::move(on_finished)));
}

References queue_job(), and queue_texture_displacement_prepare().

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::queue_prepare(), and queue_texture_displacement_prepare().

Here is the call graph for this function:

Here is the caller graph for this function:

ray_axis_proj()

double Slic3r::GUI::ray_axis_proj ( const Linef3 & ray, const Vec3d & anchor, const Vec3d & dir )

static

{
    const Vec3d ro = ray.a, rd = ray.vector();
    const Vec3d e = dir;
    const Vec3d w0 = anchor - ro;
    const double a = e.dot(e), b = e.dot(rd), c = rd.dot(rd), dd = e.dot(w0), ee = rd.dot(w0);
    const double denom = a * c - b * b;
    // Relative near-parallel guard: when the camera ray is ~along the axis (e.g. the depth axis in
    // top view) denom collapses; a tiny absolute floor lets a huge, unstable projection through.
    if (std::abs(denom) < 1e-4 * std::max(a * c, 1e-12)) return std::nan("");
    return (b * ee - c * dd) / denom;
}

References Slic3r::Linef3::a, ray_axis_proj(), and Slic3r::Linef3::vector().

Referenced by Slic3r::GUI::DesignSketchTool::drag_move_arrow(), Slic3r::GUI::DesignSketchTool::grab_move_arrow(), Slic3r::GUI::DesignSketchTool::hole_axis_proj(), and ray_axis_proj().

Here is the call graph for this function:

Here is the caller 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 anonymous_namespace{SurfaceDrag.cpp}::dragging(), and anonymous_namespace{EmbossJob.cpp}::start_create_volume_on_surface_job().

Here is the call graph for this function:

Here is the caller graph for this function:

ray_segment_dist3()

double Slic3r::GUI::ray_segment_dist3 ( const Vec3d & ro, const Vec3d & rd, const Vec3d & a, const Vec3d & b )

static

{
    const Vec3d d1 = rd, d2 = b - a, r = ro - a;
    const double A = d1.dot(d1), B = d1.dot(d2), C = d2.dot(d2), D = d1.dot(r), E = d2.dot(r);
    const double denom = A * C - B * B;
    double s = (std::abs(denom) > 1e-12) ? (A * E - B * D) / denom : 0.0;  // param on segment
    s = std::max(0.0, std::min(1.0, s));
    double tt = (B * s - D) / std::max(A, 1e-12);                          // param on ray
    tt = std::max(0.0, tt);                                                // ray is forward-only
    const Vec3d pr = ro + tt * d1, ps = a + s * d2;
    return (pr - ps).norm();
}

References Slic3r::E, and ray_segment_dist3().

Referenced by Slic3r::GUI::DesignSketchTool::hit_test_cut_arrow(), Slic3r::GUI::DesignSketchTool::hit_test_extrude_arrow(), Slic3r::GUI::DesignSketchTool::hit_test_fillet_arrow(), Slic3r::GUI::DesignSketchTool::hit_test_hole_handle(), Slic3r::GUI::DesignSketchTool::hit_test_move_arc(), Slic3r::GUI::DesignSketchTool::hit_test_move_arrow(), Slic3r::GUI::DesignSketchTool::hit_test_pattern_handle(), Slic3r::GUI::DesignSketchTool::hit_test_shell_arrow(), Slic3r::GUI::DesignSketchTool::hit_test_thread_handle(), and ray_segment_dist3().

Here is the call graph for this function:

Here is the caller graph for this function:

ray_triangle()

bool Slic3r::GUI::ray_triangle ( const Vec3d & ro, const Vec3d & rd, const Vec3d & v0, const Vec3d & v1, const Vec3d & v2, double & t )

static

{
    const Vec3d e1 = v1 - v0, e2 = v2 - v0;
    const Vec3d p = rd.cross(e2);
    const double det = e1.dot(p);
    if (std::abs(det) < 1e-12) return false;          // parallel
    const double inv = 1.0 / det;
    const Vec3d s = ro - v0;
    const double u = s.dot(p) * inv;
    if (u < -1e-9 || u > 1.0 + 1e-9) return false;
    const Vec3d q = s.cross(e1);
    const double v = rd.dot(q) * inv;
    if (v < -1e-9 || u + v > 1.0 + 1e-9) return false;
    t = e2.dot(q) * inv;
    return t > 1e-9;
}

References ray_triangle().

Referenced by ray_triangle(), and Slic3r::GUI::DesignSketchTool::resolve_solid_pick().

Here is the call graph for this function:

Here is the caller graph for this function:

read_binary_stl()

void Slic3r::GUI::read_binary_stl	(	const std::string &	filename,
		std::string &	model_id,
		std::string &	code )

                                                                                      {
    std::ifstream file( encode_path(filename.c_str()), std::ios::binary);
    if (!file) {
        return;
    }
 
    try {
        // Read the first 80 bytes
        char data[80];
        file.read(data, 80);
        if (!file) {
            file.close();
            return;
        }
 
        if (data[0] == '\0' || data[0] == ' ') {
            file.close();
            return;
        }
 
        char magic[2] = { data[0], data[1] };
        if (magic[0] != 'M' || magic[1] != 'W') {
            file.close();
            return;
        }
 
        if (data[2] != ' ') {
            file.close();
            return;
        }
 
        char protocol_version[3] = { data[3], data[4], data[5] };
 
        //version
        if (protocol_version[0] != '1' || protocol_version[1] != '.' || protocol_version[2] != '0') {
            file.close();
            return;
        }
 
        std::vector<char*> tokens;
        std::istringstream iss(data);
        std::string token;
        while (std::getline(iss, token, ' ')) {
            char* tokenPtr = new char[token.length() + 1];
            std::strcpy(tokenPtr, token.c_str());
            tokens.push_back(tokenPtr);
        }
 
        //model id
        if (tokens.size() < 4) {
            file.close();
            return;
        }
 
        model_id = tokens[2];
        code = tokens[3];
        file.close();
    }
    catch (...) {
    }
    return;
}

References Slic3r::encode_path().

Referenced by Slic3r::GUI::Plater::priv::load_files().

Here is the call graph for this function:

Here is the caller graph for this function:

read_json_file()

char * Slic3r::GUI::read_json_file ( const std::string & preset_path )

static

{
    FILE *json_file = boost::nowide::fopen(boost::filesystem::path(preset_path).make_preferred().string().c_str(), "rb");
    if (json_file == NULL) {
        BOOST_LOG_TRIVIAL(info) << "Failed to open JSON file: " << preset_path;
        return NULL;
    }
    fseek(json_file, 0, SEEK_END);     // seek to end
    long file_size = ftell(json_file); // get file size
    fseek(json_file, 0, SEEK_SET);     // seek to start
 
    char * json_contents = (char *) malloc(file_size);
    if (json_contents == NULL) {
        BOOST_LOG_TRIVIAL(info) << "Failed to allocate memory for JSON file ";
        fclose(json_file);
        return NULL;
    }
 
    const size_t read_bytes = fread(json_contents, 1, file_size, json_file);
    if (read_bytes != static_cast<size_t>(file_size))
        BOOST_LOG_TRIVIAL(error) << "Read " << read_bytes << " of " << file_size << " bytes from the JSON file";
    fclose(json_file);
 
    return json_contents;
}

read_model_from_file()

void Slic3r::GUI::read_model_from_file ( const std::string & input_file, Model & model )

static

{
    LoadStrategy              strategy = LoadStrategy::LoadModel;
    ConfigSubstitutionContext config_substitutions{ForwardCompatibilitySubstitutionRule::Enable};
    int                       plate_to_slice = 0;
 
    bool                  is_bbl_3mf;
    Semver                file_version;
    DynamicPrintConfig    config;
    PlateDataPtrs         plate_data_src;
    std::vector<Preset *> project_presets;
 
    model = Model::read_from_file(input_file, &config, &config_substitutions, strategy, &plate_data_src, &project_presets,
        &is_bbl_3mf, &file_version, nullptr, nullptr, nullptr, plate_to_slice);
 
    model.add_default_instances();
 
    const std::string extension      = fs::path(input_file).extension().string();
    const bool        is_project_file = extension == ".3mf" || extension == ".3MF" || extension == ".amf" || extension == ".AMF";
    for (auto object : model.objects) {
        if (!is_project_file)
            object->center_around_origin(false);
        object->ensure_on_bed(is_project_file);
    }
}

References Slic3r::Model::add_default_instances(), Slic3r::Enable, Slic3r::LoadModel, Slic3r::Model::objects, and Slic3r::Model::read_from_file().

Referenced by Slic3r::GUI::CalibUtils::calib_flowrate(), Slic3r::GUI::CalibUtils::calib_generic_auto_pa_cali(), Slic3r::GUI::CalibUtils::calib_generic_PA(), Slic3r::GUI::CalibUtils::calib_max_vol_speed(), Slic3r::GUI::CalibUtils::calib_retraction(), Slic3r::GUI::CalibUtils::calib_temptue(), and Slic3r::GUI::CalibUtils::calib_VFA().

Here is the call graph for this function:

Here is the caller graph for this function:

recompute_mixed_slot_colors()

void Slic3r::GUI::recompute_mixed_slot_colors	(	std::vector< wxColour > &	colors,
		const Slic3r::DynamicPrintConfig &	cfg )

{
    const auto* is_mixed_opt = cfg.option<ConfigOptionBools>("filament_is_mixed");
    const auto* comp_opt     = cfg.option<ConfigOptionStrings>("filament_mixed_components");
    const auto* ratio_opt    = cfg.option<ConfigOptionStrings>("filament_mixed_sublayer_ratios");
    const auto* grad_opt     = cfg.option<ConfigOptionBools>("filament_mixed_gradient");
    if (!is_mixed_opt || !comp_opt) return;
 
    const size_t n = is_mixed_opt->values.size();
    if (colors.size() < n) colors.resize(n);
 
    const auto* colour_opt = cfg.option<ConfigOptionStrings>("filament_colour");
    const auto  kFallback  = wxColour(128, 128, 128, 255);
 
    for (size_t i = 0; i < n; ++i) {
        if (!is_mixed_opt->values[i]) continue;
 
        if (i >= comp_opt->values.size()) { colors[i] = kFallback; continue; }
        auto comp_ids = Slic3r::parse_mixed_components(comp_opt->values[i]);
        if (comp_ids.empty()) { colors[i] = kFallback; continue; }
 
        bool is_gradient = grad_opt && i < grad_opt->values.size() && grad_opt->values[i];
        std::vector<unsigned int> use_ids = comp_ids;
        std::vector<int>          weights;
 
        if (is_gradient && comp_ids.size() >= 2) {
            use_ids = { comp_ids.front(), comp_ids.back() };
            weights = { 5000, 5000 };
        } else {
            auto ratios_d = Slic3r::parse_mixed_ratios(
                (ratio_opt && i < ratio_opt->values.size()) ? ratio_opt->values[i] : std::string{},
                comp_ids.size());
            weights.reserve(comp_ids.size());
            for (double r : ratios_d)
                weights.push_back(static_cast<int>(std::lround(r * 10000.0)));
        }
 
        std::vector<std::string> hex_colors;
        hex_colors.reserve(use_ids.size());
        bool any_invalid = false;
        for (unsigned int id : use_ids) {
            if (id == 0 || id > colors.size()) { any_invalid = true; break; }
            wxColour c = colors[id - 1];
            if (c.IsOk() && (c.Red() > 0 || c.Green() > 0 || c.Blue() > 0)) {
                hex_colors.push_back(to_hex(c));
            } else if (colour_opt && (id - 1) < colour_opt->values.size()) {
                hex_colors.push_back(colour_opt->values[id - 1]);
            } else {
                any_invalid = true; break;
            }
        }
        if (any_invalid) { colors[i] = kFallback; continue; }
 
        std::string hex = Slic3r::blend_color_multi(hex_colors, weights);
        wxColour blended(hex);
        if (!blended.IsOk()) blended = kFallback;
        colors[i] = wxColour(blended.Red(), blended.Green(), blended.Blue(), 255);
    }
}

References Slic3r::blend_color_multi(), Slic3r::ConfigBase::option(), Slic3r::parse_mixed_components(), Slic3r::parse_mixed_ratios(), Slic3r::ConfigOptionVector< T >::size(), to_hex(), Slic3r::ConfigOptionVector< T >::values, and Slic3r::ConfigOptionVector< unsigned char >::values.

Referenced by Slic3r::GUI::SelectMachineDialog::change_default_normal(), Slic3r::GUI::SyncAmsInfoDialog::change_default_normal(), Slic3r::GUI::SelectMachineDialog::clone_thumbnail_data(), Slic3r::GUI::SyncAmsInfoDialog::clone_thumbnail_data(), and Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::mixed_filament_blend_color().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_label_box()

std::array< Vec3d, 4 > Slic3r::GUI::reference_label_box	(	const SketchPlane &	square,
		double	half,
		const std::string &	text )

{
    const double th = label_height(half);
    Vec2d        size;
    text_strokes(text, th, size);
    const Vec2d c = label_centre(half, size);
    const Vec2d r = 0.5 * size + Vec2d::Constant(0.15 * th);   // a margin round the strokes, to aim at
    return { square.to_world(c + Vec2d(-r.x(), -r.y())), square.to_world(c + Vec2d(r.x(), -r.y())),
             square.to_world(c + Vec2d(r.x(), r.y())), square.to_world(c + Vec2d(-r.x(), r.y())) };
}

References reference_label_box(), and Slic3r::SketchPlane::to_world().

Referenced by Slic3r::GUI::DesignSketchTool::hit_test_base_pick(), and reference_label_box().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_square()

SketchPlane Slic3r::GUI::reference_square	(	const SketchPlane &	plane,
		int	base,
		double	half )

{
    SketchPlane square = plane;
    if (is_base_plane(base)) {
        const Vec3d o = reference_octant();
        square.origin += (reference_square_gap(half) + half) * (plane.x_axis.dot(o) * plane.x_axis + plane.y_axis.dot(o) * plane.y_axis);
    }
    return square;
}

References is_base_plane(), Slic3r::SketchPlane::origin, reference_square(), reference_square_gap(), Slic3r::SketchPlane::x_axis, and Slic3r::SketchPlane::y_axis.

Referenced by Slic3r::GUI::DesignSketchTool::dbp_squares(), and reference_square().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_square_gap()

double Slic3r::GUI::reference_square_gap ( double half )

inline

{ return 0.25 * half; }

Referenced by reference_square(), and Slic3r::GUI::DesignSketchTool::render_reference_axes().

Here is the caller graph for this function:

refresh_agora_url()

void Slic3r::GUI::refresh_agora_url ( char const * device, char const * dev_ver, char const * channel, void * context, void(* callback )(void *context, char const *url) )

extern

{
    std::string device2 =device;
    device2 += "|";
    device2 += dev_ver;
    device2 += "|\"agora\"|";
    device2 += channel;
    wxGetApp().getAgent()->get_camera_url(device2, [context, callback](std::string url) {
        callback(context, url.c_str());
    }, wxGetApp().get_printer_cloud_provider());
}

Referenced by Slic3r::GUI::MediaPlayCtrl::Play().

Here is the caller graph for this function:

refresh_plugin_metadata_blocking()

void Slic3r::GUI::refresh_plugin_metadata_blocking

(

bool

fetch_cloud

)

{
    PluginManager& manager = PluginManager::instance();
 
    std::vector<std::string> not_found, unauthorized;
    const std::vector<PluginDescriptor> current_cloud_metadata = fetch_cloud ? std::vector<PluginDescriptor>{} :
                                                                             current_cloud_metadata_snapshot();
 
    manager.rescan_plugins();
 
    if (!fetch_cloud) {
        manager.update_cloud_metadata(current_cloud_metadata);
        return;
    }
 
    manager.fetch_plugins_from_cloud(&not_found, &unauthorized);
 
    wxGetApp().CallAfter([not_found = std::move(not_found), unauthorized = std::move(unauthorized)]() {
        if (wxGetApp().is_closing())
            return;
        Plater* plater = wxGetApp().plater();
        if (plater == nullptr)
            return;
 
        for (const auto& uuid : not_found)
            plater->get_notification_manager()->push_notification(NotificationType::CustomNotification,
                                                                  NotificationManager::NotificationLevel::RegularNotificationLevel,
                                                                  format(_L("Plugin %s is no longer available."), uuid));
        for (const auto& uuid : unauthorized)
            plater->get_notification_manager()->push_notification(NotificationType::CustomNotification,
                                                                  NotificationManager::NotificationLevel::RegularNotificationLevel,
                                                                  format(_L("Plugin %s access is unauthorized."), uuid));
    });
}

References _L, CustomNotification, Slic3r::PluginManager::fetch_plugins_from_cloud(), format(), Slic3r::PluginManager::instance(), plater(), Slic3r::GUI::NotificationManager::RegularNotificationLevel, Slic3r::PluginManager::rescan_plugins(), and Slic3r::PluginManager::update_cloud_metadata().

Referenced by install_local_plugin_package(), Slic3r::GUI::PluginsDialog::refresh_plugin_metadata_async(), and Slic3r::GUI::GUI_App::refresh_plugins().

Here is the call graph for this function:

Here is the caller graph for this function:

register_mac_deep_link_handler()

void Slic3r::GUI::register_mac_deep_link_handler

(

)

{
    static OrcaDeepLinkHandler *handler = nil;
    if (handler == nil)
        handler = [[OrcaDeepLinkHandler alloc] init];
 
    [[NSAppleEventManager sharedAppleEventManager]
        setEventHandler:handler
            andSelector:@selector(handleGetURLEvent:withReplyEvent:)
          forEventClass:kInternetEventClass
             andEventID:kAEGetURL];
}

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

Here is the caller graph for this function:

register_model_for_picking()

void Slic3r::GUI::register_model_for_picking ( GLCanvas3D & canvas, PickingModel & model, int id )

static

{
  if (model.mesh_raycaster == nullptr)
    return;
 
    canvas.add_raycaster_for_picking(SceneRaycaster::EType::Bed, id, *model.mesh_raycaster, Transform3d::Identity());
}

References Slic3r::GUI::GLCanvas3D::add_raycaster_for_picking(), Slic3r::GUI::SceneRaycaster::Bed, and Slic3r::GUI::PickingModel::mesh_raycaster.

Referenced by Slic3r::GUI::PartPlate::generate_plate_name_texture(), Slic3r::GUI::PartPlate::refresh_imex_icon(), and Slic3r::GUI::PartPlate::register_raycasters_for_picking().

Here is the call graph for this function:

Here is the caller graph for this function:

release_window_pools()

void Slic3r::GUI::release_window_pools

(

)

{
    for (auto p : spools2) {
        delete p;
    }
    spools2.clear();
}

References spools2.

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

Here is the caller graph for this function:

remove_empty_plugin_values()

void Slic3r::GUI::remove_empty_plugin_values ( std::vector< std::string > & values )

static

{
    for (auto it = values.begin(); it != values.end();) {
        if (it->empty())
            it = values.erase(it);
        else
            ++it;
    }
}

Referenced by Slic3r::GUI::PluginField::rebuild_ui().

Here is the caller graph for this function:

remove_special_key()

std::string Slic3r::GUI::remove_special_key ( const std::string & str )

static

{
    std::string res_str;
    for (char c : str) {
        if (special_key.find(c) == special_key.end()) {
            res_str.push_back(c);
        }
    }
    return res_str;
}

References special_key.

Referenced by Slic3r::GUI::CreateFilamentPresetDialog::create_dialog_buttons(), Slic3r::GUI::CreatePrinterPresetDialog::get_printer_model(), Slic3r::GUI::CreatePrinterPresetDialog::get_printer_vendor(), and Slic3r::GUI::CreatePrinterPresetDialog::validate_input_valid().

Here is the caller graph for this function:

remove_user_texture()

bool Slic3r::GUI::remove_user_texture	(	const std::string &	path,
		std::string &	error )

{
    if (!in_user_texture_dir(path)) {
        error = _u8L("Only your own imported textures can be removed.");
        return false;
    }
    boost::system::error_code ec;
    boost::filesystem::remove(boost::filesystem::path(path), ec);
    if (ec) {
        BOOST_LOG_TRIVIAL(error) << "Could not delete texture " << path << ": " << ec.message();
        error = _u8L("Could not delete the texture file.");
        return false;
    }
 
    const std::string        name  = boost::filesystem::path(path).filename().string();
    std::vector<std::string> names = recent_texture_names();
    names.erase(std::remove(names.begin(), names.end(), name), names.end());
    store_recent_texture_names(std::move(names));
    texture_library(true); // drop it from the list
    return true;
}

References _u8L, and texture_library().

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::render_texture_library_popup().

Here is the call graph for this function:

Here is the caller graph for this function:

render_extruders_combo()

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 Slic3r::GUI::GLGizmoMmuSegmentation::EXTRUDERS_LIMIT, style, and Slic3r::GUI::ImGuiWrapper::to_ImU32().

Here is the call graph for this function:

render_ribbons()

void Slic3r::GUI::render_ribbons ( GLModel & model, GLModel::Geometry && g, const ColorRGBA & colour )

static

{
    if (g.is_empty())
        return;
    glsafe(::glEnable(GL_DEPTH_TEST));
    glsafe(::glDepthFunc(GL_LEQUAL));
    glsafe(::glDepthMask(GL_FALSE));
    glsafe(::glEnable(GL_BLEND));
    glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
    model.reset();
    model.init_from(std::move(g));
    model.set_color(colour);
    model.render();
    glsafe(::glDepthMask(GL_TRUE));
    glsafe(::glDepthFunc(GL_LESS));
    glsafe(::glDisable(GL_BLEND));
    glsafe(::glDisable(GL_DEPTH_TEST));
}

References GL_BLEND, GL_DEPTH_TEST, GL_FALSE, GL_LEQUAL, GL_LESS, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, GL_TRUE, glBlendFunc, glDepthFunc, glDepthMask, glDisable, glEnable, glsafe, Slic3r::GUI::GLModel::init_from(), Slic3r::GUI::GLModel::render(), render_ribbons(), Slic3r::GUI::GLModel::reset(), and Slic3r::GUI::GLModel::set_color().

Referenced by Slic3r::GUI::DesignSketchTool::render_body_edges(), Slic3r::GUI::DesignSketchTool::render_face_outline(), and render_ribbons().

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::fill_bed_with_copies(), Slic3r::GUI::Plater::fill_bed_with_instances(), Slic3r::GUI::Plater::import_sl1_archive(), Slic3r::GUI::BindMachineDialog::on_bind_printer(), Slic3r::GUI::SendToPrinterDialog::on_ok(), Slic3r::GUI::SelectMachineDialog::on_send_print(), Slic3r::GUI::InputIpAddressDialog::on_send_retry(), Slic3r::GUI::Plater::optimize_rotation(), Slic3r::GUI::Plater::orient(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::DownloadProgressDialog::Show(), and Slic3r::GUI::OAuthDialog::Show().

Here is the call graph for this function:

Here is the caller graph for this function:

requires_mode_switch()

bool Slic3r::GUI::requires_mode_switch ( ConfigOptionMode setting_mode, ConfigOptionMode current_mode )

inline

{
    return setting_mode > current_mode;
}

Referenced by Slic3r::GUI::SpeedDialWebDialog::run_action().

Here is the caller graph for this function:

rescale_children()

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:

resolve_default_virtual_filament_preset_name()

std::string Slic3r::GUI::resolve_default_virtual_filament_preset_name ( )

static

{
    auto* preset_bundle = wxGetApp().preset_bundle;
    if (!preset_bundle)
        return {};
 
    auto valid_preset_name = [preset_bundle](const std::string& name) -> bool {
        return !name.empty() && preset_bundle->filaments.find_preset(name, false) != nullptr;
    };
 
    const auto* default_profiles = preset_bundle->printers.get_selected_preset()
        .config.option<ConfigOptionStrings>("default_filament_profile");
    if (default_profiles) {
        for (const std::string& name : default_profiles->values) {
            if (starts_with_preset_name(name, DEFAULT_VIRTUAL_FILAMENT_NAME) && valid_preset_name(name))
                return name;
        }
    }
 
    for (const Preset& preset : preset_bundle->filaments.get_presets()) {
        if (preset.is_system && preset.is_visible && preset.is_compatible &&
            starts_with_preset_name(preset.name, DEFAULT_VIRTUAL_FILAMENT_NAME)) {
            return preset.name;
        }
    }
 
    for (const Preset& preset : preset_bundle->filaments.get_presets()) {
        if (preset.is_visible && preset.is_compatible &&
            starts_with_preset_name(preset.name, DEFAULT_VIRTUAL_FILAMENT_NAME)) {
            return preset.name;
        }
    }
 
    std::string selected = preset_bundle->filaments.get_selected_preset_name();
    return valid_preset_name(selected) ? selected : std::string();
}

References DEFAULT_VIRTUAL_FILAMENT_NAME, and starts_with_preset_name().

Referenced by wxBEGIN_EVENT_TABLE().

Here is the call graph for this function:

Here is the caller graph for this function:

resolve_plugin_status()

PluginStatus Slic3r::GUI::resolve_plugin_status ( bool loading, bool has_error, bool is_loaded )

inline

        {
            if (loading)
                return PluginStatus::Loading;
            if (has_error)
                return is_loaded ? PluginStatus::RuntimeError : PluginStatus::Error;
            if (is_loaded)
                return PluginStatus::Activated;
            return PluginStatus::Inactive;
        }

References Activated, Error, Inactive, Loading, and RuntimeError.

Referenced by Slic3r::GUI::anonymous_namespace{PluginsDialog.cpp}::build_plugin_dialog_item().

Here is the caller graph for this function:

rgb_to_hex()

wxString Slic3r::GUI::rgb_to_hex ( const std::array< std::size_t, 3 > & c )

static

{
    return wxString::Format("#%02X%02X%02X",
        (unsigned)c[0], (unsigned)c[1], (unsigned)c[2]);
}

Referenced by Slic3r::GUI::TextureImportDialog::do_auto_match(), and Slic3r::GUI::TextureImportDialog::rebuild_mapping_rows().

Here is the caller graph for this function:

rib_frame()

bool Slic3r::GUI::rib_frame ( const Vec2d & p0, const Vec2d & p1, double thickness, Vec2d & d, Vec2d & perp, Vec2d & mid, double & half )

static

{
    const Vec2d seg = p1 - p0;
    const double len = seg.norm();
    if (len < 1e-9) return false;
    d    = seg / len;
    perp = Vec2d(-d.y(), d.x());
    mid  = 0.5 * (p0 + p1);
    half = thickness * 0.5;
    return true;
}

References Slic3r::perp(), and rib_frame().

Referenced by Slic3r::GUI::DesignSketchTool::drag_rib_handle(), Slic3r::GUI::DesignSketchTool::hit_test_rib_handle(), Slic3r::GUI::DesignSketchTool::render_rib_gizmo(), and rib_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

run_off_ui_thread()

void Slic3r::GUI::run_off_ui_thread ( wxWindow * parent, const wxString & message, const std::function< void()> & work )

static

{
    struct Busy { Busy() { ++s_doc_worker_busy; } ~Busy() { --s_doc_worker_busy; } } busy;
    std::atomic<bool> done{false};
    std::thread worker([&work, &done]() {
        work();
        done.store(true, std::memory_order_release);
    });
 
    // Input stays blocked for the whole operation: the worker owns the document, so nothing
    // in the UI may mutate it meanwhile. The dialog only appears if the work is actually slow —
    // a fillet on a small body finishes in milliseconds and must not flash a dialog.
    wxWindowDisabler disabler;
    std::unique_ptr<wxProgressDialog> dlg;
    int elapsed_ms = 0;
    while (!done.load(std::memory_order_acquire)) {
        if (dlg == nullptr && elapsed_ms >= 300)
            dlg = std::make_unique<wxProgressDialog>(_L("Design"), message, 100, parent,
                                                     wxPD_AUTO_HIDE | wxPD_SMOOTH);
        if (dlg != nullptr)
            dlg->Pulse();
        wxYield();               // keep the window painting instead of going unresponsive
        wxMilliSleep(30);
        elapsed_ms += 30;
    }
    worker.join();
}

References _L, Slic3r::Busy, s_doc_worker_busy, and wxWindowDisabler.

Referenced by Slic3r::GUI::DesignPanel::feature_faces(), Slic3r::GUI::DesignPanel::on_import_step(), and Slic3r::GUI::DesignPanel::recompute_guarded().

Here is the caller graph for this function:

run_scene_benchmark()

void Slic3r::GUI::run_scene_benchmark

(

)

{
    Plater* plater = wxGetApp().plater();
    if (plater == nullptr || !wxGetApp().is_editor())
        return;
    if (s_benchmark != nullptr) {
        if (s_benchmark->is_running()) {
            s_benchmark->Raise();
            return;
        }
        s_benchmark->Close();
    }
 
    MessageDialog confirm(wxGetApp().mainframe,
                          _L("The benchmark replaces the current project with the OrcaSliced Combo and slices it. It turns the camera "
                             "around the model in Prepare and in Preview, then moves the layer slider through the sliced layers, timing "
                             "every frame, and shows the results.") + "\n\n" +
                          _L("It uses the current graphics settings and usually takes less than a minute. The main window stays "
                             "locked until it finishes."),
                          _L("Benchmark 3D Scene"), wxICON_INFORMATION | wxOK | wxCANCEL);
    confirm.SetButtonLabel(wxID_OK, _L("Start"), true);
    if (confirm.ShowModal() != wxID_OK || plater->new_project() == wxID_CANCEL)
        return;
 
    const std::vector<MenuFactory::HandyModel>& models = MenuFactory::handy_models();
    const auto combo = std::find_if(models.begin(), models.end(),
                                    [](const MenuFactory::HandyModel& model) { return std::strcmp(model.key, "orcasliced_combo") == 0; });
    MenuFactory::load_handy_model(size_t(combo - models.begin()));
    (new SceneBenchmarkDialog())->Show();
}

References _L, Slic3r::GUI::MenuFactory::handy_models(), Slic3r::GUI::anonymous_namespace{SceneBenchmark.cpp}::SceneBenchmarkDialog::is_running(), Slic3r::GUI::MenuFactory::load_handy_model(), plater(), Slic3r::GUI::anonymous_namespace{SceneBenchmark.cpp}::s_benchmark, Slic3r::GUI::MsgDialog::SetButtonLabel(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), Slic3r::GUI::PreferencesDialog::create_items(), and Slic3r::GUI::MainFrame::generate_help_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

run_wizard()

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:

rv_yaxis()

Vec3d Slic3r::GUI::rv_yaxis ( const Vec3d & axis, const Vec3d & ref, bool flip )

static

{
    Vec3d y = axis.cross(ref);
    if (y.norm() < 1e-9) return ref;            // degenerate; never used (ref ⟂ axis by construction)
    y.normalize();
    return flip ? -y : y;
}

References rv_yaxis().

Referenced by Slic3r::GUI::DesignSketchTool::drag_revolve_arc(), Slic3r::GUI::DesignSketchTool::hit_test_revolve_handle(), Slic3r::GUI::DesignSketchTool::render_revolve_gizmo(), and rv_yaxis().

Here is the call graph for this function:

Here is the caller graph for this function:

RYBW_BLUE()

const wxColour Slic3r::GUI::RYBW_BLUE ( 0 , 0 , 255  )

static

Referenced by Slic3r::GUI::ColorDecomposeDialog::compute_decomposition(), pure_color_for_base(), and standard_base_color_for().

Here is the caller graph for this function:

RYBW_RED()

const wxColour Slic3r::GUI::RYBW_RED ( 255 , 0 , 0  )

static

Referenced by pure_color_for_base(), and standard_base_color_for().

Here is the caller graph for this function:

RYBW_WHITE()

const wxColour Slic3r::GUI::RYBW_WHITE ( 255 , 255 , 255  )

static

Referenced by standard_base_color_for().

Here is the caller graph for this function:

RYBW_YELLOW()

const wxColour Slic3r::GUI::RYBW_YELLOW ( 255 , 255 , 0  )

static

Referenced by Slic3r::GUI::ColorDecomposeDialog::compute_decomposition(), and standard_base_color_for().

Here is the caller graph for this function:

s_button_style_gray()

StateColor Slic3r::GUI::s_button_style_gray ( )

static

{
    return StateColor(std::pair<wxColour, int>(wxColour(206, 206, 206), StateColor::Pressed),
                      std::pair<wxColour, int>(*wxWHITE, StateColor::Focused),
                      std::pair<wxColour, int>(wxColour(238, 238, 238), StateColor::Hovered),
                      std::pair<wxColour, int>(*wxWHITE, StateColor::Normal));
}

References StateColor::Focused, StateColor::Hovered, StateColor::Normal, and StateColor::Pressed.

Referenced by Slic3r::GUI::wgtDeviceNozzleRackArea::CreateGui().

Here is the caller graph for this function:

s_create_title()

wxPanel * Slic3r::GUI::s_create_title ( wxWindow * parent, const wxString & text )

static

{
    wxPanel *panel = new wxPanel(parent, wxID_ANY);
    panel->SetBackgroundColour(*wxWHITE);
 
    auto title  = new Label(panel, text);
    title->SetFont(::Label::Body_13);
    title->SetBackgroundColour(*wxWHITE);
    title->SetForegroundColour(0x909090);
 
    auto split_line = new wxPanel(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
    split_line->SetBackgroundColour(wxColour(0xEE, 0xEE, 0xEE));
    split_line->SetMinSize(wxSize(-1, 1));
    split_line->SetMaxSize(wxSize(-1, 1));
 
    wxBoxSizer *sizer = new wxBoxSizer(wxHORIZONTAL);
    sizer->Add(0, 0, 0, wxEXPAND, 0);
    sizer->Add(title, 0, wxALIGN_CENTER, 0);
    sizer->Add(split_line, 1, wxALIGN_CENTER_VERTICAL | wxEXPAND, 0);
    panel->SetSizer(sizer);
    panel->Layout();
    return panel;
}

References Label::Body_13.

Referenced by Slic3r::GUI::wgtDeviceNozzleRackSelect::CreateGui().

Here is the caller graph for this function:

s_enable_item_if_match()

void Slic3r::GUI::s_enable_item_if_match ( wgtDeviceNozzleRackNozzleItem * item, const DevNozzle & nozzle_info, const DevNozzle & selected_nozzle )

static

{
    if (item) {
        if (nozzle_info.GetLogicExtruderId() != selected_nozzle.GetLogicExtruderId()) {
            item->SetDisable(true);
            return;
        }
 
        if (!nozzle_info.IsEmpty() && !nozzle_info.IsAbnormal() && !nozzle_info.IsUnknown() &&
            nozzle_info.GetNozzleType() == selected_nozzle.GetNozzleType() &&
            nozzle_info.GetNozzleDiameter() == selected_nozzle.GetNozzleDiameter() &&
            nozzle_info.GetNozzleFlowType() == selected_nozzle.GetNozzleFlowType()) {
            item->SetDisable(false);
        } else {
            item->SetDisable(true);
        }
    }
}

References Slic3r::DevNozzle::GetLogicExtruderId(), Slic3r::DevNozzle::GetNozzleDiameter(), Slic3r::DevNozzle::GetNozzleFlowType(), Slic3r::DevNozzle::GetNozzleType(), Slic3r::DevNozzle::IsAbnormal(), Slic3r::DevNozzle::IsEmpty(), Slic3r::DevNozzle::IsUnknown(), and Slic3r::GUI::wgtDeviceNozzleRackNozzleItem::SetDisable().

Referenced by Slic3r::GUI::wgtDeviceNozzleRackSelect::UpdatSelectedNozzle().

Here is the call graph for this function:

Here is the caller graph for this function:

s_get_mapped_nozzle_str_line_count()

int Slic3r::GUI::s_get_mapped_nozzle_str_line_count ( const wxString & text )

static

{
    if (text.empty()) {
        return 0;
    }
 
    return std::max(1, static_cast<int>(wxSplit(s_wrap_mapped_nozzle_str(text), '\n', '\0').size()));
}

References s_wrap_mapped_nozzle_str().

Referenced by Slic3r::GUI::MaterialItem::messure_size().

Here is the call graph for this function:

Here is the caller graph for this function:

s_get_slicing_extuder_nozzles()

std::unordered_multimap< int, NozzleDef > Slic3r::GUI::s_get_slicing_extuder_nozzles ( )

static

{
    std::unordered_multimap<int, NozzleDef> used_extuder_nozzles;
 
    PresetBundle* preset_bundle = wxGetApp().preset_bundle;
    if (!preset_bundle) {
        return used_extuder_nozzles;
    }
 
    PartPlate* cur_plate = wxGetApp().plater()->get_partplate_list().get_curr_plate();
    if (!cur_plate) {
        return used_extuder_nozzles;
    }
 
    auto opt_nozzle_diameters = preset_bundle->printers.get_edited_preset().config.option<ConfigOptionFloats>("nozzle_diameter");
    if (!opt_nozzle_diameters) {
        return used_extuder_nozzles;
    }
 
    auto nozzle_volume_type_opt = dynamic_cast<const ConfigOptionEnumsGeneric*>(preset_bundle->project_config.option("nozzle_volume_type"));
    if (!nozzle_volume_type_opt) {
        return used_extuder_nozzles;
    }
 
    try {
        auto nozzle_group_res = DevUtilBackend::GetNozzleGroupResult(wxGetApp().plater());
        if (nozzle_group_res && nozzle_group_res->is_support_dynamic_nozzle_map() && nozzle_volume_type_opt->values.size() == 2) {
            const auto& used_nozzles = nozzle_group_res->get_used_nozzles_in_extruder();
            for (const auto& used_nozzle : used_nozzles) {
                NozzleDef nozzle_data;
                nozzle_data.nozzle_diameter = std::stof(used_nozzle.diameter);
                nozzle_data.nozzle_flow_type = DevNozzle::ToNozzleFlowType(used_nozzle.volume_type);
                if (used_nozzle.extruder_id == 0) {
                    used_extuder_nozzles.insert({ DEPUTY_EXTRUDER_ID, nozzle_data });
                } else if (used_nozzle.extruder_id == 1) {
                    used_extuder_nozzles.insert({ MAIN_EXTRUDER_ID, nozzle_data });
                }
            };
 
            return used_extuder_nozzles;
        }
 
        const auto& used_filament_idxs = cur_plate->get_used_filaments(); /*the index is started from 1*/
        for (int used_filament_idx : used_filament_idxs) {
            int physical_idx = cur_plate->get_physical_extruder_by_filament_id(preset_bundle->full_config(), used_filament_idx);
            int logic_extruder_idx = cur_plate->get_logical_extruder_by_filament_id(preset_bundle->full_config(), used_filament_idx);
            if (physical_idx < 0 || logic_extruder_idx < 0) {
                assert(0);
                continue;
            }
 
            NozzleDef nozzle_data;
            nozzle_data.nozzle_diameter = float(opt_nozzle_diameters->get_at(logic_extruder_idx));
            nozzle_data.nozzle_flow_type = NozzleFlowType::S_FLOW;// default value
 
            auto volume_type = (NozzleVolumeType)nozzle_volume_type_opt->get_at(logic_extruder_idx);
            if (volume_type == NozzleVolumeType::nvtHybrid) {
                if (used_extuder_nozzles.find(physical_idx) != used_extuder_nozzles.end()) {
                    continue;// already collected
                }
 
                // A hybrid extruder prints with a mix of nozzle flows: collect the flow of each
                // physically used nozzle instead of forcing a single one.
                if (nozzle_group_res) {
                    for (const auto& nozzle_info : nozzle_group_res->get_used_nozzles_in_extruder(logic_extruder_idx)) {
                        nozzle_data.nozzle_flow_type = DevNozzle::ToNozzleFlowType(nozzle_info.volume_type);
                        used_extuder_nozzles.insert({ physical_idx, nozzle_data });
                    }
                } else {
                    // Orca: a by-object plate with several objects produces no plate-level nozzle
                    // grouping, so the used flows are unknown; skip the check for this extruder
                    // rather than blocking the print.
                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": no nozzle group result, nozzle check skipped for extruder " << logic_extruder_idx;
                }
 
                continue;
            }
 
            nozzle_data.nozzle_flow_type = DevNozzle::ToNozzleFlowType(volume_type);
            used_extuder_nozzles.insert({ physical_idx, nozzle_data });
        };
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "exception: " << e.what();
    }
 
    return used_extuder_nozzles;
}

References Slic3r::Preset::config, DEPUTY_EXTRUDER_ID, Slic3r::PresetBundle::full_config(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::GUI::PartPlate::get_logical_extruder_by_filament_id(), Slic3r::GUI::PartPlate::get_physical_extruder_by_filament_id(), Slic3r::GUI::PartPlate::get_used_filaments(), Slic3r::DevUtilBackend::GetNozzleGroupResult(), MAIN_EXTRUDER_ID, NozzleDef::nozzle_diameter, NozzleDef::nozzle_flow_type, Slic3r::nvtHybrid, Slic3r::ConfigBase::option(), plater(), Slic3r::PresetBundle::printers, Slic3r::PresetBundle::project_config, Slic3r::S_FLOW, and Slic3r::DevNozzle::ToNozzleFlowType().

Referenced by Slic3r::GUI::SelectMachineDialog::CheckErrorExtruderNozzleWithSlicing().

Here is the call graph for this function:

Here is the caller graph for this function:

s_set_bg_style()

void Slic3r::GUI::s_set_bg_style ( StaticBox * box, ScalableButton * btn, Label * label_row, Label * label_row_status, const wxColour & clr )

static

{
    box->SetBorderColor(clr);
    box->SetBackgroundColor(clr);
    btn->SetBackgroundColour(clr);
    label_row->SetBackgroundColour(clr);
    label_row_status->SetBackgroundColour(clr);
}

References StaticBox::SetBackgroundColor(), and StaticBox::SetBorderColor().

Referenced by Slic3r::GUI::wgtDeviceNozzleRackPos::CreateGui().

Here is the call graph for this function:

Here is the caller graph for this function:

s_show_label() [1/2]

void Slic3r::GUI::s_show_label ( Label * label, const wxString & text )

static

{
    label->SetLabel(text);
    label->Show();
}

References Label::SetLabel().

Referenced by Slic3r::GUI::wgtDeviceNozzleRackPos::UpdateRackPos().

Here is the call graph for this function:

Here is the caller graph for this function:

s_show_label() [2/2]

void Slic3r::GUI::s_show_label ( Label * label, const wxString & text, const wxColour & text_color )

static

{
    label->SetLabel(text);
    label->SetForegroundColour(StateColor::darkModeColorFor(text_color));
    label->Show();
}

References StateColor::darkModeColorFor(), Label::SetLabel(), and text_color().

Here is the call graph for this function:

s_update_nozzle_info()

void Slic3r::GUI::s_update_nozzle_info ( wgtDeviceNozzleRackNozzleItem * item, std::shared_ptr< DevNozzleRack > rack, const DevNozzle & nozzle_info )

static

{
    item->UpdateInfo(rack, nozzle_info.IsOnRack());
    if (nozzle_info.IsUnknown()) {
        if (item->GetToolTipText() != _L("Nozzle information needs to be read")) {
            item->SetToolTip(_L("Nozzle information needs to be read"));
        }
    } else {
        item->SetToolTip(wxEmptyString);
    }
}

References _L, Slic3r::DevNozzle::IsOnRack(), Slic3r::DevNozzle::IsUnknown(), and Slic3r::GUI::wgtDeviceNozzleRackNozzleItem::UpdateInfo().

Referenced by Slic3r::GUI::wgtDeviceNozzleRackSelect::UpdateNozzleInfos().

Here is the call graph for this function:

Here is the caller graph for this function:

s_update_title()

void Slic3r::GUI::s_update_title ( const std::shared_ptr< DevNozzleRack > rack, wgtDeviceNozzleRackTitle * title_label )

static

{
    wxString title = _L("Induction Hotend Rack");
    if (rack && (rack->GetReadingCount() > 0))
    {
        // TRN %d/%d is the hotend being read and the number of hotends to read.
        title = wxString::Format(_L("Induction Hotend Rack: Reading %d/%d"), rack->GetReadingIdx(), rack->GetReadingCount());
    }
 
    title_label->SetLabel(title);
}

References _L, and Slic3r::GUI::wgtDeviceNozzleRackTitle::SetLabel().

Here is the call graph for this function:

s_wrap_mapped_nozzle_str()

wxString Slic3r::GUI::s_wrap_mapped_nozzle_str ( const wxString & text )

static

{
    if (text.length() <= MAPPED_NOZZLE_STR_MAX_CHARS_PER_LINE) {
        return text;
    }
 
    wxArrayString parts = wxSplit(text, ',');
    wxString wrapped;
    std::vector<wxString> buffers;
    for (auto& part : parts) {
        if (!part.empty()) {
            buffers.push_back(part.Trim(false).Trim(true));
        }
 
        if (buffers.size() > 2) {
            if (!wrapped.empty()) {
                wrapped += "\n";
            }
 
            wrapped += buffers[0];
            wrapped += " ";
            wrapped += buffers[1];
            wrapped += " ";
            wrapped += buffers[2];
            buffers.clear();
        }
    }
 
    if (!wrapped.empty()) {
        wrapped += "\n";
    }
    if (buffers.size() > 0) {
        wrapped += buffers[0];
    }
    if (buffers.size() > 1) {
        wrapped += " ";
        wrapped += buffers[1];
    }
 
    return wrapped;
}

References MAPPED_NOZZLE_STR_MAX_CHARS_PER_LINE.

Referenced by Slic3r::GUI::MaterialItem::doRender(), and s_get_mapped_nozzle_str_line_count().

Here is the caller graph for this function:

same_rgb()

bool Slic3r::GUI::same_rgb ( const wxColour & lhs, const wxColour & rhs )

static

{
    return lhs.Red() == rhs.Red() && lhs.Green() == rhs.Green() && lhs.Blue() == rhs.Blue();
}

Referenced by standard_base_color_for().

Here is the caller graph for this function:

sample_gradient_ramp()

std::vector< wxColour > Slic3r::GUI::sample_gradient_ramp	(	const wxColour &	first,
		const wxColour &	second,
		const Slic3r::GradientCurve &	curve,
		int	steps )

{
    std::vector<wxColour> ramp;
    if (steps <= 0 || curve.points.size() < 2) return ramp;
 
    ramp.reserve(steps);
    for (int i = 0; i < steps; ++i) {
        const double t  = (steps > 1) ? (i + 0.5) / steps : 0.5;
        const double r1 = Slic3r::sample_gradient_curve(curve, t);
        ramp.push_back(blend_n_colors({first, second}, {r1, 1.0 - r1}));
    }
    return ramp;
}

References blend_n_colors(), Slic3r::GradientCurve::points, and Slic3r::sample_gradient_curve().

Referenced by Slic3r::GUI::MixedFilamentDialog::create_preview_panel(), and mixed_gradient_ramp().

Here is the call graph for this function:

Here is the caller graph for this function:

save_texture_to_library()

std::optional< TextureLibraryEntry > Slic3r::GUI::save_texture_to_library	(	const DecodedHeightTexture &	image,
		const std::string &	stem,
		std::string &	error )

{
    std::vector<unsigned char> scratch;
    const wxImage              wx = image_from_decoded(image, scratch);
    if (!wx.IsOk()) {
        error = _u8L("The selected image is empty.");
        return std::nullopt;
    }
 
    std::vector<unsigned char> bytes;
    if (!encode_png_bytes(wx, bytes, error))
        return std::nullopt;
 
    return write_user_texture(bytes, stem.empty() ? std::string("texture") : stem, error);
}

References _u8L.

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::commit_image_adjust().

Here is the caller graph for this function:

save_version()

void Slic3r::GUI::save_version ( )

static

{
    //BBS sentwxGetApp().app_config->set("version_last", std::string(SLIC3R_VERSION));
}

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

Here is the caller graph for this function:

scene_selection()

const Selection & Slic3r::GUI::scene_selection ( )

static

{
    //BBS AssembleView canvas has its own selection
    if (wxGetApp().plater()->get_current_canvas3D()->get_canvas_type() == GLCanvas3D::ECanvasType::CanvasAssembleView)
        return wxGetApp().plater()->get_assmeble_canvas3D()->get_selection();
    
    return wxGetApp().plater()->get_view3D_canvas3D()->get_selection();
}

References Slic3r::GUI::GLCanvas3D::CanvasAssembleView, and plater().

Referenced by Slic3r::GUI::ObjectList::can_split_instances(), Slic3r::GUI::ObjectList::is_instance_or_object_selected(), 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::split_instances(), and Slic3r::GUI::ObjectList::update_selections().

Here is the call graph for this function:

Here is the caller graph for this function:

sCheckFilamentInfo()

DevFilaBlacklist::CheckResult Slic3r::GUI::sCheckFilamentInfo ( PresetBundle * preset_bundle, MachineObject * obj, int ams_id, int slot_id, const std::string & filament_id, std::string & ams_filament_id, std::string & ams_setting_id )

static

{
    DevFilaBlacklist::CheckResult result;
    if (!preset_bundle || !obj)
        return result;
 
    // Orca: there is no lookup struct that also carries setting_id, so resolve the (root) preset by
    // scanning the filaments collection for a matching filament_id.
    Preset* fila_preset = nullptr;
    for (auto it = preset_bundle->filaments.begin(); it != preset_bundle->filaments.end(); ++it) {
        if (it->filament_id == filament_id) {
            fila_preset = &(*it);
            break;
        }
    }
    if (!fila_preset)
        return result;
 
    if (wxGetApp().app_config->get("skip_ams_blacklist_check") != "true") {
        std::string filamnt_type;
        fila_preset->get_filament_type(filamnt_type);
 
        DevFilaBlacklist::CheckFilamentInfo check_info;
        check_info.dev_id              = obj->get_dev_id();
        check_info.model_id            = obj->printer_type;
        check_info.fila_id             = fila_preset->filament_id;
        check_info.fila_type           = filamnt_type;
        check_info.fila_name           = fila_preset->name;
        check_info.has_filament_switch = obj->GetFilaSwitch()->IsInstalled();
        check_info.ams_id              = ams_id;
        check_info.slot_id             = slot_id;
 
        if (auto vendor = dynamic_cast<ConfigOptionStrings*>(fila_preset->config.option("filament_vendor"));
            vendor && !vendor->values.empty()) {
            check_info.fila_vendor = vendor->values[0];
        }
 
        check_info.extruder_id = obj->GetFilaSystem()->GetExtruderIdByAmsId(std::to_string(ams_id));
 
        // Rack-gated per-nozzle context. For a multi-nozzle main extruder on a rack printer (H2C) the
        // specific nozzle is resolved later by the print-dispatch rack mapping, so leave
        // nozzle_flow/nozzle_diameter unset here to keep the high-flow nozzle rules dormant. Every
        // non-rack printer takes the else branch, threading the reported nozzle flow + diameter and
        // thereby activating the high-flow blacklist warnings in the AMS-edit dialog for H2D/H2S/X2D/P2S
        // (and the E3D-kit X1C/P1x).
        DevNozzleSystem* nozzle_system = obj->GetNozzleSystem();
        const bool       rack_supported = nozzle_system && nozzle_system->GetNozzleRack() &&
                                    nozzle_system->GetNozzleRack()->IsSupported();
        if (check_info.extruder_id == MAIN_EXTRUDER_ID && rack_supported) {
            ; // multi-nozzle main extruder on a rack printer — nozzle resolved later by print dispatch
        } else {
            check_info.nozzle_flow = obj->GetFilaSystem()->GetNozzleFlowStringByAmsId(std::to_string(ams_id));
            if (nozzle_system) {
                DevNozzle nozzle = nozzle_system->GetNozzleByPosId(check_info.extruder_id.value_or(-1));
                if (!nozzle.IsEmpty())
                    check_info.nozzle_diameter = nozzle.GetNozzleDiameter();
            }
        }
 
        result = DevFilaBlacklist::check_filaments_in_blacklist(check_info);
    }
 
    ams_filament_id = fila_preset->filament_id;
    ams_setting_id  = fila_preset->setting_id;
    return result;
}

References Slic3r::DevFilaBlacklist::CheckFilamentInfo::ams_id, Slic3r::PresetCollection::begin(), Slic3r::DevFilaBlacklist::check_filaments_in_blacklist(), Slic3r::Preset::config, Slic3r::DevFilaBlacklist::CheckFilamentInfo::dev_id, Slic3r::PresetCollection::end(), Slic3r::DevFilaBlacklist::CheckFilamentInfo::extruder_id, Slic3r::DevFilaBlacklist::CheckFilamentInfo::fila_id, Slic3r::DevFilaBlacklist::CheckFilamentInfo::fila_name, Slic3r::DevFilaBlacklist::CheckFilamentInfo::fila_type, Slic3r::DevFilaBlacklist::CheckFilamentInfo::fila_vendor, Slic3r::Preset::filament_id, Slic3r::PresetBundle::filaments, Slic3r::MachineObject::get_dev_id(), Slic3r::Preset::get_filament_type(), Slic3r::MachineObject::GetFilaSwitch(), Slic3r::MachineObject::GetFilaSystem(), Slic3r::DevNozzleSystem::GetNozzleByPosId(), Slic3r::DevNozzle::GetNozzleDiameter(), Slic3r::DevNozzleSystem::GetNozzleRack(), Slic3r::MachineObject::GetNozzleSystem(), Slic3r::DevFilaBlacklist::CheckFilamentInfo::has_filament_switch, Slic3r::DevNozzle::IsEmpty(), Slic3r::DevFilaSwitch::IsInstalled(), MAIN_EXTRUDER_ID, Slic3r::DevFilaBlacklist::CheckFilamentInfo::model_id, Slic3r::Preset::name, Slic3r::DevFilaBlacklist::CheckFilamentInfo::nozzle_diameter, Slic3r::DevFilaBlacklist::CheckFilamentInfo::nozzle_flow, Slic3r::ConfigBase::option(), Slic3r::MachineObject::printer_type, Slic3r::Preset::setting_id, Slic3r::DevFilaBlacklist::CheckFilamentInfo::slot_id, and Slic3r::ConfigOptionVector< T >::values.

Referenced by Slic3r::GUI::AMSMaterialsSetting::on_select_ok().

Here is the call graph for this function:

Here is the caller graph for this function:

scroll_down()

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);
}

Referenced by process_mouse_wheel(), and Slic3r::GUI::ImGuiWrapper::search_list().

Here is the caller graph for this function:

scroll_up()

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);
}

Referenced by process_mouse_wheel(), and Slic3r::GUI::ImGuiWrapper::search_list().

Here is the caller graph for this function:

scroll_y()

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);
}

Referenced by Slic3r::GUI::ImGuiWrapper::search_list().

Here is the caller graph for this function:

search_string_getter()

bool Slic3r::GUI::search_string_getter ( int idx, const char ** label, const char ** tooltip )

static

{
    return wxGetApp().plater()->search_string_getter(idx, label, tooltip);
}

section_name()

const char * Slic3r::GUI::section_name

(

ShortcutSection

section

)

{ return section_table[size_t(section)].name; }

Referenced by Slic3r::GUI::ConfigWizard::priv::apply_config(), Slic3r::GUI::GuideFrame::apply_config(), Slic3r::GUI::KBShortcutsDialog::create_page(), anonymous_namespace{EmbossStyleManager.cpp}::load_styles(), Slic3r::GUI::ConfigWizard::priv::load_vendors(), Slic3r::GUI::GuideFrame::SaveProfile(), and anonymous_namespace{EmbossStyleManager.cpp}::store_styles().

Here is the caller graph for this function:

seedExtruderNozzleStats()

void Slic3r::GUI::seedExtruderNozzleStats

(

PresetBundle *

preset_bundle

)

{
    if (!preset_bundle)
        return;
    auto *max_nozzle_count   = preset_bundle->printers.get_edited_preset().config.option<ConfigOptionIntsNullable>("extruder_max_nozzle_count");
    auto *nozzle_volume_type = preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
 
    const int extruder_count = preset_bundle->get_printer_extruder_count();
    for (int eid = 0; eid < extruder_count; ++eid) {
        NozzleVolumeType type = nvtStandard;
        if (nozzle_volume_type && eid < (int) nozzle_volume_type->values.size())
            type = NozzleVolumeType(nozzle_volume_type->values[eid]);
        // A fresh seed has no per-type breakdown to draw on, so a Hybrid extruder starts as all-Standard.
        if (type == nvtHybrid)
            type = nvtStandard;
        int count = 1;
        if (max_nozzle_count && eid < (int) max_nozzle_count->values.size() &&
            max_nozzle_count->values[eid] != ConfigOptionIntsNullable::nil_value())
            count = max_nozzle_count->values[eid];
        setExtruderNozzleCount(preset_bundle, eid, type, count, true);
    }
    s_nozzle_stats_from_machine = false;
}

References Slic3r::Preset::config, count, Slic3r::PresetCollection::get_edited_preset(), Slic3r::PresetBundle::get_printer_extruder_count(), Slic3r::ConfigOptionIntsTempl< true >::nil_value(), Slic3r::nozzle_volume_type(), Slic3r::nvtHybrid, Slic3r::nvtStandard, Slic3r::ConfigBase::option(), Slic3r::PresetBundle::printers, Slic3r::PresetBundle::project_config, s_nozzle_stats_from_machine, and setExtruderNozzleCount().

Referenced by Slic3r::GUI::TabPrinter::on_preset_loaded().

Here is the call graph for this function:

Here is the caller graph for this function:

select_iso_view()

void Slic3r::GUI::select_iso_view ( Camera & camera )

static

{
    const Vec3d target = camera.get_target();
    camera.look_at(target + camera.get_distance() * Vec3d(1., -1., 1.).normalized(), target, Vec3d::UnitZ());
    camera.auto_type(Camera::EType::Perspective);
}

References Slic3r::GUI::Camera::auto_type(), Slic3r::GUI::Camera::get_distance(), Slic3r::GUI::Camera::get_target(), Slic3r::GUI::Camera::look_at(), and Slic3r::GUI::Camera::Perspective.

Referenced by Slic3r::GUI::DesignCanvas::DesignCanvas(), and Slic3r::GUI::DesignCanvas::set_view().

Here is the call graph for this function:

Here is the caller graph for this function:

select_nozzle_volume()

void Slic3r::GUI::select_nozzle_volume ( ComboBox * combo, NozzleVolumeType volume_type )

static

{
    for (unsigned int i = 0; i < combo->GetCount(); ++i)
        if (NozzleVolumeType(intptr_t(combo->GetClientData(i))) == volume_type) {
            combo->SetSelection(i);
            return;
        }
}

References ComboBox::GetCount(), and ComboBox::SetSelection().

Referenced by fill_nozzle_volume_combo(), and Slic3r::GUI::CalibrationPresetPage::init_with_machine().

Here is the call graph for this function:

Here is the caller graph for this function:

selectable()

bool Slic3r::GUI::selectable ( const char * label, bool selected, ImGuiSelectableFlags flags = 0, const ImVec2 & size_arg = ImVec2(0, 0), bool * out_hovered = nullptr )

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 || selected) {
        sprintf(marked_label, "%c%s", ImGui::ColorMarkerHovered, label);
        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
    }
    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();
    if (hovered || selected) ImGui::PopStyleColor();
 
    if (out_hovered) *out_hovered = hovered;
 
    // 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;
}

References ImRect, and style.

Referenced by Slic3r::GUI::DesignRowList::DesignRowList(), begin_menu(), Slic3r::GUI::GLGizmosManager::get_gizmo_from_mouse(), menu_item_with_icon(), Slic3r::GUI::GLGizmoMeshBoolean::on_render_input_window(), and Slic3r::GUI::ImGuiWrapper::search_list().

Here is the caller graph for this function:

selected_machines()

std::vector< DeviceItem * > Slic3r::GUI::selected_machines	(	const std::vector< DeviceItem * > &	dev_item_list,
		std::string	search_text )

{
    std::vector<DeviceItem*> res;
    for (const auto& item : dev_item_list) {
        const MachineObject* dev = item->get_obj();
        const std::string& dev_name = dev->get_dev_name();
        const std::string& dev_ip = dev->get_dev_ip();
 
        auto name_it = dev_name.find(search_text);
        auto ip_it = dev_ip.find(search_text);
 
        if (name_it != std::string::npos || ip_it != std::string::npos)
            res.emplace_back(item);
    }
 
    return res;
}

References Slic3r::MachineObject::get_dev_ip(), and Slic3r::MachineObject::get_dev_name().

Here is the call graph for this function:

selection_transform()

void Slic3r::GUI::selection_transform	(	Selection &	selection,
		const std::function< void()> &	selection_transformation_fnc )

Wrap function around selection transformation to apply fix transformation Fix transformation is needed because of (store/load) volume (to/from) 3mf.

Parameters

selection	Selected gl volume will be modified
selection_transformation_fnc	Function modified Selection transformation

{   
    if (const Transform3d *fix = get_fix_transformation(selection); fix != nullptr) {        
        // NOTE: need editable gl volume .. can't use selection.get_first_volume()
        GLVolume *gl_volume = selection.get_volume(*selection.get_volume_idxs().begin());
        Transform3d volume_tr = gl_volume->get_volume_transformation().get_matrix();
        gl_volume->set_volume_transformation(volume_tr * fix->inverse());
        selection.setup_cache();
 
        selection_transformation_fnc();
 
        volume_tr = gl_volume->get_volume_transformation().get_matrix();
        gl_volume->set_volume_transformation(volume_tr * (*fix));
        selection.setup_cache();
    } else {
        selection_transformation_fnc();
    }
 
    if (selection.is_single_full_instance())
        selection.synchronize_unselected_instances(Selection::SyncRotationType::GENERAL);
}

References Slic3r::GUI::Selection::GENERAL, Slic3r::Geometry::Transformation::get_matrix(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::GLVolume::get_volume_transformation(), Slic3r::GUI::Selection::is_single_full_instance(), Slic3r::GLVolume::set_volume_transformation(), Slic3r::GUI::Selection::setup_cache(), and Slic3r::GUI::Selection::synchronize_unselected_instances().

Referenced by do_local_z_move(), do_local_z_rotate(), Slic3r::GUI::GLGizmoEmboss::do_mirror(), dragging_rotate_gizmo(), Slic3r::GUI::GLGizmoSVG::draw_mirroring(), and Slic3r::GUI::GLGizmoSVG::draw_size().

Here is the call graph for this function:

Here is the caller graph for this function:

sequential_clearance_height_polygons()

std::vector< std::pair< Polygon, float > > Slic3r::GUI::sequential_clearance_height_polygons ( const std::vector< SequentialClearanceInstance > & instances, double printable_height, double height_to_lid, double height_to_rod )

inline

{
    std::vector<std::pair<Polygon, float>> height_polygons;
    height_polygons.reserve(instances.size());
    for (size_t k = 0; k < instances.size(); ++k) {
        const auto& instance = instances[k];
        double height = k + 1 == instances.size() ? printable_height : height_to_lid;
        for (size_t i = k + 1; i < instances.size(); ++i) {
            const auto& next_bbox = instances[i].bounding_box;
            if (std::min(instance.bounding_box.max.y(), next_bbox.max.y()) >
                std::max(instance.bounding_box.min.y(), next_bbox.min.y())) {
                height = height_to_rod;
                break;
            }
        }
        if (height < instance.instance_height)
            height_polygons.emplace_back(instance.hull_polygon, float(height));
    }
    return height_polygons;
}

References Slic3r::printable_height().

Referenced by Slic3r::GUI::GLCanvas3D::update_sequential_clearance().

Here is the call graph for this function:

Here is the caller graph for this function:

serialize_mixed_gradient_curve_if_custom()

std::string Slic3r::GUI::serialize_mixed_gradient_curve_if_custom ( const MixedFilamentResult & result )

static

{
    if (!(result.components.size() == 2 && !result.gradient_curve.empty()))
        return {};
 
    const double y0 = (result.gradient_direction == 0) ? kGradientMaxRatio : kGradientMinRatio;
    const double y1 = (result.gradient_direction == 0) ? kGradientMinRatio : kGradientMaxRatio;
    const double eps = 1e-4;
    if (result.gradient_curve.size() == 2) {
        const auto& a0 = result.gradient_curve[0];
        const auto& a1 = result.gradient_curve[1];
        // Default curve also requires no tangent overrides; any finite tangent
        // means the user bent the segment, so we must serialize it.
        const bool is_default =
               std::abs(a0.x - 0.0) < eps
            && std::abs(a1.x - 1.0) < eps
            && std::abs(a0.y - y0)  < eps
            && std::abs(a1.y - y1)  < eps
            && !std::isfinite(a0.m_in)  && !std::isfinite(a0.m_out)
            && !std::isfinite(a1.m_in)  && !std::isfinite(a1.m_out);
        if (is_default) return {};
    }
 
    Slic3r::GradientCurve gc;
    gc.points = result.gradient_curve;
    return Slic3r::serialize_gradient_curve(gc);
}

References Slic3r::GUI::MixedFilamentResult::components, Slic3r::GUI::MixedFilamentResult::gradient_curve, Slic3r::GUI::MixedFilamentResult::gradient_direction, Slic3r::kGradientMaxRatio, Slic3r::kGradientMinRatio, Slic3r::GradientCurve::points, and Slic3r::serialize_gradient_curve().

Referenced by create_mixed_filament_from_result(), and Slic3r::GUI::Sidebar::edit_mixed_filament().

Here is the call graph for this function:

Here is the caller graph for this function:

serialize_nozzle_config()

std::string Slic3r::GUI::serialize_nozzle_config ( const std::map< int, std::vector< DevNozzle > > & nozzle_cfg_map )

static

{
    std::ostringstream oss;
 
    std::vector<DevNozzle> deputy_nozzles;
    auto deputy_it = nozzle_cfg_map.find(1);
    if (deputy_it != nozzle_cfg_map.end()) {
        deputy_nozzles = deputy_it->second;
    }
 
    std::vector<DevNozzle> main_nozzles;
    auto main_it = nozzle_cfg_map.find(0);
    if (main_it != nozzle_cfg_map.end()) {
        main_nozzles = main_it->second;
    }
 
    for (size_t i = 0; i < deputy_nozzles.size(); ++i) {
        if (i > 0) oss << ";";
        oss << std::fixed << std::setprecision(1) << deputy_nozzles[i].GetNozzleDiameter() << ","
            << static_cast<int>(deputy_nozzles[i].GetNozzleFlowType());
    }
 
    oss << "|";
 
    for (size_t i = 0; i < main_nozzles.size(); ++i) {
        if (i > 0) oss << ";";
        oss << std::fixed << std::setprecision(1) << main_nozzles[i].GetNozzleDiameter() << ","
            << static_cast<int>(main_nozzles[i].GetNozzleFlowType());
    }
 
    return oss.str();
}

Referenced by Slic3r::GUI::Sidebar::priv::get_nozzle_options().

Here is the caller graph for this function:

serialize_nozzle_option()

std::string Slic3r::GUI::serialize_nozzle_option ( const NozzleOption & option )

static

                                                                     {
    std::ostringstream oss;
    oss << option.diameter << "|";
 
    bool first = true;
    for (const auto& pair : option.extruder_nozzle_stats) {
        if (!first) oss << ";";
        first = false;
        oss << pair.first << ":";
 
        bool first_stat = true;
        for (const auto& stat_pair : pair.second) {
            if (!first_stat) oss << ",";
            first_stat = false;
            oss << static_cast<int>(stat_pair.first) << "#" << stat_pair.second;
        }
    }
    return oss.str();
}

References Slic3r::GUI::NozzleOption::diameter, and Slic3r::GUI::NozzleOption::extruder_nozzle_stats.

Referenced by Slic3r::GUI::Sidebar::priv::get_nozzle_options().

Here is the caller graph for this function:

set_arrange_polygon_bed_exclusion_extruders()

void Slic3r::GUI::set_arrange_polygon_bed_exclusion_extruders	(	ArrangePolygon &	polygon,
		const ModelObject &	object,
		const PartPlate &	plate,
		const DynamicPrintConfig &	config )

{
    polygon.bed_exclusion_extruder_ids.clear();
    if (active_bed_exclude_volume_mode(config) == BedExcludeVolumeMode::Shared)
        return;
 
    const ConfigOptionFloats *nozzle_diameters = config.opt<ConfigOptionFloats>("nozzle_diameter");
    const size_t extruder_count = nozzle_diameters != nullptr ? nozzle_diameters->size() : 0;
    if (extruder_count == 0)
        return;
 
    PresetBundle *preset_bundle = wxGetApp().preset_bundle;
    if (preset_bundle == nullptr)
        return;
 
    const DynamicPrintConfig &project_config = preset_bundle->project_config;
    // Automatic Bambu mapping may be recalculated after arrangement or differ
    // between destination plates. Leave it unresolved so every nozzle volume
    // is checked rather than embedding a temporary assignment in the item.
    if (preset_bundle->is_bbl_vendor() &&
        is_auto_filament_map_mode(plate.get_real_filament_map_mode(project_config)))
        return;
 
    std::set<int> extruder_ids;
    for (const auto &mapping : plate.get_object_filament_extruders(object, project_config, extruder_count))
        extruder_ids.emplace(int(mapping.second));
    polygon.bed_exclusion_extruder_ids.assign(extruder_ids.begin(), extruder_ids.end());
}

References Slic3r::active_bed_exclude_volume_mode(), Slic3r::arrangement::ArrangePolygon::bed_exclusion_extruder_ids, Slic3r::GUI::PartPlate::get_object_filament_extruders(), Slic3r::GUI::PartPlate::get_real_filament_map_mode(), Slic3r::is_auto_filament_map_mode(), Slic3r::PresetBundle::is_bbl_vendor(), Slic3r::DynamicConfig::opt(), Slic3r::PresetBundle::project_config, Slic3r::Shared, and Slic3r::ConfigOptionVector< double >::size().

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_arrange_polygon_bed_exclusion_extruders_for_all_plates()

void Slic3r::GUI::set_arrange_polygon_bed_exclusion_extruders_for_all_plates ( ArrangePolygon & polygon, const ModelObject & object, PartPlateList & plate_list, const DynamicPrintConfig & config )

static

{
    polygon.bed_exclusion_extruder_ids.clear();
    if (active_bed_exclude_volume_mode(config) == BedExcludeVolumeMode::Shared)
        return;
 
    std::set<int> extruder_ids;
    for (int plate_index = 0; plate_index < plate_list.get_plate_count(); ++plate_index) {
        ArrangePolygon mapped = polygon;
        set_arrange_polygon_bed_exclusion_extruders(mapped, object, *plate_list.get_plate(plate_index), config);
        if (mapped.bed_exclusion_extruder_ids.empty()) {
            polygon.bed_exclusion_extruder_ids.clear();
            return;
        }
        extruder_ids.insert(mapped.bed_exclusion_extruder_ids.begin(), mapped.bed_exclusion_extruder_ids.end());
    }
    polygon.bed_exclusion_extruder_ids.assign(extruder_ids.begin(), extruder_ids.end());
}

References Slic3r::active_bed_exclude_volume_mode(), Slic3r::arrangement::ArrangePolygon::bed_exclusion_extruder_ids, Slic3r::GUI::PartPlateList::get_plate(), Slic3r::GUI::PartPlateList::get_plate_count(), set_arrange_polygon_bed_exclusion_extruders(), and Slic3r::Shared.

Referenced by Slic3r::GUI::ArrangeJob::prepare_all(), and Slic3r::GUI::ArrangeJob::prepare_selected().

Here is the call graph for this function:

Here is the caller graph for this function:

set_config_values()

template<typename T, typename OptionType>

void Slic3r::GUI::set_config_values ( DynamicPrintConfig * config, const std::string & key, T value )

static

{
    auto config_opt = config->option<OptionType>(key);
    if (config_opt) {
        for (size_t i = 0; i < config_opt->values.size(); ++i) {
            config_opt->values[i] = value;
        }
    }
    else {
        BOOST_LOG_TRIVIAL(info) << "set_config_values: the key" << key << "is empty.";
    }
}

References Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern(), Slic3r::GUI::Plater::Calib_Cornering(), Slic3r::GUI::Plater::calib_input_shaping_damp(), Slic3r::GUI::Plater::calib_input_shaping_freq(), Slic3r::GUI::Plater::calib_max_vol_speed(), Slic3r::GUI::Plater::calib_temp(), and Slic3r::GUI::Plater::calib_VFA().

Here is the call graph for this function:

Here is the caller graph for this function:

set_created_standard_component_metadata()

void Slic3r::GUI::set_created_standard_component_metadata	(	size_t	config_idx,
		const DecomposeOfficialComponent &	component )

{
    auto& project_config = wxGetApp().preset_bundle->project_config;
    if (!component.filament_id.empty()) {
        if (auto* filament_id_opt = project_config.option<ConfigOptionStrings>("filament_id")) {
            while (filament_id_opt->values.size() <= config_idx)
                filament_id_opt->values.push_back("");
            filament_id_opt->values[config_idx] = component.filament_id;
        }
    }
 
    // component.filament_id is our OF id; the two constants are the printer's own ids.
    auto* agent = wxGetApp().getAgent();
    const std::string printer_filament_id = agent ? agent->from_orca_filament_id(component.filament_id) : component.filament_id;
    const std::string type = printer_filament_id == kDecomposePetgFilamentId ? kDecomposePetgShortType :
                             printer_filament_id == kDecomposePlaFilamentId ? kDecomposePlaShortType : "";
    if (!type.empty()) {
        if (auto* type_opt = project_config.option<ConfigOptionStrings>("filament_type")) {
            while (type_opt->values.size() <= config_idx)
                type_opt->values.push_back("");
            type_opt->values[config_idx] = type;
        }
    }
}

References Slic3r::GUI::DecomposeOfficialComponent::filament_id, kDecomposePetgFilamentId, kDecomposePetgShortType, kDecomposePlaFilamentId, and kDecomposePlaShortType.

Referenced by Slic3r::GUI::Sidebar::decompose_filament_color().

Here is the caller graph for this function:

set_miniaturizable()

void Slic3r::GUI::set_miniaturizable

(

void *

window

)

{
    CGFloat rFloat = 34/255.0;
    CGFloat gFloat = 34/255.0;
    CGFloat bFloat = 36/255.0;
    [(NSView*) window window].titlebarAppearsTransparent = true;
    [(NSView*) window window].backgroundColor = [NSColor colorWithCalibratedRed:rFloat green:gFloat blue:bFloat alpha:1.0];
    [(NSView*) window window].styleMask |= NSMiniaturizableWindowMask;
 
    NSEnumerator *viewEnum = [[[[[[[(NSView*) window window] contentView] superview] titlebarViewController] view] subviews] objectEnumerator];
    NSView *viewObject;
 
    while(viewObject = (NSView *)[viewEnum nextObject]) {
        if([viewObject class] == [NSTextField self]) {
            //[(NSTextField*)viewObject setTextColor :  NSColor.whiteColor];
            mainframe_text_field = (NSTextField*)viewObject;
        }
    }
}

References mainframe_text_field.

set_pop_up_remind_flag()

void Slic3r::GUI::set_pop_up_remind_flag ( bool remind )

static

{
    auto &app_config = wxGetApp().app_config;
    app_config->set_bool("pop_up_filament_map_dialog", remind);
}

Referenced by Slic3r::GUI::FilamentMapDialog::on_checkbox().

Here is the caller graph for this function:

set_prefered_map_mode()

void Slic3r::GUI::set_prefered_map_mode ( FilamentMapMode mode )

static

{
    const static std::vector<std::string> enum_values = ConfigOptionEnum<FilamentMapMode>::get_enum_names();
    auto                                 &app_config  = wxGetApp().app_config;
    std::string                           mode_str;
    if (mode < enum_values.size()) mode_str = enum_values[mode];
 
    if (mode_str.empty()) BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format("Set empty prefered_filament_map_mode to app config");
    app_config->set("prefered_filament_map_mode", mode_str);
}

References Slic3r::ConfigOptionEnum< T >::get_enum_names().

Here is the call graph for this function:

set_tag_when_enter_full_screen()

void Slic3r::GUI::set_tag_when_enter_full_screen

(

bool

isfullscreen

)

{
  is_in_full_screen_mode = isfullscreen;
}

References is_in_full_screen_mode.

set_title_colour_after_set_title()

void Slic3r::GUI::set_title_colour_after_set_title

(

void *

window

)

{
  NSEnumerator *viewEnum = [[[[[[[(NSView*) window window] contentView] superview] titlebarViewController] view] subviews] objectEnumerator];
  NSView *viewObject;
  while(viewObject = (NSView *)[viewEnum nextObject]) {
    if([viewObject class] == [NSTextField self]) {
      [(NSTextField*)viewObject setTextColor : NSColor.whiteColor];
      mainframe_text_field = (NSTextField*)viewObject;
    }
  }
 
  if (mainframe_text_field) {
    [(NSTextField*)mainframe_text_field setTextColor : NSColor.whiteColor];
  }
}

References mainframe_text_field.

Referenced by Slic3r::GUI::MainFrame::update_title_colour_after_set_title().

Here is the caller graph for this function:

set_window_corner_radius()

void Slic3r::GUI::set_window_corner_radius	(	wxWindow *	win,
		int	radius )

                                                         {
    if (!win)
        return;
    NSView* view = (NSView*)win->GetHandle();
    if (!view)
        return;
    NSWindow* window = [view window];
    [window setOpaque:NO];
    [window setBackgroundColor:[NSColor clearColor]];
    [view setWantsLayer:YES];
    [[view layer] setCornerRadius:radius];
    [[view layer] setMasksToBounds:YES];
}

Referenced by Slic3r::GUI::SpeedDialWebDialog::apply_rounded_shape().

Here is the caller graph for this function:

setExtruderNozzleCount()

void Slic3r::GUI::setExtruderNozzleCount	(	PresetBundle *	preset_bundle,
		int	extruder_id,
		NozzleVolumeType	volume_type,
		int	nozzle_count,
		bool	clear_all )

{
    if (!preset_bundle)
        return;
    // Hybrid is a mix marker, not a physical nozzle type — never a stats key.
    if (volume_type == nvtHybrid)
        return;
    auto &config = preset_bundle->printers.get_edited_preset().config;
    auto *opt    = config.option<ConfigOptionStrings>("extruder_nozzle_stats", true);
    if (!opt)
        return;
 
    const int extruder_count = preset_bundle->get_printer_extruder_count();
    auto      stats          = get_extruder_nozzle_stats(opt->values);
    if ((int) stats.size() < extruder_count)
        stats.resize(extruder_count);
    if (extruder_id < 0 || extruder_id >= (int) stats.size())
        return;
 
    if (clear_all)
        stats[extruder_id].clear();
    stats[extruder_id][volume_type] = nozzle_count;
    opt->values                     = save_extruder_nozzle_stats_to_string(stats);
}

References Slic3r::Preset::config, Slic3r::PresetCollection::get_edited_preset(), Slic3r::get_extruder_nozzle_stats(), Slic3r::PresetBundle::get_printer_extruder_count(), Slic3r::nvtHybrid, Slic3r::PresetBundle::printers, and Slic3r::save_extruder_nozzle_stats_to_string().

Referenced by Slic3r::GUI::Sidebar::priv::get_nozzle_options(), manuallySetNozzleCount(), onNozzleVolumeTypeSwitch(), seedExtruderNozzleStats(), and tryPopUpMultiNozzleDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

setMinimalSupportAreaPrams()

void Slic3r::GUI::setMinimalSupportAreaPrams ( Slic3r::orientation::OrientParams & out )

static

parameters to minimize support area

{
    out.TAR_A               = 0.015f;
    out.TAR_B               = 0.177f;
    out.RELATIVE_F          = 20;
    out.CONTOUR_F           = 0.5f;
    out.BOTTOM_F            = 2.5f;
    out.BOTTOM_HULL_F       = 0.1f;
    out.TAR_C               = 0.1f;
    out.TAR_D               = 1;
    out.TAR_E               = 0.0115f;
    out.FIRST_LAY_H         = 0.2f;      // 0.0475;
    out.VECTOR_TOL          = -0.00083f;
    out.NEGL_FACE_SIZE      = 0.01f;
    out.ASCENT              = -0.5f;
    out.PLAFOND_ADV         = 0.0599f;
    out.CONTOUR_AMOUNT      = 0.0182427f;
    out.OV_H                = 2.574f;
    out.height_offset       = 2.3728f;
    out.height_log          = 0.041375f;
    out.height_log_k        = 1.9325457f;
    out.LAF_MAX             = 0.999f;    // cos(1.4\degree) for low angle face 0.9997f
    out.LAF_MIN             = 0.97f;     // cos(14\degree) 0.9703f
    out.TAR_LAF             = 0.001f;    // 0.01f
    out.TAR_PROJ_AREA       = 0.1f;
    out.BOTTOM_MIN          = 0.1f;      // min bottom area. If lower than it the object may be unstable
    out.BOTTOM_MAX          = 2000;      // max bottom area. If get to it the object is stable enough (further increase bottom area won't do more help)
    out.height_to_bottom_hull_ratio_MIN = 1,
    out.BOTTOM_HULL_MAX     = 2000;      // max bottom hull area
    out.APPERANCE_FACE_SUPP = 3;         // penalty of generating supports on appearance face
    out.overhang_angle      = 60.f;
    out.use_low_angle_face  = true;
    out.min_volume          = false;
    out.fun_dir             = {};
    out.parallel            = true;
    out.progressind         = {};
    out.stopcondition       = {};
}

References Slic3r::orientation::OrientParams::APPERANCE_FACE_SUPP, Slic3r::orientation::OrientParams::ASCENT, Slic3r::orientation::OrientParams::BOTTOM_F, Slic3r::orientation::OrientParams::BOTTOM_HULL_F, Slic3r::orientation::OrientParams::BOTTOM_HULL_MAX, Slic3r::orientation::OrientParams::BOTTOM_MAX, Slic3r::orientation::OrientParams::BOTTOM_MIN, Slic3r::orientation::OrientParams::CONTOUR_AMOUNT, Slic3r::orientation::OrientParams::CONTOUR_F, Slic3r::orientation::OrientParams::FIRST_LAY_H, Slic3r::orientation::OrientParams::fun_dir, Slic3r::orientation::OrientParams::height_log, Slic3r::orientation::OrientParams::height_log_k, Slic3r::orientation::OrientParams::height_offset, Slic3r::orientation::OrientParams::height_to_bottom_hull_ratio_MIN, Slic3r::orientation::OrientParams::LAF_MAX, Slic3r::orientation::OrientParams::LAF_MIN, Slic3r::orientation::OrientParams::min_volume, Slic3r::orientation::OrientParams::NEGL_FACE_SIZE, Slic3r::orientation::OrientParams::OV_H, Slic3r::orientation::OrientParams::overhang_angle, Slic3r::orientation::OrientParams::parallel, Slic3r::orientation::OrientParams::PLAFOND_ADV, Slic3r::orientation::OrientParams::progressind, Slic3r::orientation::OrientParams::RELATIVE_F, Slic3r::orientation::OrientParams::stopcondition, Slic3r::orientation::OrientParams::TAR_A, Slic3r::orientation::OrientParams::TAR_B, Slic3r::orientation::OrientParams::TAR_C, Slic3r::orientation::OrientParams::TAR_D, Slic3r::orientation::OrientParams::TAR_E, Slic3r::orientation::OrientParams::TAR_LAF, Slic3r::orientation::OrientParams::TAR_PROJ_AREA, Slic3r::orientation::OrientParams::use_low_angle_face, and Slic3r::orientation::OrientParams::VECTOR_TOL.

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

Here is the caller graph for this function:

SetNozzleBmpColor()

wxBitmap Slic3r::GUI::SetNozzleBmpColor ( const wxBitmap & bmp, const std::string & color_str )

static

                                                                                   {
    if(color_str.empty()) return bmp;
 
    wxImage img = bmp.ConvertToImage();
    wxColour color("#" + color_str);
 
    for (int y = 0; y < img.GetHeight(); ++y) {
        for (int x = 0; x < img.GetWidth(); ++x) {
            unsigned char r = img.GetRed(x, y);
            unsigned char g = img.GetGreen(x, y);
            unsigned char b = img.GetBlue(x, y);
 
            /*replace yellow with color*/
            if ( r >= 180 && g >= 180 && b <= 150) {
                img.SetRGB(x, y, color.Red(), color.Green(), color.Blue());
            }
        }
    }
 
    return wxBitmap(img, -1, bmp.GetScaleFactor());
}

Referenced by Slic3r::GUI::wgtDeviceNozzleRackNozzleItem::Rescale(), Slic3r::GUI::wgtDeviceNozzleRackToolHead::Rescale(), Slic3r::GUI::wgtDeviceNozzleRackNozzleItem::SetNozzleStatus(), and Slic3r::GUI::wgtDeviceNozzleRackToolHead::UpdateToolHeadInfo().

Here is the caller graph for this function:

setNozzleStatsFromMachine()

void Slic3r::GUI::setNozzleStatsFromMachine

(

bool

from_machine

)

{ s_nozzle_stats_from_machine = from_machine; }

References s_nozzle_stats_from_machine.

Referenced by Slic3r::GUI::Sidebar::priv::get_nozzle_options(), and tryPopUpMultiNozzleDialog().

Here is the caller graph for this function:

setup_collapse_toolbar()

bool Slic3r::GUI::setup_collapse_toolbar	(	GLToolbar &	toolbar,
		std::function< void()>	toggle )

{
    toolbar.set_layout_type(GLToolbar::Layout::Vertical);
    toolbar.set_horizontal_orientation(GLToolbar::Layout::HO_Right);
    toolbar.set_vertical_orientation(GLToolbar::Layout::VO_Top);
    toolbar.set_border(4.0f);
    toolbar.set_separator_size(4);
    toolbar.set_gap_size(2);
 
    toolbar.del_all_item();
 
    GLToolbarItem::Data item;
 
    item.name = "collapse_sidebar";
    // set collapse svg name
    item.icon_filename = "collapse.svg";
    item.sprite_id = 0;
    item.left.action_callback = std::move(toggle);
 
    return toolbar.add_item(item);
}

References Slic3r::GUI::GLToolbar::add_item(), Slic3r::GUI::GLToolbar::del_all_item(), Slic3r::GUI::GLToolbar::Layout::HO_Right, Slic3r::GUI::GLToolbarItem::Data::icon_filename, Slic3r::GUI::GLToolbarItem::Data::left, Slic3r::GUI::GLToolbarItem::Data::name, Slic3r::GUI::GLToolbar::set_border(), Slic3r::GUI::GLToolbar::set_gap_size(), Slic3r::GUI::GLToolbar::set_horizontal_orientation(), Slic3r::GUI::GLToolbar::set_layout_type(), Slic3r::GUI::GLToolbar::set_separator_size(), Slic3r::GUI::GLToolbar::set_vertical_orientation(), Slic3r::GUI::GLToolbarItem::Data::sprite_id, Slic3r::GUI::GLToolbar::Layout::Vertical, and Slic3r::GUI::GLToolbar::Layout::VO_Top.

Referenced by Slic3r::GUI::Plater::priv::init_collapse_toolbar(), and Slic3r::GUI::DesignCanvas::set_sidebar_collapse().

Here is the call graph for this function:

Here is the caller graph for this function:

setup_dialog_position()

template<typename T>

void Slic3r::GUI::setup_dialog_position

(

T &

info

)

{
    auto  plater   = wxGetApp().plater();
    auto& sidebar  = plater->sidebar();
    auto  docking  = plater->get_sidebar_docking_state();
    bool  on_right = true;
 
    if (docking == Sidebar::Left) {
        on_right = true;
    } else if (docking == Sidebar::Right) {
        on_right = false;
    } else {
        // If sidebar is too close to screen right edge, then move the dialog to the left side instead
 
        auto screen_width = wxDisplay(&sidebar).GetClientArea().GetSize().x;
        auto right_space  = screen_width - sidebar.get_sidebar_pos_right_x();
        if (right_space < sidebar.FromDIP(400)) {
            on_right = false;
        }
    }
 
    if (on_right) {
        info.dialog_pos.x           = sidebar.get_sidebar_pos_right_x() + sidebar.FromDIP(5);
        info.dialog_pos_align_right = true;
    } else {
        info.dialog_pos.x           = sidebar.GetScreenPosition().x - sidebar.FromDIP(5);
        info.dialog_pos_align_right = false;
    }
}

References Slic3r::GUI::Sidebar::Left, plater(), and Slic3r::GUI::Sidebar::Right.

Referenced by Slic3r::GUI::Sidebar::pop_finsish_sync_ams_dialog(), and Slic3r::GUI::Sidebar::pop_sync_nozzle_and_ams_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

sGetNozzlePosId()

volatile int Slic3r::GUI::sGetNozzlePosId	(	wgtDeviceNozzleRackNozzleItem *	item,
		wgtDeviceNozzleRackNozzleItem *	l_item,
		wgtDeviceNozzleRackNozzleItem *	r_item )

{
    int to_select_pos_id = -1;
    if (item == l_item) {
        to_select_pos_id = DEPUTY_EXTRUDER_ID;
    } else if (item == r_item) {
        to_select_pos_id = MAIN_EXTRUDER_ID;
    } else {
        to_select_pos_id = item->GetNozzleId() + 0x10;
    }
 
    return to_select_pos_id;
}

References DEPUTY_EXTRUDER_ID, Slic3r::GUI::wgtDeviceNozzleRackNozzleItem::GetNozzleId(), and MAIN_EXTRUDER_ID.

Referenced by Slic3r::GUI::wgtDeviceNozzleRackSelect::OnNozzleItemSelected().

Here is the call graph for this function:

Here is the caller graph for this function:

sGetTrayData()

std::optional< TrayData > Slic3r::GUI::sGetTrayData ( DevAmsTray * tray, const std::string & ams_id_str, DevAmsType ams_type )

static

{
    int ams_id = 0;
    int tray_id = 0;
    try {
        ams_id = std::stoi(ams_id_str);
        tray_id = atoi(tray->id.c_str());
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":[error] invalid ams_id or tray_id: " << e.what();
        return std::nullopt;
    }
 
    TrayData td;
    td.ams_id = ams_id;
    if (ams_type != DevAmsType::EXT_SPOOL) {
        td.slot_id = tray_id;
    } else {
        td.slot_id = 0;
    }
 
    if (ams_type == DevAmsType::AMS ||
        ams_type == DevAmsType::AMS_LITE ||
        ams_type == DevAmsType::N3F) {
        td.id = ams_id * 4 + tray_id;
    } else if (ams_type == DevAmsType::N3S) {
        td.id = ams_id + tray_id;
    } else if(ams_type == DevAmsType::EXT_SPOOL){
        td.id = tray_id;
    }
 
    if (ams_type != EXT_SPOOL && !tray->is_exists) {
        td.type = EMPTY;
    } else {
        if (!tray->is_tray_info_ready()) {
            td.type = THIRD;
        } else {
            td.type = NORMAL;
            td.remain = tray->remain;
            td.colour = DevAmsTray::decode_color(tray->color);
            td.name = tray->get_display_filament_type();
            td.filament_type = tray->get_filament_type();
            td.ctype = tray->ctype;
            for (const auto& col : tray->cols) {
                td.material_cols.push_back(DevAmsTray::decode_color(col));
            }
        }
    }
 
    return td;
}

References Slic3r::AMS, Slic3r::GUI::TrayData::ams_id, Slic3r::AMS_LITE, Slic3r::DevAmsTray::color, Slic3r::GUI::TrayData::colour, Slic3r::DevAmsTray::cols, Slic3r::DevAmsTray::ctype, Slic3r::GUI::TrayData::ctype, Slic3r::DevAmsTray::decode_color(), EMPTY, Slic3r::EXT_SPOOL, Slic3r::GUI::TrayData::filament_type, Slic3r::DevAmsTray::get_display_filament_type(), Slic3r::DevAmsTray::get_filament_type(), Slic3r::DevAmsTray::id, Slic3r::GUI::TrayData::id, Slic3r::DevAmsTray::is_exists, Slic3r::DevAmsTray::is_tray_info_ready(), Slic3r::GUI::TrayData::material_cols, Slic3r::N3F, Slic3r::N3S, Slic3r::GUI::TrayData::name, NORMAL, Slic3r::DevAmsTray::remain, Slic3r::GUI::TrayData::remain, Slic3r::GUI::TrayData::slot_id, THIRD, and Slic3r::GUI::TrayData::type.

Referenced by Slic3r::GUI::AmsMapingPopup::update_mapping_items().

Here is the call graph for this function:

Here is the caller graph for this function:

short_and_splitted_time()

std::string Slic3r::GUI::short_and_splitted_time ( const std::string & time )

static

{
    // Parse the dhms time format.
    int days    = 0;
    int hours   = 0;
    int minutes = 0;
    int seconds = 0;
    if (time.find('d') != std::string::npos)
        ::sscanf(time.c_str(), "%dd %dh %dm %ds", &days, &hours, &minutes, &seconds);
    else if (time.find('h') != std::string::npos)
        ::sscanf(time.c_str(), "%dh %dm %ds", &hours, &minutes, &seconds);
    else if (time.find('m') != std::string::npos)
        ::sscanf(time.c_str(), "%dm %ds", &minutes, &seconds);
    else if (time.find('s') != std::string::npos)
        ::sscanf(time.c_str(), "%ds", &seconds);
 
    // Format the dhm time.
    char buffer[64];
    if (days > 0)
        ::sprintf(buffer, "%dd%dh%dm", days, hours, minutes);
    else if (hours > 0) {
        if (hours < 10 && minutes < 10 && seconds < 10)
            ::sprintf(buffer, "%dh%dm%ds", hours, minutes, seconds);
        else if (hours > 10 && minutes > 10 && seconds > 10)
            ::sprintf(buffer, "%dh%dm%ds", hours, minutes, seconds);
        else if ((minutes < 10 && seconds > 10) || (minutes > 10 && seconds < 10))
            ::sprintf(buffer, "%dh%dm%ds", hours, minutes, seconds);
        else
            ::sprintf(buffer, "%dh%dm%ds", hours, minutes, seconds);
    } else if (minutes > 0) {
        if (minutes > 10 && seconds > 10)
            ::sprintf(buffer, "%dm%ds", minutes, seconds);
        else
            ::sprintf(buffer, "%dm%ds", minutes, seconds);
    } else
        ::sprintf(buffer, "%ds", seconds);
    return std::string(buffer);
}

Referenced by Slic3r::GUI::IMSlider::get_label().

Here is the caller graph for this function:

short_nozzle_volume_name()

wxString Slic3r::GUI::short_nozzle_volume_name ( const std::string & volume_name )

static

{
    // Hybrid has no entry on purpose: it is never a variant string, and the switch lists its two
    // sub-nozzle types as separate tags (see generate_extruder_options).
    if (volume_name == "Standard")
        // TRN Short tag for the Standard nozzle flow type.
        return _L_CONTEXT("SF", "Nozzle flow type");
    if (volume_name == "High Flow")
        // TRN Short tag for the High Flow nozzle flow type.
        return _L_CONTEXT("HF", "Nozzle flow type");
    if (volume_name == "TPU High Flow")
        // TRN Short tag for the TPU High Flow nozzle flow type.
        return _L_CONTEXT("TPU HF", "Nozzle flow type");
    if (volume_name == "E3D High Flow")
        // TRN Short tag for the E3D High Flow nozzle flow type.
        return _L_CONTEXT("E3D HF", "Nozzle flow type");
    if (volume_name == "Extra High Flow")
        // TRN Short tag for the Extra High Flow nozzle flow type.
        return _L_CONTEXT("XHF", "Nozzle flow type");
    return from_u8(volume_name);
}

References _L_CONTEXT, Slic3r::from_u8(), and short_nozzle_volume_name().

Referenced by Slic3r::GUI::Tab::generate_extruder_options(), and short_nozzle_volume_name().

Here is the call graph for this function:

Here is the caller graph for this function:

shortcut_info()

const ShortcutInfo & Slic3r::GUI::shortcut_info

(

Shortcut

shortcut

)

{ return shortcut_table[size_t(shortcut)]; }

Referenced by Slic3r::GUI::ShortcutCaptureDialog::ShortcutCaptureDialog(), Slic3r::GUI::KBShortcutsDialog::apply_bindings(), Slic3r::GUI::ShortcutRegistry::bind(), Slic3r::GUI::ShortcutRegistry::binding(), Slic3r::GUI::ShortcutRegistry::conflicts(), Slic3r::GUI::KBShortcutsDialog::create_page(), Slic3r::GUI::KBShortcutsDialog::edit_shortcut(), Slic3r::GUI::GLCanvas3D::handle_shortcut(), Slic3r::GUI::ShortcutRegistry::lookup(), Slic3r::GUI::ShortcutCaptureDialog::record(), Slic3r::GUI::KBShortcutsDialog::reset_shortcut(), Slic3r::GUI::anonymous_namespace{KBShortcutsDialog.cpp}::shortcut_names(), Slic3r::GUI::ShortcutRegistry::step_owner(), and Slic3r::GUI::KBShortcutsDialog::take_chord_from().

Here is the caller graph for this function:

shortcut_section()

ShortcutSection Slic3r::GUI::shortcut_section

(

Shortcut

shortcut

)

{
    size_t section = 0;
    for (size_t i = 1; i < section_table.size(); ++i)
        if (section_table[i].first <= shortcut)
            section = i;
    return ShortcutSection(section);
}

Referenced by Slic3r::GUI::KBShortcutsDialog::fill_pages().

Here is the caller graph for this function:

shortcuts_in()

std::vector< Shortcut > Slic3r::GUI::shortcuts_in

(

ShortcutContext

context

)

{
    std::vector<Shortcut> out;
    for (const ShortcutInfo& info : shortcut_table)
        if (info.contexts & context_bit(context))
            out.push_back(info.id);
    return out;
}

References context_bit().

Referenced by Slic3r::GUI::KBShortcutsDialog::fill_pages().

Here is the call graph for this function:

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__
    u8"\u2325+"  // "⌥+" (Mac Option+)
#else
    _u8L("Alt+")
#endif
    ;
  return str;
}

References _u8L.

Referenced by Slic3r::GUI::GizmoObjectManipulation::GizmoObjectManipulation(), Slic3r::GUI::GLCanvas3D::GLCanvas3D(), Slic3r::GUI::GLCanvas3D::_render_section_view_panel(), Slic3r::GUI::KeyChord::modifier_prefix(), Slic3r::GUI::GLGizmoCut3D::on_init(), Slic3r::GUI::GLGizmoMmuSegmentation::on_init(), Slic3r::GUI::GLGizmoTextureDisplacement::on_init(), and Slic3r::GUI::anonymous_namespace{SpeedDialDialog.cpp}::speed_dial_ui_strings().

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__
    u8"\u2318+"  // "⌘+" (Mac Command+)
#else
    _u8L("Ctrl+")
#endif
    ;
  return str;
}

References _u8L.

Referenced by Slic3r::GUI::GizmoObjectManipulation::GizmoObjectManipulation(), RammingPanel::RammingPanel(), Slic3r::GUI::KeyChord::modifier_prefix(), Slic3r::GUI::GLGizmoBrimEars::on_init(), Slic3r::GUI::GLGizmoCut3D::on_init(), Slic3r::GUI::GLGizmoFdmSupports::on_init(), Slic3r::GUI::GLGizmoFuzzySkin::on_init(), Slic3r::GUI::GLGizmoMmuSegmentation::on_init(), Slic3r::GUI::GLGizmoSeam::on_init(), Slic3r::GUI::GLGizmoTextureDisplacement::on_init(), Slic3r::GUI::NotificationManager::PrintHostUploadNotification::render_cancel_button(), and Slic3r::GUI::anonymous_namespace{SpeedDialDialog.cpp}::speed_dial_ui_strings().

Here is the caller graph for this function:

shortkey_shift_prefix()

const std::string & Slic3r::GUI::shortkey_shift_prefix

(

)

{
  static const std::string str = _u8L("Shift+");
    return str;
}

References _u8L.

Referenced by Slic3r::GUI::GizmoObjectManipulation::GizmoObjectManipulation(), Slic3r::GUI::GLGizmoCut3D::on_init(), Slic3r::GUI::GLGizmoFdmSupports::on_init(), Slic3r::GUI::GLGizmoFuzzySkin::on_init(), Slic3r::GUI::GLGizmoMeasure::on_init(), Slic3r::GUI::GLGizmoMmuSegmentation::on_init(), Slic3r::GUI::GLGizmoSeam::on_init(), Slic3r::GUI::GLGizmoTextureDisplacement::on_init(), and Slic3r::GUI::GLCanvas3D::LayersEditing::render_variable_layer_height_dialog().

Here is the caller graph for this function:

should_dialog_be_shown()

bool Slic3r::GUI::should_dialog_be_shown ( )

static

{
    //BBS TODO remember to read last version
    //std::string last_sent_version = wxGetApp().app_config->get("version_last");
    std::string last_sent_version = SLIC3R_VERSION;
 
    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
    // 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
    //BBS: remove atl related logic
    //return check_internet_connection_win();
    return true;
#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:

should_pop_up()

bool Slic3r::GUI::should_pop_up ( )

static

{
    const auto &preset_bundle    = wxGetApp().preset_bundle;
    if (!preset_bundle->is_bbl_vendor()) return false;
    const auto &full_config      = preset_bundle->full_config();
    const auto  nozzle_diameters = full_config.option<ConfigOptionFloats>("nozzle_diameter");
    return nozzle_diameters->size() > 1;
}

Referenced by Slic3r::GUI::FilamentGroupPopup::tryPopup().

Here is the caller graph for this function:

show_error() [1/3]

void Slic3r::GUI::show_error	(	wxWindow *	parent,
		const char *	message,
		bool	has_code_excerpts )

{
  assert(message);
  show_error(parent, wxString::FromUTF8(message), has_code_excerpts);
}

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 has_code_excerpts = false )

inline

{ show_error(parent, message.c_str(), has_code_excerpts); }

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	has_code_excerpts )

{
    wxGetApp().CallAfter([=] {
        ErrorDialog msg(parent, message, has_code_excerpts);
        msg.ShowModal();
    });
}

References Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by Slic3r::GUI::PrintHostQueueDialog::PrintHostQueueDialog(), Slic3r::GUI::GLGizmoTextureDisplacement::add_texture_layer(), Slic3r::GUI::GLGizmoTextureDisplacement::bake(), Slic3r::GUI::GLGizmoTextureDisplacement::bake_standard(), Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings(), Slic3r::GUI::GUI_App::catch_error(), Slic3r::GUI::GUI_App::check_legacy_user_filament_presets(), Slic3r::GUI::GUI_App::check_updates(), Slic3r::GUI::GLGizmoTextureDisplacement::commit_image_adjust(), anonymous_namespace{EmbossJob.cpp}::create_message(), Slic3r::GUI::ObjectList::del_subobject_from_object(), Slic3r::GUI::Plater::export_3mf(), Slic3r::GUI::MainFrame::export_config(), Slic3r::GUI::Plater::export_gcode(), Slic3r::GUI::Plater::priv::export_gcode(), Slic3r::GUI::Plater::priv::export_gcode(), Slic3r::GUI::Plater::export_gcode_3mf(), fatal_error(), Slic3r::GUI::ArrangeJob::finalize(), Slic3r::GUI::PlaterWorker< WorkerSubclass >::PlaterJob::finalize(), Slic3r::GUI::SLAImportJob::finalize(), Slic3r::GUI::TextureDisplacementBakeJob::finalize(), focus_event(), Slic3r::GUI::LayerRangeEditor::get_value(), Slic3r::GUI::PointCtrl::get_value(), Slic3r::GUI::Field::get_value_by_opt_type(), Slic3r::GUI::GLGizmoTextureDisplacement::import_custom_texture(), Slic3r::GUI::MainFrame::load_config_file(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::Plater::load_gcode(), Slic3r::GUI::BedShapePanel::load_model(), Slic3r::GUI::CreatePrinterPresetDialog::load_model_stl(), Slic3r::GUI::ObjectList::load_modifier(), Slic3r::GUI::BedShapePanel::load_stl(), Slic3r::GUI::BedShapePanel::load_texture(), Slic3r::GUI::CreatePrinterPresetDialog::load_texture(), Slic3r::GUI::GUI_App::maybe_migrate_user_presets_on_login(), Slic3r::GUI::ConnectPrinterDialog::on_button_confirm(), Slic3r::GUI::Downloader::on_error(), Slic3r::GUI::PrintHostQueueDialog::on_error(), Slic3r::GUI::GUI_App::on_init_inner(), Slic3r::GUI::Plater::priv::on_process_completed(), Slic3r::GUI::Tab::on_value_change(), Slic3r::GUI::Plater::PopupMenu(), Slic3r::GUI::Plater::preview_zip_archive(), Slic3r::GUI::GLGizmoTextureDisplacement::queue_prepare(), Slic3r::GUI::GLGizmoTextureDisplacement::render_debug_stage_panel(), Slic3r::GUI::GLGizmoTextureDisplacement::render_texture_library_popup(), Slic3r::GUI::GLGizmoTextureDisplacement::run_stage_debug(), Slic3r::GUI::GLGizmoTextureDisplacement::run_uv_command(), anonymous_namespace{GLGizmoSVG.cpp}::select_shape(), Slic3r::GUI::Plater::send_gcode_legacy(), Slic3r::GUI::GLGizmoTextureDisplacement::set_layer_texture(), Slic3r::GUI::ObjectList::set_volume_type(), Slic3r::GUI::Plater::priv::show_delayed_error_message(), show_error(), show_error(), show_error_id(), Slic3r::GUI::Plater::show_illegal_characters_warning(), Slic3r::GUI::GLGizmoTextureDisplacement::smooth_model(), Slic3r::GUI::GUI_App::start_download(), Slic3r::GUI::GLGizmoTextureDisplacement::subdivide_model_adaptive(), Slic3r::GUI::Config::take_config_snapshot_report_error(), Slic3r::GUI::PhysicalPrinterDialog::update_printers(), and Slic3r::GUI::FlashforgePrintHostSendDialog::validate_before_close().

Here is the call 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

{ 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_FULL_NAME " - ") + (title.empty() ? _L("Notice") : title), wxOK | wxICON_INFORMATION);
  msg_wingow.ShowModal();
}

References _L, Slic3r::GUI::DPIAware< P >::ShowModal(), and SLIC3R_APP_FULL_NAME.

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::Plater::load_files(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::Plater::normalize_bed_types(), Slic3r::GUI::GLGizmoTextureDisplacement::render_debug_stage_panel(), Slic3r::GUI::GUI_App::request_open_project(), show_info(), and show_info().

Here is the call graph for this function:

Here is the caller graph for this function:

show_notification_extruders_limit_exceeded()

void Slic3r::GUI::show_notification_extruders_limit_exceeded ( )

inlinestatic

{
    wxGetApp()
        .plater()
        ->get_notification_manager()
        ->push_notification(NotificationType::MmSegmentationExceededExtrudersLimit, NotificationManager::NotificationLevel::PrintInfoNotificationLevel,
                            GUI::format(_L_PLURAL("Filament count exceeds the maximum number that painting tool supports. Only the "
                                                  "first %1% filament will be available in painting tool.",
                                                  "Filament count exceeds the maximum number that painting tool supports. Only the "
                                                  "first %1% filaments will be available in painting tool.",
                                                  unsigned(GLGizmoMmuSegmentation::EXTRUDERS_LIMIT)),
                                        GLGizmoMmuSegmentation::EXTRUDERS_LIMIT));
}

References _L_PLURAL, 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(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Here is the call 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("The configuration file \u201c%1%\u201d was loaded, but some values were not recognized."), from_u8(filename)),
    substitution_message(changes), true);
  msg.ShowModal();
}

References _L, add_config_substitutions(), format_wxstr(), from_u8(), Slic3r::GUI::DPIAware< P >::ShowModal(), 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("Process");
      // BBS: remove TYPE_SLA_PRINT
      case Preset::TYPE_FILAMENT:     return _L("Filament");
      // BBS: remove TYPE_SLA_MATERIAL
      case Preset::TYPE_PRINTER:      return _L("Machine");
      // BBS: remove TYPE_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("The configuration package was loaded, but some values were not recognized."), substitution_message(changes), true);
  msg.ShowModal();
}

References _L, add_config_substitutions(), bold_string(), format_wxstr(), preset_type_name(), Slic3r::GUI::DPIAware< P >::ShowModal(), substitution_message(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, and Slic3r::Preset::TYPE_PRINTER.

Referenced by Slic3r::GUI::SLAImportJob::finalize(), Slic3r::GUI::MainFrame::load_config_file(), Slic3r::GUI::Plater::priv::load_files(), and Slic3r::GUI::Plater::load_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

sidebar_icon_btn()

::Button * Slic3r::GUI::sidebar_icon_btn ( wxWindow * parent, const char * icon, const wxString & tip, int px = 20 )

static

{
    auto* b = new ::Button(parent, "", icon, wxBORDER_NONE, px);
    b->SetName("design_icon_btn");
    b->SetCanFocus(false);
    b->SetIconSpacing(0);   // off macOS an empty label still reserves the icon-text gap
    b->SetBorderColor(StateColor());
    b->SetToolTip(tip);
    style_sidebar_icon_btn(b);
    return b;
}

References style_sidebar_icon_btn().

Referenced by Slic3r::GUI::DesignPanel::DesignPanel(), and Slic3r::GUI::DesignPanel::rebuild_constraint_list().

Here is the call graph for this function:

Here is the caller graph for this function:

sketch_endpoint_roles()

int Slic3r::GUI::sketch_endpoint_roles ( const SketchEntity & e, SketchPointRole out[2] )

static

{
    switch (e.type) {
    case SketchEntity::Type::Line:
    case SketchEntity::Type::Arc:
    case SketchEntity::Type::BSpline:
    case SketchEntity::Type::EllipseArc:
        out[0] = SketchPointRole::P0; out[1] = SketchPointRole::P1; return 2;
    case SketchEntity::Type::Point:
        out[0] = SketchPointRole::P0; return 1;
    default: return 0;   // circle: centre coincidence is Concentric's job, not this one's
    }
}

References Slic3r::SketchEntity::Arc, Slic3r::SketchEntity::BSpline, Slic3r::SketchEntity::EllipseArc, Slic3r::SketchEntity::Line, Slic3r::P0, Slic3r::P1, Slic3r::SketchEntity::Point, sketch_endpoint_roles(), and Slic3r::SketchEntity::type.

Referenced by Slic3r::GUI::DesignSketchTool::heal_coincidences(), Slic3r::GUI::DesignSketchTool::infer_auto_constraints(), and sketch_endpoint_roles().

Here is the call graph for this function:

Here is the caller graph for this function:

sketch_plane_prompt()

wxString Slic3r::GUI::sketch_plane_prompt ( )

static

{
    return _L("Click a reference plane or a flat face to sketch on it — Esc cancels");
}

References _L.

Referenced by Slic3r::GUI::DesignPanel::DesignPanel(), and Slic3r::GUI::DesignPanel::start_sketch().

Here is the caller graph for this function:

sketch_step_prompt()

wxString Slic3r::GUI::sketch_step_prompt ( DesignSketchTool::Mode m, int step, int picks )

static

{
    using Mode = DesignSketchTool::Mode;
    auto pick_more = [](const wxString& lead, int n) {
        return n <= 0 ? lead
                      // TRN Appended to a sketch tool prompt; %d is the number of picked entities.
                      : lead + wxString::Format(_L_PLURAL("  ·  %d picked", "  ·  %d picked", n), n);
    };
    switch (m) {
    case Mode::Select:
        return picks > 0
            ? wxString::Format(_L_PLURAL("%d selected  ·  Del removes it  ·  Shift-click adds  ·  "
                                         "double-click takes the whole loop",
                                         "%d selected  ·  Del removes them  ·  Shift-click adds  ·  "
                                         "double-click takes the whole loop", picks), picks)
            : _L("Select — click an entity to pick it  ·  drag an endpoint or center to move it  ·  "
                 "Shift-click adds  ·  Del removes");
    case Mode::Constrain:
        return picks > 0
            ? wxString::Format(_L_PLURAL("%d picked  ·  now choose a constraint (Horizontal, Parallel, "
                                         "Tangent, Equal…)",
                                         "%d picked  ·  now choose a constraint (Horizontal, Parallel, "
                                         "Tangent, Equal…)", picks), picks)
            : _L("Constrain — click one or two entities, then choose a constraint");
    case Mode::Dimension:
        return step == 0 ? _L("Dimension — click an entity, or the first of two points")
                         : _L("Dimension — click the second point");
    case Mode::Line:
        return step == 0 ? _L("Line — click the start point")
                         : _L("Line — click the end point; its length and angle can then be typed");
    case Mode::Polyline:
        return step == 0 ? _L("Polyline — click the first point")
                         : pick_more(_L("Polyline — click the next point  ·  click the start point "
                                        "to close it  ·  right-click, double-click or Enter ends the chain"), step);
    case Mode::CornerRect:
        return step == 0 ? _L("Rectangle — click one corner")
                         : _L("Rectangle — click the opposite corner");
    case Mode::CenterRect:
        return step == 0 ? _L("Center rectangle — click the center")
                         : _L("Center rectangle — click a corner");
    case Mode::ObliqueRect:
        return step == 0 ? _L("Oblique rectangle — click the start of the base edge")
             : step == 1 ? _L("Oblique rectangle — click the end of the base edge (this sets the angle)")
                         : _L("Oblique rectangle — click to set the width");
    case Mode::RoundedRect:
        return step == 0 ? _L("Rounded rectangle — click one corner")
             : step == 1 ? _L("Rounded rectangle — click the opposite corner")
                         : _L("Rounded rectangle — click to set the corner radius");
    case Mode::CenterCircle:
        return step == 0 ? _L("Circle — click the center")
                         : _L("Circle — click to set the radius; it can then be typed");
    case Mode::TwoPointCircle:
        return step == 0 ? _L("Circle (2 points) — click one end of the diameter")
                         : _L("Circle (2 points) — click the other end of the diameter");
    case Mode::ThreePointCircle:
        return step == 0 ? _L("Circle (3 points) — click the first point on the circle")
             : step == 1 ? _L("Circle (3 points) — click the second point")
                         : _L("Circle (3 points) — click the third point");
    case Mode::ThreePointArc:
        return step == 0 ? _L("Arc — click the start point")
             : step == 1 ? _L("Arc — click the end point")
                         : _L("Arc — click a point the arc passes through");
    case Mode::TangentArc:
        return step == 0 ? _L("Tangent arc — click the endpoint it leaves from")
                         : _L("Tangent arc — click its far end");
    case Mode::CenterArc:
        return step == 0 ? _L("Center arc — click the center")
             : step == 1 ? _L("Center arc — click the start point (this sets the radius)")
                         : _L("Center arc — click the end point");
    case Mode::Slot:
        return step == 0 ? _L("Slot — click one end of the centerline")
             : step == 1 ? _L("Slot — click the other end of the centerline")
                         : _L("Slot — click to set the width");
    case Mode::ArcSlot:
        return step == 0 ? _L("Arc slot — click the center the slot curves about")
             : step == 1 ? _L("Arc slot — click the start of the centerline (this sets the radius)")
             : step == 2 ? _L("Arc slot — click the end of the centerline")
                         : _L("Arc slot — click to set the width");
    case Mode::Polygon:
        return step == 0 ? _L("Polygon — click the center")
                         : _L("Polygon — click a vertex (this sets size and orientation)");
    case Mode::Ellipse:
        return step == 0 ? _L("Ellipse — click the center")
             : step == 1 ? _L("Ellipse — click the end of the major axis")
                         : _L("Ellipse — click a point on the minor axis");
    case Mode::EllipseArc:
        return step == 0 ? _L("Elliptical arc — click the center")
             : step == 1 ? _L("Elliptical arc — click the end of the major axis")
             : step == 2 ? _L("Elliptical arc — click a point on the minor axis")
             : step == 3 ? _L("Elliptical arc — click where the arc starts")
                         : _L("Elliptical arc — click where the arc ends");
    case Mode::BSpline:
        return step == 0 ? _L("Spline — click the first control point")
                         : pick_more(_L("Spline — click the next control point  ·  right-click, "
                                        "double-click or Enter finishes the curve"), step);
    case Mode::Point:
        return _L("Point — click to place one; the tool stays armed for more");
    case Mode::Trim:
        return _L("Trim — click a segment where it crosses another entity  ·  Esc to exit");
    case Mode::Extend:
        return _L("Extend — click a line or arc to grow it out to the nearest entity  ·  "
                  "Esc to exit");
    case Mode::Fillet:
        return step == 0 ? _L("Fillet — click the first of two lines that meet")
             : step == 1 ? _L("Fillet — click the second line")
                         : _L("Fillet — drag the arrow, or click the number to type the radius  ·  "
                              "Enter applies  ·  Esc cancels");
    case Mode::Chamfer:
        return step == 0 ? _L("Chamfer — click the first of two lines that meet")
             : step == 1 ? _L("Chamfer — click the second line")
                         : _L("Chamfer — drag the arrow, or click the number to type the setback  ·  "
                              "Enter applies  ·  Esc cancels");
    case Mode::Offset:
        return step == 0 ? _L("Offset — click a curve; its whole outline is offset")
                         : _L("Offset — drag the arrow to either side, or click the number to type "
                              "the distance  ·  Enter applies  ·  Esc cancels");
    case Mode::Mirror:
        // The two-phase pick is the one gesture users reported as unguided: nothing said the
        // AXIS comes first, and nothing said how it is applied.
        return step == 0
            ? _L("Mirror — first click the LINE to mirror about (a construction line works)")
            : picks == 0
                ? _L("Mirror — axis set  ·  now click the entities to mirror  ·  Esc cancels")
                : wxString::Format(_L_PLURAL("Mirror — axis set  ·  %d to mirror  ·  click another to add or "
                                             "remove it  ·  Enter applies",
                                             "Mirror — axis set  ·  %d to mirror  ·  click another to add or "
                                             "remove it  ·  Enter applies", picks), picks);
    case Mode::Move:
        return step == 0 ? _L("Move — click the entities to move")
                         : pick_more(_L("Move — drag the handle, or click the number to type the "
                                        "distance  ·  Enter applies"), picks);
    case Mode::Rotate:
        return step == 0 ? _L("Rotate — click the entities to rotate")
                         : pick_more(_L("Rotate — drag the handle, or click the number to type the "
                                        "angle  ·  Enter applies"), picks);
    case Mode::Scale:
        return step == 0 ? _L("Scale — click the entities to scale")
                         : pick_more(_L("Scale — drag the handle, or click the number to type the "
                                        "factor  ·  Enter applies"), picks);
    case Mode::Array:
        return step == 0 ? _L("Array — click the entities to repeat")
                         : pick_more(_L("Array — drag the handle to set the step, click the count to "
                                        "type it  ·  Enter applies"), picks);
    case Mode::PolarArray:
        return step == 0 ? _L("Polar array — click the entities to repeat")
                         : pick_more(_L("Polar array — drag the handle to set the sweep, click the "
                                        "count to type it  ·  Enter applies"), picks);
    case Mode::TransformArt:
        return _L("Drag a corner to scale, the center to move  ·  Enter or ✓ when done, Esc to discard");
    }
    return wxString();
}

References _L, and _L_PLURAL.

Referenced by Slic3r::GUI::DesignPanel::on_sketch_step().

Here is the caller graph for this function:

slider_behavior()

bool Slic3r::GUI::slider_behavior	(	ImGuiID	id,
		const ImRect &	region,
		const ImS32	v_min,
		const ImS32	v_max,
		ImS32 *	out_value,
		ImRect *	out_handle,
		ImGuiSliderFlags	flags,
		const int	fixed_value,
		const ImVec4 &	fixed_rect )

{
    ImGuiContext& context = *GImGui;
    ImGuiIO& io = ImGui::GetIO();
 
    const ImGuiAxis axis = (flags & ImGuiSliderFlags_Vertical) ? ImGuiAxis_Y : ImGuiAxis_X;
 
    const ImVec2 handle_sz = out_handle->GetSize();
    ImS32 v_range = (v_min < v_max ? v_max - v_min : v_min - v_max);
    const float region_usable_sz = (region.Max[axis] - region.Min[axis]);
    const float region_usable_pos_min = region.Min[axis];
    const float region_usable_pos_max = region.Max[axis];
 
    // Process interacting with the slider
    ImS32 v_new = *out_value;
    bool value_changed = false;
 
    // drag behavior
    if (context.ActiveId == id)
    {
        float mouse_pos_ratio = 0.0f;
        if (context.ActiveIdSource == ImGuiInputSource_Mouse)
        {
            if (context.IO.MouseReleased[0])
            {
                ImGui::ClearActiveID();
            }
            if (context.IO.MouseDown[0])
            {
                const float mouse_abs_pos = context.IO.MousePos[axis];
                mouse_pos_ratio = (region_usable_sz > 0.0f) ? ImClamp((mouse_abs_pos - region_usable_pos_min) / region_usable_sz, 0.0f, 1.0f) : 0.0f;
                if (axis == ImGuiAxis_Y)
                    mouse_pos_ratio = 1.0f - mouse_pos_ratio;
                v_new = v_min + (ImS32)(v_range * mouse_pos_ratio + 0.5f);
            }
        }
    }
    // click in fixed_rect behavior
    if (ImGui::ItemHoverable(fixed_rect, id) && context.IO.MouseReleased[0])
    {
        v_new = fixed_value;
    }
 
  // apply result, output value
  if (*out_value != v_new)
  {
    *out_value = v_new;
    value_changed = true;
  }
 
    // Output handle position so it can be displayed by the caller
    const ImS32 v_clamped = (v_min < v_max) ? ImClamp(*out_value, v_min, v_max) : ImClamp(*out_value, v_max, v_min);
    float handle_pos_ratio = v_range != 0 ? ((float)(v_clamped - v_min) / (float)v_range) : 0.0f;
    handle_pos_ratio = axis == ImGuiAxis_Y ? 1.0f - handle_pos_ratio : handle_pos_ratio;
    const float handle_pos = region_usable_pos_min + (region_usable_pos_max - region_usable_pos_min) * handle_pos_ratio;
 
    ImVec2 new_handle_center = axis == ImGuiAxis_Y ? ImVec2(out_handle->GetCenter().x, handle_pos) : ImVec2(handle_pos, out_handle->GetCenter().y);
    *out_handle = ImRect(new_handle_center - handle_sz * 0.5f, new_handle_center + handle_sz * 0.5f);
 
    return value_changed;
}

References ImRect.

Referenced by Slic3r::GUI::IMSlider::horizontal_slider(), and Slic3r::GUI::IMSlider::vertical_slider().

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 Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::format, M_PI, Slic3r::normal(), Slic3r::GUI::GLModel::Geometry::P3N3, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::resolution(), Slic3r::GUI::GLModel::Geometry::Triangles, and Slic3r::GUI::GLModel::Geometry::vertices_count().

Referenced by Slic3r::GUI::GLGizmoBrimEars::GLGizmoBrimEars(), Slic3r::GUI::GLGizmoMeasure::GLGizmoMeasure(), Slic3r::GUI::Bed3D::Axes::render(), and Slic3r::GUI::Bed3D::render_gravity_arrow().

Here is the call graph for this function:

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 Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::format, M_PI, Slic3r::GUI::GLModel::Geometry::P3N3, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::resolution(), and Slic3r::GUI::GLModel::Geometry::Triangles.

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

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 Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::format, M_PI, Slic3r::GUI::GLModel::Geometry::P3N3, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), and Slic3r::GUI::GLModel::Geometry::Triangles.

Here is the call graph for this function:

sort_plugin_items_for_dialog()

template<class PluginItem>

void Slic3r::GUI::sort_plugin_items_for_dialog	(	std::vector< PluginItem > &	items,
		PluginSortKey	sort_key,
		PluginSortOrder	sort_order )

    {
        std::sort(items.begin(), items.end(),
                  [sort_key, sort_order](const PluginItem& lhs, const PluginItem& rhs)
                  {
                      if (const int cmp = compare_plugin_sort_key(lhs, rhs, sort_key); cmp != 0)
                          return sort_order == PluginSortOrder::Asc ? cmp < 0 : cmp > 0;
                      // why: ties fall back to ascending base order regardless of the primary direction.
                      return compare_plugin_base_order(lhs, rhs) < 0;
                  });
    }

Referenced by Slic3r::GUI::PluginsDialog::build_plugins_payload().

Here is the caller graph for this function:

sort_sequential_clearance_instances()

void Slic3r::GUI::sort_sequential_clearance_instances ( std::vector< SequentialClearanceInstance >::iterator first, std::vector< SequentialClearanceInstance >::iterator last, const std::map< ObjectID, int > & print_order )

inline

{
    if (!std::all_of(first, last, [&print_order](const SequentialClearanceInstance& instance) {
            const auto order = print_order.find(instance.instance_id);
            return order != print_order.end() && order->second > 0;
        }))
        return;
 
    std::stable_sort(first, last, [&print_order](const SequentialClearanceInstance& lhs, const SequentialClearanceInstance& rhs) {
        return print_order.at(lhs.instance_id) < print_order.at(rhs.instance_id);
    });
}

References Slic3r::GUI::SequentialClearanceInstance::instance_id.

Referenced by Slic3r::GUI::GLCanvas3D::update_sequential_clearance().

Here is the caller graph for this function:

spin_frame()

wxWindow * Slic3r::GUI::spin_frame ( wxWindow * spin )

static

{ return spin->GetParent(); }

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

Here is the caller graph for this function:

standard_base_color_for()

DecomposeBaseColor Slic3r::GUI::standard_base_color_for ( DecomposeMode mode, const wxColour & color )

static

{
    if (mode == DecomposeMode::CMYW) {
        if (same_rgb(color, CMYW_CYAN))    return DecomposeBaseColor::Cyan;
        if (same_rgb(color, CMYW_MAGENTA)) return DecomposeBaseColor::Magenta;
        if (same_rgb(color, CMYW_YELLOW))  return DecomposeBaseColor::Yellow;
        if (same_rgb(color, CMYW_WHITE))   return DecomposeBaseColor::White;
    } else if (mode == DecomposeMode::RYBW) {
        if (same_rgb(color, RYBW_RED))     return DecomposeBaseColor::Red;
        if (same_rgb(color, RYBW_YELLOW))  return DecomposeBaseColor::Yellow;
        if (same_rgb(color, RYBW_BLUE))    return DecomposeBaseColor::Blue;
        if (same_rgb(color, RYBW_WHITE))   return DecomposeBaseColor::White;
    }
    return DecomposeBaseColor::None;
}

References Blue, CMYW_CYAN(), CMYW_MAGENTA(), CMYW_WHITE(), CMYW_YELLOW(), Cyan, Magenta, None, Red, RYBW_BLUE(), RYBW_RED(), RYBW_WHITE(), RYBW_YELLOW(), same_rgb(), White, and Yellow.

Referenced by to_dialog_result().

Here is the call graph for this function:

Here is the caller graph for this function:

standard_base_color_from_key()

DecomposeBaseColor Slic3r::GUI::standard_base_color_from_key ( const std::string & key )

static

{
    if (key == "Cyan")    return DecomposeBaseColor::Cyan;
    if (key == "Magenta") return DecomposeBaseColor::Magenta;
    if (key == "Yellow")  return DecomposeBaseColor::Yellow;
    if (key == "White")   return DecomposeBaseColor::White;
    if (key == "Red")     return DecomposeBaseColor::Red;
    if (key == "Green")   return DecomposeBaseColor::Green;
    if (key == "Blue")    return DecomposeBaseColor::Blue;
    return DecomposeBaseColor::None;
}

References Blue, Cyan, Green, Magenta, None, Red, White, and Yellow.

Referenced by to_dialog_result().

Here is the caller graph for this function:

start_mcp_control_if_enabled()

void Slic3r::GUI::start_mcp_control_if_enabled

(

)

{
    const char* env = std::getenv("ORCA_CAD_MCP");
    if (!env || !*env) return;
    std::string path = (std::strcmp(env, "1") == 0) ? "/tmp/orca-cad-mcp.sock" : env;
    static bool started = false;
    if (started) return;
    started = true;
    std::thread(server_thread, path).detach();
}

Referenced by Slic3r::GUI::MainFrame::init_tabpanel().

Here is the caller graph for this function:

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);
}

References GCodeViewer, and start_new_slicer_or_gcodeviewer().

Referenced by 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().

Here is the call graph for this function:

start_new_slicer() [1/2]

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

{
  start_new_slicer_or_gcodeviewer(NewSlicerInstanceType::Slicer, files, single_instance);
}

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 )

{
  start_new_slicer_or_gcodeviewer(NewSlicerInstanceType::Slicer, path_to_open, single_instance);
}

References Slicer, and start_new_slicer_or_gcodeviewer().

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:

start_new_slicer_or_gcodeviewer() [1/2]

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

static

{
#ifdef _WIN32
  wxString path;
  wxFileName::SplitPath(wxStandardPaths::Get().GetExecutablePath(), &path, nullptr, nullptr, wxPATH_NATIVE);
  path += "\\";
  path += (instance_type == NewSlicerInstanceType::Slicer) ? "orca-slicer.exe" : "bambu-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");
  args.emplace_back(nullptr);
  BOOST_LOG_TRIVIAL(info) << "Trying to spawn a new slicer \"" << into_u8(path) << "\"";
  // Don't call with wxEXEC_HIDE_CONSOLE, OrcaSlicer 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__)
  {
        auto bundle_path = bin_path.parent_path().parent_path().parent_path();
    //bin_path = bin_path.parent_path() / "OrcaSlicer";
        bin_path = "/usr/bin/open";
    // 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 = { "-n", "-a", bundle_path.string()};
            if (!paths_to_open.empty()) {
                for (const auto& file : paths_to_open)
                    args.emplace_back(into_u8(file));
            }
            args.emplace_back("--args");
      if (instance_type == NewSlicerInstanceType::GCodeViewer)
        args.emplace_back("--gcodeviewer");
      if (instance_type == NewSlicerInstanceType::Slicer && single_instance)
        args.emplace_back("--single-instance");
      boost::process::spawn(bin_path, args);
    }
    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) ? "orca-slicer" : "bambu-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");
    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 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]

void Slic3r::GUI::start_new_slicer_or_gcodeviewer ( const NewSlicerInstanceType instance_type, const wxString * path_to_open, bool single_instance )

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);
}

References start_new_slicer_or_gcodeviewer().

Here is the call graph for this function:

start_ping_test()

void Slic3r::GUI::start_ping_test

(

)

{
    return;
    wxArrayString output;
    wxExecute("ping www.amazon.com", output, wxEXEC_NODISABLE);
 
    wxString output_i;
    std::string output_temp;
 
    for (int i = 0; i < output.size(); i++) {
        output_i = output[i].To8BitData();
        output_temp = output_i.ToStdString(wxConvUTF8);
        BOOST_LOG_TRIVIAL(info) << "ping amazon:" << output_temp;
 
    }
    wxExecute("ping www.apple.com", output, wxEXEC_NODISABLE);
    for (int i = 0; i < output.size(); i++) {
        output_i = output[i].To8BitData();
        output_temp = output_i.ToStdString(wxConvUTF8);
        BOOST_LOG_TRIVIAL(info) << "ping www.apple.com:" << output_temp;
    }
    wxExecute("ping www.bambulab.com", output, wxEXEC_NODISABLE);
    for (int i = 0; i < output.size(); i++) {
        output_i = output[i].To8BitData();
        output_temp = output_i.ToStdString(wxConvUTF8);
        BOOST_LOG_TRIVIAL(info) << "ping bambulab:" << output_temp;
    }
    //Get GateWay IP
    wxExecute("ping 192.168.0.1", output, wxEXEC_NODISABLE);
    for (int i = 0; i < output.size(); i++) {
        output_i = output[i].To8BitData();
        output_temp = output_i.ToStdString(wxConvUTF8);
        BOOST_LOG_TRIVIAL(info) << "ping 192.168.0.1:" << output_temp;
    }
}

Referenced by Slic3r::GUI::MediaPlayCtrl::Stop().

Here is the caller graph for this function:

starts_with_preset_name()

bool Slic3r::GUI::starts_with_preset_name ( const std::string & name, const char * prefix )

static

{
    const size_t prefix_len = std::strlen(prefix);
    return name.size() >= prefix_len && name.compare(0, prefix_len, prefix) == 0;
}

Referenced by resolve_default_virtual_filament_preset_name().

Here is the caller graph for this function:

staticbox_remove_margin()

void Slic3r::GUI::staticbox_remove_margin

(

wxStaticBox *

sb

)

                                              {
    NSBox* nativeBox = (NSBox*)sb->GetHandle();
    [nativeBox setBoxType:NSBoxCustom];
    [nativeBox setBorderWidth:0];
}

Referenced by LabeledStaticBox::Create().

Here is the caller 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::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::angle(), Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::GLModel::Geometry::P3N3, PI, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::resolution(), and Slic3r::GUI::GLModel::Geometry::Triangles.

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

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:

str_is_all_digit()

bool Slic3r::GUI::str_is_all_digit ( const std::string & str )

static

                                                   {
    for (const char &c : str) {
        if (!std::isdigit(c)) return false;
    }
    return true;
}

Referenced by Slic3r::GUI::CreateFilamentPresetDialog::create_dialog_buttons().

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::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::format, Slic3r::normal(), Slic3r::GUI::GLModel::Geometry::P3N3, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), 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:

string_getter()

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);
}

StringReplace()

void Slic3r::GUI::StringReplace	(	std::string &	strBase,
		std::string	strSrc,
		std::string	strDes )

{
    std::string::size_type pos    = 0;
    std::string::size_type srcLen = strSrc.size();
    std::string::size_type desLen = strDes.size();
    pos                      = strBase.find(strSrc, pos);
    while ((pos != std::string::npos)) {
        strBase.replace(pos, srcLen, strDes);
        pos = strBase.find(strSrc, (pos + desLen));
    }
}

Referenced by Slic3r::GUI::GuideFrame::LoadProfileFamily().

Here is the caller graph for this function:

style_sidebar_icon_btn()

void Slic3r::GUI::style_sidebar_icon_btn ( ::Button * b )

static

{
    b->SetPaddingSize(b->FromDIP(wxSize(2, 2)));
    b->SetMinSize(b->FromDIP(wxSize(24, 24)));   // square, whatever the icon size
    b->SetCornerRadius(b->FromDIP(4));
    b->SetBackgroundColor(StateColor(
        std::pair<wxColour, int>(wxColour(DesignRowList::hover_chip), StateColor::Hovered),   // dark-mapped at paint
        std::pair<wxColour, int>(dp_panel_bg(),                       StateColor::Normal)));   // must stay last
}

References dp_panel_bg(), Slic3r::GUI::DesignRowList::hover_chip, StateColor::Hovered, StateColor::Normal, StaticBox::SetBackgroundColor(), StaticBox::SetCornerRadius(), Button::SetMinSize(), and Button::SetPaddingSize().

Referenced by Slic3r::GUI::DesignPanel::refresh_icons(), and sidebar_icon_btn().

Here is the call graph for this function:

Here is the caller graph for this function:

substitution_message()

wxString Slic3r::GUI::substitution_message ( const wxString & changes )

static

{
  return
    _L("The configuration may be generated by a newer version of OrcaSlicer.") + " " +
    _L("Some values have been replaced. Please check them:") + "\n" + changes + "\n";
}

References _L.

Referenced by show_substitutions_info(), and show_substitutions_info().

Here is the caller graph for this function:

substruct()

std::vector< std::string > Slic3r::GUI::substruct ( std::vector< std::string > const & l, std::vector< std::string > const & r )

static

{
    std::vector<std::string> t;
    std::copy_if(l.begin(), l.end(), std::back_inserter(t), [&r](auto & e) { return std::find(r.begin(), r.end(), e) == r.end(); });
    return t;
}

References substruct().

Referenced by substruct(), and Slic3r::GUI::TabPrintModel::update_model_config().

Here is the call graph for this function:

Here is the caller graph for this function:

support_combo_value_for_config()

wxString Slic3r::GUI::support_combo_value_for_config ( const DynamicPrintConfig & config, bool is_fff )

static

{
    const std::string support         = is_fff ? "enable_support"                 : "supports_enable";
    const std::string buildplate_only = is_fff ? "support_on_build_plate_only" : "support_buildplate_only";
 
    // BBS
#if 0
    return
        ! config.opt_bool(support) ?
            _("None") :
            (is_fff && !config.opt_bool("support_material_auto")) ?
                _("For support enforcers only") :
                (config.opt_bool(buildplate_only) ? _("Support on build plate only") :
                                                    _("Everywhere"));
#else
    if (config.opt_bool(support)) {
         return (config.opt_bool(buildplate_only) ? _("Support on build plate only") : _("Everywhere"));
    } else {
        return _("For support enforcers only");
    }
#endif
}

References _, Slic3r::DynamicConfig::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:

support_nozzle_volume()

bool Slic3r::GUI::support_nozzle_volume

(

const MachineObject *

obj

)

{
    if (!obj)
        return false;
    Preset * machine_preset = get_printer_preset(obj);
    if (machine_preset) {
        int extruder_nums = machine_preset->config.option<ConfigOptionFloatsNullable>("nozzle_diameter")->values.size();
        auto nozzle_volume_opt = machine_preset->config.option<ConfigOptionFloatsNullable>("nozzle_volume");
        if (nozzle_volume_opt) {
            int printer_variant_size = nozzle_volume_opt->values.size();
            return (printer_variant_size / extruder_nums) > 1;
        }
    }
    return false;
}

References Slic3r::Preset::config, get_printer_preset(), and Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::EditCalibrationHistoryDialog::EditCalibrationHistoryDialog(), Slic3r::GUI::NewCalibrationHistoryDialog::NewCalibrationHistoryDialog(), Slic3r::GUI::NewCalibrationHistoryDialog::on_ok(), Slic3r::GUI::EditCalibrationHistoryDialog::on_save(), and Slic3r::GUI::HistoryWindow::sync_history_data().

Here is the call graph for this function:

Here is the caller graph for this function:

switch_window_pools()

void Slic3r::GUI::switch_window_pools

(

)

{
    for (auto p : spools) {
        spools2.push_back(*p);
        *p = new std::deque<wxWindow*>;
    }
}

References spools, and spools2.

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

Here is the caller graph for this function:

sync_loaded_project_filament_config()

void Slic3r::GUI::sync_loaded_project_filament_config ( DynamicConfig & proj_cfg )

static

{
    ConfigOptionStrings* filament_color = proj_cfg.opt<ConfigOptionStrings>("filament_colour");
    if (filament_color) {
        size_t filament_count = filament_color->size();
 
        // Sync filament map
        ConfigOptionInts* filament_map = proj_cfg.opt<ConfigOptionInts>("filament_map", true);
        if (filament_map->size() != filament_count) {
            filament_map->values.resize(filament_count, 1);
        }
 
        ConfigOptionInts* filament_nozzle_map = proj_cfg.opt<ConfigOptionInts>("filament_nozzle_map", true);
        if (filament_nozzle_map->size() != filament_count) {
            filament_nozzle_map->values.resize(filament_count, 0);
        }
 
        ConfigOptionInts* filament_volume_map = proj_cfg.opt<ConfigOptionInts>("filament_volume_map", true);
        if (filament_volume_map->size() != filament_count) {
            filament_volume_map->values.resize(filament_count, static_cast<int>(NozzleVolumeType::nvtStandard));
        }
 
        // Sync filament multi colour
        ConfigOptionStrings* filament_multi_color = proj_cfg.opt<ConfigOptionStrings>("filament_multi_colour", true);
        if (filament_multi_color->size() != filament_count) {
            filament_multi_color->values.resize(filament_count);
        }
        // If there is no multi-color data or color is not match, use single color as default value
        for (size_t i = 0; i < filament_count; i++) {
            std::vector<std::string> colors = Slic3r::split_string(filament_multi_color->values[i], ' ');
            if (i >= filament_multi_color->values.size() || colors.empty() || colors[0] != filament_color->values[i] ) {
                filament_multi_color->values[i] = filament_color->values[i];
            }
        }
        // Sync filament colour type
        ConfigOptionStrings* filament_color_type = proj_cfg.opt<ConfigOptionStrings>("filament_colour_type", true);
        if (filament_color_type && filament_color_type->size() != filament_count) {
            filament_color_type->values.resize(filament_count);
 
            for (size_t i = 0; i < filament_count; i++) {
                if (i >= filament_color_type->values.size() || filament_color_type->values[i].empty()) {
                    filament_color_type->values[i] = "1";
                }
            }
        }
    }
 
    // Filament Track Switch state is derived live from the connected
    // printer; a loaded project must not carry a stale installed/active
    // flag, so clear both and let device sync re-derive them.
    if (auto* has_switcher = proj_cfg.opt<ConfigOptionBool>("has_filament_switcher"))
        has_switcher->value = false;
    if (auto* dynamic_map = proj_cfg.opt<ConfigOptionBool>("enable_filament_dynamic_map"))
        dynamic_map->value = false;
}

References Slic3r::filament_map(), Slic3r::filament_nozzle_map(), Slic3r::nvtStandard, Slic3r::DynamicConfig::opt(), Slic3r::ConfigOptionVector< T >::size(), Slic3r::ConfigOptionVector< int >::size(), Slic3r::split_string(), Slic3r::ConfigOptionVector< T >::values, and Slic3r::ConfigOptionVector< int >::values.

Referenced by Slic3r::GUI::Plater::priv::load_files(), and Slic3r::GUI::Plater::load_gcode().

Here is the call graph for this function:

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::CutObjectBase::copy(), Slic3r::ModelObject::cut_id, Slic3r::CutObjectBase::has_same_id(), Slic3r::ModelObject::is_cut(), Slic3r::CutObjectBase::is_equal(), and Slic3r::Model::objects.

Referenced by Slic3r::GUI::GLGizmoCut3D::perform_cut().

Here is the call graph for this function:

Here is the caller graph for this function:

take_snapshot()

void Slic3r::GUI::take_snapshot ( const std::string & snapshot_name )

static

{
    Plater* plater = wxGetApp().plater();
    if (plater)
        plater->take_snapshot(snapshot_name);
}

References plater().

Referenced by Slic3r::GUI::ObjectList::add_category_to_settings_from_frequent(), Slic3r::GUI::ObjectList::add_category_to_settings_from_selection(), Slic3r::GUI::ObjectList::add_layer_range_after_current(), Slic3r::GUI::ObjectList::del_instances_from_object(), Slic3r::GUI::ObjectList::del_layer_from_object(), Slic3r::GUI::ObjectList::del_settings_from_config(), Slic3r::GUI::ObjectList::del_subobject_from_object(), Slic3r::GUI::ObjectList::delete_all_connectors_for_object(), Slic3r::GUI::ObjectList::delete_from_model_and_list(), Slic3r::GUI::ObjectList::edit_layer_range(), Slic3r::GUI::ObjectList::invalidate_cut_info_for_object(), Slic3r::GUI::ObjectList::layers_editing(), Slic3r::GUI::ObjectList::load_generic_subobject(), Slic3r::GUI::ObjectList::load_subobject(), Slic3r::GUI::ObjectList::OnDrop(), Slic3r::GUI::ObjectList::paste_settings_into_list(), queue_texture_displacement_bake(), Slic3r::GUI::ObjectList::set_extruder_for_selected_items(), Slic3r::GUI::ObjectList::set_volume_type(), Slic3r::GUI::ObjectList::split(), Slic3r::GUI::ObjectList::toggle_auto_drop(), Slic3r::GUI::ObjectList::toggle_printable_state(), Slic3r::GUI::ObjectList::update_filament_in_config(), and Slic3r::GUI::ObjectList::update_name_in_model().

Here is the call graph for this function:

Here is the caller graph for this function:

texture_displacement_bake_volume()

TextureDisplacementBakeVolume Slic3r::GUI::texture_displacement_bake_volume	(	const ModelVolume &	volume,
		const std::vector< TextureDisplacementLayer > &	layers,
		const TextureDisplacementOptions &	options,
		const Vec3d &	texture_anchor,
		float	resting_drop )

{
    TextureDisplacementBakeVolume out;
    out.volume_id       = volume.id();
    out.base_mesh       = volume.mesh().its;
    out.layers          = layers;
    out.options         = options;
    out.volume_to_world = texture_displacement_volume_to_world(volume);
    out.texture_anchor  = texture_anchor;
    out.resting_drop    = resting_drop;
    if (volume.has_texture_uv())
        out.model_uv = volume.texture_uv;
    for (int i = 0; i < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++i)
        out.facets_data[size_t(i)] = volume.texture_displacement_facet(i).get_data();
    return out;
}

References Slic3r::GUI::TextureDisplacementBakeVolume::base_mesh, Slic3r::GUI::TextureDisplacementBakeVolume::facets_data, Slic3r::FacetsAnnotation::get_data(), Slic3r::ModelVolume::has_texture_uv(), Slic3r::ObjectBase::id(), Slic3r::TriangleMesh::its, Slic3r::GUI::TextureDisplacementBakeVolume::layers, Slic3r::ModelVolume::mesh(), Slic3r::GUI::TextureDisplacementBakeVolume::model_uv, Slic3r::GUI::TextureDisplacementBakeVolume::options, Slic3r::GUI::TextureDisplacementBakeVolume::resting_drop, Slic3r::GUI::TextureDisplacementBakeVolume::texture_anchor, texture_displacement_bake_volume(), Slic3r::ModelVolume::texture_displacement_facet(), Slic3r::TEXTURE_DISPLACEMENT_MAX_LAYERS, Slic3r::texture_displacement_volume_to_world(), Slic3r::ModelVolume::texture_uv, Slic3r::GUI::TextureDisplacementBakeVolume::volume_id, and Slic3r::GUI::TextureDisplacementBakeVolume::volume_to_world.

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::bake(), and texture_displacement_bake_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

texture_entry_is_mixed()

bool Slic3r::GUI::texture_entry_is_mixed ( TextureFilamentKind kind )

static

{
    return kind == TextureFilamentKind::ExistingMixed || kind == TextureFilamentKind::NewMixed;
}

References ExistingMixed, and NewMixed.

Referenced by Slic3r::GUI::FilamentSelectPopup::FilamentSelectPopup(), Slic3r::GUI::TextureImportDialog::apply_auto_standard_mix(), Slic3r::GUI::TextureImportDialog::rebuild_mapping_rows(), and Slic3r::GUI::TextureImportDialog::reset_auto_mix().

Here is the caller graph for this function:

texture_entry_is_physical()

bool Slic3r::GUI::texture_entry_is_physical ( TextureFilamentKind kind )

static

{
    return kind == TextureFilamentKind::ExistingPhysical || kind == TextureFilamentKind::NewPhysical;
}

References ExistingPhysical, and NewPhysical.

Referenced by Slic3r::GUI::TextureImportDialog::add_decomposed_mixed_filament(), Slic3r::GUI::TextureImportDialog::add_virtual_mixed_filament(), Slic3r::GUI::TextureImportDialog::apply_auto_standard_mix(), Slic3r::GUI::TextureImportDialog::compact_used_virtual_filaments(), Slic3r::GUI::TextureImportDialog::do_auto_match(), and texture_entry_official_basic().

Here is the caller graph for this function:

texture_entry_is_pla_basic()

bool Slic3r::GUI::texture_entry_is_pla_basic ( const TextureFilamentEntry & entry )

static

{
    return entry.type == DEFAULT_VIRTUAL_FILAMENT_SHORT_TYPE || entry.type == DEFAULT_VIRTUAL_FILAMENT_BASIC_TYPE ||
           entry.name.find(DEFAULT_VIRTUAL_FILAMENT_BASIC_TYPE) != std::string::npos ||
           entry.preset_name.find(DEFAULT_VIRTUAL_FILAMENT_BASIC_TYPE) != std::string::npos;
}

References DEFAULT_VIRTUAL_FILAMENT_BASIC_TYPE, DEFAULT_VIRTUAL_FILAMENT_SHORT_TYPE, Slic3r::GUI::TextureFilamentEntry::name, Slic3r::GUI::TextureFilamentEntry::preset_name, and Slic3r::GUI::TextureFilamentEntry::type.

Referenced by Slic3r::GUI::TextureImportDialog::apply_auto_standard_mix().

Here is the caller graph for this function:

texture_entry_official_basic()

bool Slic3r::GUI::texture_entry_official_basic ( const TextureFilamentEntry & entry )

static

{
    if (!texture_entry_is_physical(entry.kind))
        return false;
    // NewPhysical entries are created by add_virtual_filament with a fixed Bambu Basic name.
    if (entry.kind == TextureFilamentKind::NewPhysical)
        return !official_basic_type_from_preset_name(entry.name).empty();
    // ExistingPhysical: resolve the filament preset name from project_config_index.
    auto& pb = *wxGetApp().preset_bundle;
    const size_t cfg = entry.project_config_index;
    if (cfg < pb.filament_presets.size())
        return !official_basic_type_from_preset_name(pb.filament_presets[cfg]).empty();
    return false;
}

References Slic3r::GUI::TextureFilamentEntry::kind, Slic3r::GUI::TextureFilamentEntry::name, NewPhysical, official_basic_type_from_preset_name(), Slic3r::GUI::TextureFilamentEntry::project_config_index, and texture_entry_is_physical().

Referenced by Slic3r::GUI::TextureImportDialog::add_decomposed_mixed_filament().

Here is the call graph for this function:

Here is the caller graph for this function:

texture_library()

const std::vector< TextureLibraryEntry > & Slic3r::GUI::texture_library

(

bool

force_rescan

)

{
    const uint64_t generation = texture_library_generation();
    if (g_library_scanned && !force_rescan && generation == g_library_scan_generation)
        return g_library;
 
    g_library.clear();
    scan_dir(boost::filesystem::path(Slic3r::resources_dir()) / "textures" / "displacement", TextureSource::Shipped, g_library);
    const std::string user_dir = user_texture_dir();
    if (!user_dir.empty())
        scan_dir(boost::filesystem::path(user_dir), TextureSource::User, g_library);
    sort_user_textures(g_library);
    scan_plugin_textures(g_library);
 
    g_library_scan_generation = generation;
    g_library_scanned          = true;
    return g_library;
}

References Slic3r::resources_dir(), Shipped, texture_library_generation(), User, and user_texture_dir().

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::add_texture_layer(), remove_user_texture(), Slic3r::GUI::GLGizmoTextureDisplacement::render_texture_library_popup(), and Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::write_user_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

texture_library_generation()

uint64_t Slic3r::GUI::texture_library_generation

(

)

{
    return g_library_generation.load();
}

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::render_texture_library_popup(), and texture_library().

Here is the caller graph for this function:

texture_normalize_color_hex()

std::string Slic3r::GUI::texture_normalize_color_hex ( std::string hex )

static

{
    if (hex.empty())
        return "#808080";
    if (hex.front() != '#')
        hex = "#" + hex;
    return decompose_normalize_color_hex(std::move(hex));
}

References decompose_normalize_color_hex().

Referenced by Slic3r::GUI::TextureImportDialog::add_decomposed_mixed_filament(), Slic3r::GUI::TextureImportDialog::add_virtual_filament(), Slic3r::GUI::TextureImportDialog::add_virtual_mixed_filament(), Slic3r::GUI::TextureImportDialog::apply_auto_standard_mix(), Slic3r::GUI::TextureImportDialog::compact_used_virtual_filaments(), Slic3r::GUI::TextureImportDialog::on_computation_complete(), and wxBEGIN_EVENT_TABLE().

Here is the call graph for this function:

Here is the caller graph for this function:

texture_recipe_mode()

Slic3r::ColorDecomposeRecipeMode Slic3r::GUI::texture_recipe_mode ( TextureAutoMixMode mode )

static

{
    return mode == TextureAutoMixMode::CMYW ? Slic3r::ColorDecomposeRecipeMode::CMYW :
                                             Slic3r::ColorDecomposeRecipeMode::RYBW;
}

References Slic3r::CMYW, CMYW, and Slic3r::RYBW.

Referenced by Slic3r::GUI::TextureImportDialog::apply_auto_standard_mix().

Here is the caller graph for this function:

texture_rgba_to_hex()

std::string Slic3r::GUI::texture_rgba_to_hex ( const std::array< float, 4 > & rgba )

static

{
    return wxString::Format("#%02X%02X%02X",
        (unsigned char)std::clamp(rgba[0] * 255.f, 0.f, 255.f),
        (unsigned char)std::clamp(rgba[1] * 255.f, 0.f, 255.f),
        (unsigned char)std::clamp(rgba[2] * 255.f, 0.f, 255.f)).ToStdString();
}

tip_now()

double Slic3r::GUI::tip_now ( )

static

{
    using clock = std::chrono::steady_clock;
    static const clock::time_point base = clock::now();
    return std::chrono::duration<double>(clock::now() - base).count();
}

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::panel_tooltip(), and Slic3r::GUI::GLGizmoTextureDisplacement::render_tip_media().

Here is the caller graph for this function:

to_dialog_result()

ColorDecomposeResult Slic3r::GUI::to_dialog_result ( const ColorDecomposeRecipeResult & recipe, const wxColour & fallback )

static

{
    ColorDecomposeResult result;
    result.mode = recipe.mode;
    result.matched_color = hex_to_wx_colour(recipe.matched_color_hex, fallback);
    for (const auto& comp_recipe : recipe.components) {
        DecomposeComponent comp;
        comp.colour = hex_to_wx_colour(comp_recipe.color_hex, fallback);
        comp.ratio = comp_recipe.ratio;
        comp.filament_index = static_cast<int>(comp_recipe.filament_index);
        comp.base_color = standard_base_color_from_key(comp_recipe.base_color);
        if (comp.base_color == DecomposeBaseColor::None)
            comp.base_color = standard_base_color_for(recipe.mode, comp.colour);
        result.components.push_back(comp);
    }
    return result;
}

References Slic3r::GUI::DecomposeComponent::base_color, Slic3r::GUI::DecomposeComponent::colour, Slic3r::ColorDecomposeRecipeResult::components, Slic3r::GUI::ColorDecomposeResult::components, Slic3r::GUI::DecomposeComponent::filament_index, hex_to_wx_colour(), Slic3r::GUI::ColorDecomposeResult::matched_color, Slic3r::ColorDecomposeRecipeResult::matched_color_hex, Slic3r::ColorDecomposeRecipeResult::mode, Slic3r::GUI::ColorDecomposeResult::mode, None, Slic3r::GUI::DecomposeComponent::ratio, standard_base_color_for(), and standard_base_color_from_key().

Referenced by Slic3r::GUI::ColorDecomposeDialog::compute_decomposition().

Here is the call graph for this function:

Here is the caller graph for this function:

to_hex()

std::string Slic3r::GUI::to_hex ( const wxColour & c )

static

{
    return wxString::Format("#%02X%02X%02X", c.Red(), c.Green(), c.Blue()).ToStdString();
}

Referenced by blend_n_colors(), and recompute_mixed_slot_colors().

Here is the caller graph for this function:

to_squared_power_of_two()

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:

to_string() [1/6]

std::string Slic3r::GUI::to_string ( libvgcode::EGCodeExtrusionRole role )

static

{
    switch (role)
    {                                                              // ORCA matched terms
    case libvgcode::EGCodeExtrusionRole::None:                     { return _u8L("Unknown"); }
    case libvgcode::EGCodeExtrusionRole::Perimeter:                { return _u8L("Inner wall"); }
    case libvgcode::EGCodeExtrusionRole::ExternalPerimeter:        { return _u8L("Outer wall"); }
    case libvgcode::EGCodeExtrusionRole::OverhangPerimeter:        { return _u8L("Overhang wall"); }
    case libvgcode::EGCodeExtrusionRole::InternalInfill:           { return _u8L("Sparse infill"); }
    case libvgcode::EGCodeExtrusionRole::SolidInfill:              { return _u8L("Internal solid infill"); }
    case libvgcode::EGCodeExtrusionRole::TopSolidInfill:           { return _u8L("Top surface"); }
    case libvgcode::EGCodeExtrusionRole::Ironing:                  { return _u8L("Ironing"); }
    case libvgcode::EGCodeExtrusionRole::BridgeInfill:             { return _u8L("Bridge"); }
    case libvgcode::EGCodeExtrusionRole::GapFill:                  { return _u8L("Gap infill"); }
    case libvgcode::EGCodeExtrusionRole::Skirt:                    { return _u8L("Skirt"); }
    case libvgcode::EGCodeExtrusionRole::SupportMaterial:          { return _u8L("Support"); }
    case libvgcode::EGCodeExtrusionRole::SupportMaterialInterface: { return _u8L("Support interface"); }
    case libvgcode::EGCodeExtrusionRole::WipeTower:                { return _u8L("Prime tower"); }
    case libvgcode::EGCodeExtrusionRole::Custom:                   { return _u8L("Custom"); }
    // ORCA
    case libvgcode::EGCodeExtrusionRole::BottomSurface:            { return _u8L("Bottom surface"); }
    case libvgcode::EGCodeExtrusionRole::InternalBridgeInfill:     { return _u8L("Internal bridge"); } // ORCA
    case libvgcode::EGCodeExtrusionRole::Brim:                     { return _u8L("Brim"); }
    case libvgcode::EGCodeExtrusionRole::SupportTransition:        { return _u8L("Support transition"); }
    case libvgcode::EGCodeExtrusionRole::Mixed:                    { return _u8L("Mixed"); }
    default:                                                       { return _u8L("Unknown"); }
    }
}

References _u8L, libvgcode::BottomSurface, libvgcode::BridgeInfill, libvgcode::Brim, libvgcode::Custom, libvgcode::ExternalPerimeter, libvgcode::GapFill, libvgcode::InternalBridgeInfill, libvgcode::InternalInfill, libvgcode::Ironing, libvgcode::Mixed, libvgcode::None, libvgcode::OverhangPerimeter, libvgcode::Perimeter, libvgcode::Skirt, libvgcode::SolidInfill, libvgcode::SupportMaterial, libvgcode::SupportMaterialInterface, libvgcode::SupportTransition, libvgcode::TopSolidInfill, and libvgcode::WipeTower.

to_string() [2/6]

std::string Slic3r::GUI::to_string ( libvgcode::EMoveType type )

static

{
    switch (type)
    {
    case libvgcode::EMoveType::Noop:        { return _u8L("Noop"); }
    case libvgcode::EMoveType::Retract:     { return _u8L("Retract"); }
    case libvgcode::EMoveType::Unretract:   { return _u8L("Unretract"); }
    case libvgcode::EMoveType::Seam:        { return _u8L("Seam"); }
    case libvgcode::EMoveType::ToolChange:  { return _u8L("Tool Change"); }
    case libvgcode::EMoveType::ColorChange: { return _u8L("Color Change"); }
    case libvgcode::EMoveType::PausePrint:  { return _u8L("Pause Print"); }
    case libvgcode::EMoveType::CustomGCode: { return _u8L("Custom G-code"); }
    case libvgcode::EMoveType::Travel:      { return _u8L("Travel"); }
    case libvgcode::EMoveType::Wipe:        { return _u8L("Wipe"); }
    case libvgcode::EMoveType::Extrude:     { return _u8L("Extrude"); }
    default:                                { return _u8L("Unknown"); }
    }
}

References _u8L, libvgcode::ColorChange, libvgcode::CustomGCode, libvgcode::Extrude, libvgcode::Noop, libvgcode::PausePrint, libvgcode::Retract, libvgcode::Seam, libvgcode::ToolChange, libvgcode::Travel, libvgcode::Unretract, and libvgcode::Wipe.

Referenced by Slic3r::GUI::GLCanvas3D::_picking_pass(), Slic3r::GUI::anonymous_namespace{PluginsDialog.cpp}::build_plugin_payload_item(), Slic3r::GUI::PluginsDialog::build_plugins_payload(), Slic3r::GUI::GUI_App::check_new_version_sf(), Slic3r::GUI::Plater::import_model_id(), and Slic3r::GUI::GCodeViewer::SequentialView::Marker::render_position_window().

Here is the caller graph for this function:

to_string() [3/6]

std::string Slic3r::GUI::to_string ( PluginSortKey sort_key )

inline

    {
        switch (sort_key)
        {
        case PluginSortKey::Status: return "status";
        case PluginSortKey::Name: return "name";
        case PluginSortKey::Source: return "source";
        case PluginSortKey::Version: return "version";
        case PluginSortKey::None: return "none";
        }
 
        return "status";
    }

References Name, None, Source, Status, and Version.

to_string() [4/6]

std::string Slic3r::GUI::to_string ( PluginSortOrder sort_order )

inline

    {
        return sort_order == PluginSortOrder::Desc ? "desc" : "asc";
    }

References Desc.

to_string() [5/6]

std::string Slic3r::GUI::to_string ( PluginSource source )

inline

        {
            switch (source)
            {
            case PluginSource::Mine: return "mine";
            case PluginSource::Subscribed: return "subscribed";
            case PluginSource::Orphaned: return "orphaned";
            case PluginSource::Local: return "local";
            }
 
            return "local";
        }

References Local, Mine, Orphaned, and Subscribed.

to_string() [6/6]

std::string Slic3r::GUI::to_string ( PluginStatus status )

inline

        {
            switch (status)
            {
            case PluginStatus::Activated: return "Activated";
            case PluginStatus::Error: return "Error";
            case PluginStatus::RuntimeError: return "RuntimeError";
            case PluginStatus::Inactive: return "Inactive";
            case PluginStatus::Loading: return "Loading";
            }
 
            return "Inactive";
        }

References Activated, Error, Inactive, Loading, and RuntimeError.

to_wstring_name()

wxString Slic3r::GUI::to_wstring_name ( std::string name )

static

{
    if (name == "hardened_steel") {
        return _L("Hardened Steel");
    } else if (name == "stainless_steel") {
        return _L("Stainless Steel");
    } else if (name == "tungsten_carbide") {
        return _L("Tungsten Carbide");
    } else if (name == "brass") {
        return _L("Brass");
    }
 
    return wxEmptyString;
}

References _L.

Referenced by is_same_nozzle_type().

Here is the caller graph for this function:

touch_user_texture()

void Slic3r::GUI::touch_user_texture

(

const std::string &

path

)

{
    if (!in_user_texture_dir(path))
        return;
    const std::string        name  = boost::filesystem::path(path).filename().string();
    std::vector<std::string> names = recent_texture_names();
    names.erase(std::remove(names.begin(), names.end(), name), names.end());
    names.insert(names.begin(), name);
    store_recent_texture_names(std::move(names));
    if (g_library_scanned)
        sort_user_textures(g_library);
}

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::set_layer_texture().

Here is the caller graph for this function:

trace_autoedit()

void Slic3r::GUI::trace_autoedit ( const char * why, size_t n )

static

{
    if (!std::getenv("ORCA_CAD_UXTRACE")) return;
    fprintf(stderr, "[UX] autoedit %s steps=%zu\n", why, n);
    fflush(stderr);
}

References trace_autoedit().

Referenced by Slic3r::GUI::DesignSketchTool::open_primary_autoedit(), Slic3r::GUI::DesignSketchTool::render(), and trace_autoedit().

Here is the call graph for this function:

Here is the caller graph for this function:

translate_entity()

void Slic3r::GUI::translate_entity ( SketchEntity & e, const Vec2d & d )

static

{
    e.p0 += d;
    e.p1 += d;
    e.center += d;
    for (auto& cp : e.ctrl) cp += d;     // BSpline poles
}

References Slic3r::SketchEntity::center, Slic3r::SketchEntity::ctrl, Slic3r::SketchEntity::p0, Slic3r::SketchEntity::p1, and translate_entity().

Referenced by Slic3r::GUI::DesignSketchTool::apply_dimension(), and translate_entity().

Here is the call graph for this function:

Here is the caller graph for this function:

tri_barycentric()

void Slic3r::GUI::tri_barycentric	(	TriPoint	p,
		TriPoint	v0,
		TriPoint	v1,
		TriPoint	v2,
		double &	w0,
		double &	w1,
		double &	w2 )

{
    double total = std::abs(tri_signed_area2(v0, v1, v2));
    if (total < 1e-9) { w0 = w1 = w2 = 1.0 / 3.0; return; }
    w0 = std::abs(tri_signed_area2(p, v1, v2)) / total;
    w1 = std::abs(tri_signed_area2(v0, p, v2)) / total;
    w2 = 1.0 - w0 - w1;
    w0 = std::clamp(w0, 0.0, 1.0);
    w1 = std::clamp(w1, 0.0, 1.0);
    w2 = std::clamp(w2, 0.0, 1.0);
    double s = w0 + w1 + w2;
    if (s > 0) { w0 /= s; w1 /= s; w2 /= s; }
}

References tri_signed_area2().

Referenced by Slic3r::GUI::MixedFilamentDialog::create_triangle_picker(), draw_mixed_triangle_picker(), and tri_clamp().

Here is the call graph for this function:

Here is the caller graph for this function:

tri_clamp()

TriPoint Slic3r::GUI::tri_clamp	(	TriPoint	p,
		TriPoint	v0,
		TriPoint	v1,
		TriPoint	v2 )

{
    double w0, w1, w2;
    tri_barycentric(p, v0, v1, v2, w0, w1, w2);
    return {w0 * v0.x + w1 * v1.x + w2 * v2.x,
            w0 * v0.y + w1 * v1.y + w2 * v2.y};
}

References tri_barycentric(), Slic3r::GUI::TriPoint::x, and Slic3r::GUI::TriPoint::y.

Referenced by Slic3r::GUI::MixedFilamentDialog::create_triangle_picker().

Here is the call graph for this function:

Here is the caller graph for this function:

tri_contains()

bool Slic3r::GUI::tri_contains	(	TriPoint	p,
		TriPoint	v0,
		TriPoint	v1,
		TriPoint	v2 )

{
    double total = tri_signed_area2(v0, v1, v2);
    if (std::abs(total) < 1e-9) return false;
    double s0 = tri_signed_area2(p, v1, v2) / total;
    double s1 = tri_signed_area2(v0, p, v2) / total;
    double s2 = 1.0 - s0 - s1;
    return s0 >= -0.001 && s1 >= -0.001 && s2 >= -0.001;
}

References tri_signed_area2().

Referenced by Slic3r::GUI::MixedFilamentDialog::create_triangle_picker(), and draw_mixed_triangle_picker().

Here is the call graph for this function:

Here is the caller graph for this function:

tri_signed_area2()

double Slic3r::GUI::tri_signed_area2	(	TriPoint	a,
		TriPoint	b,
		TriPoint	c )

{
    return (b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y);
}

References Slic3r::GUI::TriPoint::x, and Slic3r::GUI::TriPoint::y.

Referenced by tri_barycentric(), and tri_contains().

Here is the caller graph for this function:

try_pop_up_before_slice()

bool Slic3r::GUI::try_pop_up_before_slice	(	bool	is_slice_all,
		Plater *	plater_ref,
		PartPlate *	partplate_ref,
		bool	force_pop_up = false )

Try to pop up the filament map dialog before slicing.

Only pop up in multi extruder machines. If user don't want the pop up, we pop up if the applied filament map mode in manual

Parameters

is_slice_all	In slice all
plater_ref	Plater to get/set global filament map
partplate_ref	Partplate to get/set plate filament map mode

Returns

whether continue slicing

{
    auto full_config = wxGetApp().preset_bundle->full_config();
    const auto nozzle_diameters = full_config.option<ConfigOptionFloats>("nozzle_diameter");
    if (nozzle_diameters->size() <= 1)
        return true;
 
    // The filament-grouping dialog is specifically designed for BBL dual-nozzle printers
    // (e.g. H2D) where filaments must be assigned to a left or right nozzle.
    // For toolchangers (≥3 tools) and all non-BBL printers the dialog is irrelevant and
    // confusing; skip it entirely so slicing proceeds without interruption. (#12390)
    PresetBundle* preset = wxGetApp().preset_bundle;
    if (!preset || !preset->is_bbl_vendor() || nozzle_diameters->size() != 2)
        return true;
 
    bool sync_plate = true;
 
    std::vector<std::string> filament_colors = full_config.option<ConfigOptionStrings>("filament_colour")->values;
    std::vector<std::string> filament_types = full_config.option<ConfigOptionStrings>("filament_type")->values;
    FilamentMapMode applied_mode = get_applied_map_mode(full_config, plater_ref,partplate_ref, sync_plate);
    std::vector<int> applied_maps = get_applied_map(full_config, plater_ref, partplate_ref, sync_plate);
    std::vector<int> applied_volume_maps = get_applied_volume_map(full_config, plater_ref, partplate_ref, sync_plate);
    applied_maps.resize(filament_colors.size(), 1);
    applied_volume_maps.resize(filament_colors.size(), 0);
 
    if (!force_pop_up && applied_mode != fmmManual)
        return true;
 
    std::vector<int> filament_lists;
    if (is_slice_all) {
        filament_lists.resize(filament_colors.size());
        std::iota(filament_lists.begin(), filament_lists.end(), 1);
    }
    else {
        filament_lists = partplate_ref->get_extruders();
    }
 
    FilamentMapDialog map_dlg(plater_ref,
        filament_colors,
        filament_types,
        applied_maps,
        applied_volume_maps,
        filament_lists,
        applied_mode,
        plater_ref->get_machine_sync_status(),
        false,
        false
    );
    auto ret = map_dlg.ShowModal();
 
    if (ret == wxID_OK) {
        FilamentMapMode new_mode = map_dlg.get_mode();
        std::vector<int> new_maps = map_dlg.get_filament_maps();
        std::vector<int> new_volume_maps = map_dlg.get_filament_volume_maps();
        if (sync_plate) {
            if (is_slice_all) {
                auto plate_list = plater_ref->get_partplate_list().get_plate_list();
                for (int i = 0; i < plate_list.size(); ++i) {
                    plate_list[i]->set_filament_map_mode(new_mode);
                    if (new_mode == fmmManual) {
                        plate_list[i]->set_filament_maps(new_maps);
                        plate_list[i]->set_filament_volume_maps(new_volume_maps);
                    }
                }
            }
            else {
                partplate_ref->set_filament_map_mode(new_mode);
                if (new_mode == fmmManual) {
                    partplate_ref->set_filament_maps(new_maps);
                    partplate_ref->set_filament_volume_maps(new_volume_maps);
                }
            }
        }
        else {
            plater_ref->set_global_filament_map_mode(new_mode);
            if (new_mode == fmmManual) {
                plater_ref->set_global_filament_map(new_maps);
                plater_ref->set_global_filament_volume_map(new_volume_maps);
            }
        }
        plater_ref->update();
        // check whether able to slice, if not, return false
        if (!get_left_extruder_unprintable_text().empty() || !get_right_extruder_unprintable_text().empty()){
            return false;
        }
        return true;
    }
    return false;
}

References Slic3r::empty(), filament_types, Slic3r::fmmManual, get_applied_map(), get_applied_map_mode(), get_applied_volume_map(), Slic3r::GUI::PartPlate::get_extruders(), Slic3r::GUI::FilamentMapDialog::get_filament_maps(), Slic3r::GUI::FilamentMapDialog::get_filament_volume_maps(), get_left_extruder_unprintable_text(), Slic3r::GUI::Plater::get_machine_sync_status(), Slic3r::GUI::FilamentMapDialog::get_mode(), Slic3r::GUI::Plater::get_partplate_list(), Slic3r::GUI::PartPlateList::get_plate_list(), get_right_extruder_unprintable_text(), Slic3r::PresetBundle::is_bbl_vendor(), Slic3r::GUI::PartPlate::set_filament_map_mode(), Slic3r::GUI::PartPlate::set_filament_maps(), Slic3r::GUI::PartPlate::set_filament_volume_maps(), Slic3r::GUI::Plater::set_global_filament_map(), Slic3r::GUI::Plater::set_global_filament_map_mode(), Slic3r::GUI::Plater::set_global_filament_volume_map(), Slic3r::GUI::FilamentMapDialog::ShowModal(), and Slic3r::GUI::Plater::update().

Referenced by Slic3r::GUI::GLCanvas3D::_set_warning_notification(), Slic3r::GUI::NotificationManager::bbl_show_filament_map_invalid_notification_before_slice(), and Slic3r::GUI::MainFrame::create_side_tools().

Here is the call graph for this function:

Here is the caller graph for this function:

tryPopUpMultiNozzleDialog()

std::optional< NozzleOption > Slic3r::GUI::tryPopUpMultiNozzleDialog

(

MachineObject *

obj

)

{
    if (!obj)
        return std::nullopt;
    auto rack = obj->GetNozzleSystem()->GetNozzleRack();
    if (!rack || !rack->IsSupported())
        return std::nullopt;
    MultiNozzleSyncDialog dialog(wxGetApp().plater_,rack);
 
    bool has_unreliable = rack->HasUnreliableNozzles();
    bool has_unknown = rack->HasUnknownNozzles();
 
    auto config = wxGetApp().preset_bundle->printers.get_edited_preset().config;
 
    if (dialog.ShowModal() == wxID_OK) {
        auto selected_option = dialog.GetSelectedOption();
        if (!selected_option)
            return std::nullopt;
        auto& preset_bundle = GUI::wxGetApp().preset_bundle;
        auto& project_config = preset_bundle->project_config;
 
        ConfigOptionEnumsGeneric* nozzle_volume_type_opt = project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
 
        // write to preset bundle config
        for (int extruder_id = 0; extruder_id < 2; ++extruder_id) {
            NozzleVolumeType volume_type;
            int nozzle_count;
            bool clear_all = true;
            if (!selected_option->extruder_nozzle_stats.count(extruder_id)) {
                nozzle_count = 0;
                // Reset the concrete volume types (Standard/High Flow); Hybrid is a mix marker, never a stats key.
                // TPU High Flow is a concrete variant that exists only on 0.4/0.6 nozzles, so reset it too, but
                // only there (same guard that skips High Flow on 0.2).
                std::vector<NozzleVolumeType> reset_types{nvtStandard, nvtHighFlow};
                if (extruder_supports_tpu_high_flow(preset_bundle, extruder_id))
                    reset_types.push_back(nvtTPUHighFlow);
                for (NozzleVolumeType vt : reset_types) {
                    volume_type = vt;
                    setExtruderNozzleCount(preset_bundle, extruder_id, volume_type, nozzle_count, clear_all);
                    clear_all = false;
                }
            }
            else {
                for (auto& stat : selected_option->extruder_nozzle_stats[extruder_id]) {
                    volume_type = stat.first;
                    nozzle_count = stat.second;
                    setExtruderNozzleCount(preset_bundle, extruder_id, volume_type, nozzle_count, clear_all);
                    clear_all = false;
                }
            }
        }
        // The stats now hold the device's per-type breakdown: protect it from being collapsed by a manual
        // flow switch, and refresh the sidebar badges.
        setNozzleStatsFromMachine(true);
        if (nozzle_volume_type_opt) {
            for (int extruder_id = 0; extruder_id < 2 && extruder_id < (int) nozzle_volume_type_opt->values.size(); ++extruder_id)
                updateNozzleCountDisplay(preset_bundle, extruder_id, NozzleVolumeType(nozzle_volume_type_opt->values[extruder_id]));
        }
        return selected_option;
    }
 
    return std::nullopt;
}

References extruder_supports_tpu_high_flow(), Slic3r::DevNozzleSystem::GetNozzleRack(), Slic3r::MachineObject::GetNozzleSystem(), Slic3r::GUI::MultiNozzleSyncDialog::GetSelectedOption(), Slic3r::nvtHighFlow, Slic3r::nvtStandard, Slic3r::nvtTPUHighFlow, setExtruderNozzleCount(), setNozzleStatsFromMachine(), Slic3r::GUI::MultiNozzleSyncDialog::ShowModal(), tryPopUpMultiNozzleDialog(), updateNozzleCountDisplay(), and Slic3r::ConfigOptionVector< int >::values.

Referenced by Slic3r::GUI::Sidebar::priv::get_nozzle_options(), and tryPopUpMultiNozzleDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

two_col_form()

wxFlexGridSizer * Slic3r::GUI::two_col_form ( )

static

{
    auto* f = new wxFlexGridSizer(2, 6, 8);
    f->AddGrowableCol(1, 1);
    f->SetFlexibleDirection(wxHORIZONTAL);
    return f;
}

References Slic3r::f().

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

Here is the call graph for this function:

Here is the caller graph for this function:

unbind_events()

void Slic3r::GUI::unbind_events ( wxEvtHandler * h )

static

{
    static_cast<myEvtHandler *>(h)->UnbindAll();
}

Referenced by free_window().

Here is the caller graph for this function:

update_all_extruder_variants()

void Slic3r::GUI::update_all_extruder_variants ( int extruder_idx = -1 )

static

{
    for (auto tab : wxGetApp().tabs_list)
        tab->update_extruder_variants(extruder_idx);
    if (auto tab = wxGetApp().plate_tab)
        tab->update_extruder_variants(extruder_idx);
    for (auto tab : wxGetApp().model_tabs_list)
        tab->update_extruder_variants(extruder_idx);
}

References update_all_extruder_variants().

Referenced by Slic3r::GUI::TabPrinter::build_unregular_pages(), Slic3r::GUI::Tab::on_value_change(), Slic3r::GUI::TabPrinter::sync_extruders_count(), and update_all_extruder_variants().

Here is the call graph for this function:

Here is the caller graph for this function:

update_children()

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_custom_filaments()

wxString Slic3r::GUI::update_custom_filaments ( )

static

{
    json m_Res                                                                     = json::object();
    m_Res["command"]                                                               = "update_custom_filaments";
    m_Res["sequence_id"]                                                           = "2000";
    json                                               m_CustomFilaments           = json::array();
    PresetBundle *                                     preset_bundle               = wxGetApp().preset_bundle;
    std::map<std::string, std::vector<Preset const *>> temp_filament_id_to_presets = preset_bundle->filaments.get_filament_presets();
 
    std::vector<std::pair<std::string, std::string>>   need_sort;
    bool                                             need_delete_some_filament = false;
    for (std::pair<std::string, std::vector<Preset const *>> filament_id_to_presets : temp_filament_id_to_presets) {
        std::string filament_id = filament_id_to_presets.first;
        if (filament_id.empty()) continue;
        if (filament_id == "null") {
            need_delete_some_filament = true;
        }
        bool filament_with_base_id = false;
        bool not_need_show = false;
        std::string filament_name;
        for (const Preset *preset : filament_id_to_presets.second) {
            if (preset->is_system || preset->is_project_embedded) {
                not_need_show = true;
                break;
            }
            if (preset->inherits() != "") continue;
            if (!preset->base_id.empty()) filament_with_base_id = true;
 
            if (!not_need_show) {
                auto filament_vendor = dynamic_cast<ConfigOptionStrings *>(const_cast<Preset *>(preset)->config.option("filament_vendor", false));
                if (filament_vendor && filament_vendor->values.size() && filament_vendor->values[0] == "Generic") not_need_show = true;
            }
 
            if (filament_name.empty()) {
                std::string preset_name = preset->name;
                size_t      index_at    = preset_name.find(" @");
                if (std::string::npos != index_at) { preset_name = preset_name.substr(0, index_at); }
                filament_name = preset_name;
            }
        }
        if (not_need_show) continue;
        if (!filament_name.empty()) {
            if (filament_with_base_id) {
                need_sort.push_back(std::make_pair(into_u8(_L("[Action Required] ")) + filament_name, filament_id));
            } else {
 
                need_sort.push_back(std::make_pair(filament_name, filament_id));
            }
        }
    }
    std::sort(need_sort.begin(), need_sort.end(), [](const std::pair<std::string, std::string> &a, const std::pair<std::string, std::string> &b) { return a.first < b.first; });
    if (need_delete_some_filament) {
        need_sort.push_back(std::make_pair(into_u8(_L("[Action Required]")), "null"));
    }
    json temp_j;
    for (std::pair<std::string, std::string> &filament_name_to_id : need_sort) {
        temp_j["name"] = filament_name_to_id.first;
        temp_j["id"]   = filament_name_to_id.second;
        m_CustomFilaments.push_back(temp_j);
    }
    m_Res["data"]  = m_CustomFilaments;
    wxString strJS = wxString::Format("HandleStudio(%s)", wxString::FromUTF8(m_Res.dump(-1, ' ', false, json::error_handler_t::ignore)));
    return strJS;
}

References _L, Slic3r::Preset::base_id, Slic3r::Preset::config, Slic3r::filament_vendor(), Slic3r::PresetBundle::filaments, Slic3r::PresetCollection::get_filament_presets(), Slic3r::Preset::inherits(), into_u8(), Slic3r::Preset::is_project_embedded, Slic3r::Preset::is_system, Slic3r::Preset::name, and Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::GuideFrame::OnScriptMessage().

Here is the call graph for this function:

Here is the caller graph for this function:

update_dark_children_ui()

void Slic3r::GUI::update_dark_children_ui ( wxWindow * window, bool just_buttons_update = false )

static

{
    /*bool is_btn = dynamic_cast<wxButton*>(window) != nullptr;
    is_btn = false;*/
    if (!window) return;
 
    if (ScalableButton* btn = dynamic_cast<ScalableButton*>(window)) {
        btn->UpdateDarkUI();
    } else {
        wxGetApp().UpdateDarkUI(window);
    }
 
    auto children = window->GetChildren();
    for (auto child : children) {
        update_dark_children_ui(child);
    }
}

References update_dark_children_ui().

Referenced by update_dark_children_ui(), Slic3r::GUI::GUI_App::update_ui_from_settings(), Slic3r::GUI::GUI_App::UpdateDarkUIWin(), Slic3r::GUI::GUI_App::UpdateDlgDarkUI(), and Slic3r::GUI::GUI_App::UpdateFrameDarkUI().

Here is the call graph for this function:

Here is the caller graph for this function:

update_dark_config()

void Slic3r::GUI::update_dark_config

(

)

{
    wxSystemAppearance app = wxSystemSettings::GetAppearance();
    GUI::wxGetApp().app_config->set("dark_color_mode", app.IsDark() ? "1" : "0");
    wxGetApp().Update_dark_mode_flag();
}

Referenced by Slic3r::GUI::DPIAware< wxFrame >::DPIAware().

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()

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()

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->GetObject(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::GetObject(), Slic3r::GUI::ObjectDataViewModel::GetParent(), itInstance, itInstanceRoot, itObject, Slic3r::GUI::ObjectList::smInstance, and update_selection().

Referenced by Slic3r::GUI::ObjectList::remove(), Slic3r::GUI::CalibrateFilamentComboBox::update(), and update_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

update_speed_parameter()

void Slic3r::GUI::update_speed_parameter

(

const std::string &

key

)

{
    auto preset_bundle   = wxGetApp().preset_bundle;
    auto& printer_config  = preset_bundle->printers.get_edited_preset().config;
    auto& filament_config = preset_bundle->filaments.get_edited_preset().config;
    auto& print_config    = preset_bundle->prints.get_edited_preset().config;
 
    int extruder_nums = preset_bundle->get_printer_extruder_count();
    std::vector<int> extruder_types      = printer_config.option<ConfigOptionEnumsGeneric>("extruder_type")->values;
    std::vector<int> nozzle_volume_types = preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type")->values;
 
    float nozzle_diameter = printer_config.option<ConfigOptionFloats>("nozzle_diameter")->values[0];
    float layer_height = print_config.option<ConfigOptionFloat>("layer_height")->value;
    float line_width = print_config.get_abs_value("line_width", nozzle_diameter);
    if (line_width <= 0.) line_width = Flow::auto_extrusion_width(frPerimeter, nozzle_diameter);
 
    Flow flow = Flow(line_width, layer_height, nozzle_diameter);
 
    for (size_t i = 0; i < extruder_nums; ++i) {
        int index = get_index_for_extruder_parameter(filament_config, "filament_max_volumetric_speed", i, ExtruderType(extruder_types[i]), NozzleVolumeType(nozzle_volume_types[i]));
        double filament_max_volumetric_speed = filament_config.option<ConfigOptionFloats>("filament_max_volumetric_speed")->get_at(index);
        double max_speed = filament_max_volumetric_speed / flow.mm3_per_mm();
 
        index = get_index_for_extruder_parameter(print_config, key, i, ExtruderType(extruder_types[i]), NozzleVolumeType(nozzle_volume_types[i]));
        ConfigOptionFloatsNullable *speed_opt = print_config.option<ConfigOptionFloatsNullable>(key);
        speed_opt->values[index] = max_speed;
    }
}

References Slic3r::Flow::auto_extrusion_width(), Slic3r::frPerimeter, Slic3r::get_index_for_extruder_parameter(), layer_height, Slic3r::Flow::mm3_per_mm(), Slic3r::nozzle_diameter(), printer_config(), and Slic3r::ConfigOptionVector< double >::values.

Referenced by Slic3r::GUI::Plater::_calib_pa_tower().

Here is the call graph for this function:

Here is the caller graph for this function:

updateNozzleCountDisplay()

void Slic3r::GUI::updateNozzleCountDisplay	(	PresetBundle *	preset_bundle,
		int	extruder_id,
		NozzleVolumeType	volume_type )

{
    auto *plater = wxGetApp().plater();
    if (!preset_bundle || !plater)
        return;
 
    auto *max_nozzle_count = preset_bundle->printers.get_edited_preset().config.option<ConfigOptionIntsNullable>("extruder_max_nozzle_count");
    // Skip nil entries: a nullable-int nil is INT_MAX (> 1) and would otherwise falsely pass the gate.
    const bool support_multi_nozzle = max_nozzle_count &&
        std::any_of(max_nozzle_count->values.begin(), max_nozzle_count->values.end(),
                    [](int v) { return v > 1 && v != ConfigOptionIntsNullable::nil_value(); });
 
    int display_count = -1; // hides the badge
    if (support_multi_nozzle)
        display_count = volume_type == nvtHybrid ? getExtruderNozzleCountTotal(preset_bundle, extruder_id)
                                                 : getExtruderNozzleCount(preset_bundle, extruder_id, volume_type);
    plater->sidebar().set_extruder_nozzle_count(extruder_id, display_count);
}

References Slic3r::Preset::config, Slic3r::PresetCollection::get_edited_preset(), getExtruderNozzleCount(), getExtruderNozzleCountTotal(), Slic3r::nvtHybrid, Slic3r::ConfigBase::option(), plater(), and Slic3r::PresetBundle::printers.

Referenced by Slic3r::GUI::Sidebar::priv::get_nozzle_options(), Slic3r::GUI::Plater::priv::load_files(), manuallySetNozzleCount(), Slic3r::GUI::TabPrinter::on_preset_loaded(), Slic3r::GUI::TabPrinter::set_extruder_volume_type(), and tryPopUpMultiNozzleDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdatePositionAlignment()

void Slic3r::GUI::UpdatePositionAlignment ( wxWindow * w, wxPoint base_position, bool align_right )

inlinestatic

                                                                                                 {
    if (!align_right) {
        base_position.x -= w->GetSize().x;
    }
    w->SetPosition(base_position);
}

Referenced by Slic3r::GUI::FinishSyncAmsDialog::Layout(), Slic3r::GUI::SyncNozzleAndAmsDialog::Layout(), Slic3r::GUI::FinishSyncAmsDialog::update_info(), and Slic3r::GUI::SyncNozzleAndAmsDialog::update_info().

Here is the caller graph for this function:

url_encode() [1/3]

std::string Slic3r::GUI::url_encode ( const std::string & value )

static

                                                    {
    std::ostringstream escaped;
    escaped.fill('0');
    escaped << std::hex;
    for (std::string::const_iterator i = value.begin(), n = value.end(); i != n; ++i) {
        std::string::value_type c = (*i);
 
        // Keep alphanumeric and other accepted characters intact
        if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') {
            escaped << c;
            continue;
        }
 
        // Any other characters are percent-encoded
        escaped << std::uppercase;
        escaped << '%' << std::setw(2) << int((unsigned char)c);
        escaped << std::nouppercase;
    }
    return escaped.str();
}

Referenced by Slic3r::GUI::PrivacyUpdateDialog::ShowReleaseNote(), Slic3r::GUI::UpdateVersionDialog::ShowReleaseNote(), and Slic3r::GUI::MarkdownTip::ShowTip().

Here is the caller graph for this function:

url_encode() [2/3]

std::string Slic3r::GUI::url_encode ( const std::string & value )

static

                                                    {
  std::ostringstream escaped;
  escaped.fill('0');
  escaped << std::hex;
  for (std::string::const_iterator i = value.begin(), n = value.end(); i != n; ++i) {
    std::string::value_type c = (*i);
 
    // Keep alphanumeric and other accepted characters intact
    if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') {
      escaped << c;
      continue;
    }
 
    // Any other characters are percent-encoded
    escaped << std::uppercase;
    escaped << '%' << std::setw(2) << int((unsigned char)c);
    escaped << std::nouppercase;
  }
  return escaped.str();
}

url_encode() [3/3]

std::string Slic3r::GUI::url_encode ( const std::string & value )

static

                                                    {
  std::ostringstream escaped;
  escaped.fill('0');
  escaped << std::hex;
  for (std::string::const_iterator i = value.begin(), n = value.end(); i != n; ++i) {
    std::string::value_type c = (*i);
 
    // Keep alphanumeric and other accepted characters intact
    if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') {
      escaped << c;
      continue;
    }
 
    // Any other characters are percent-encoded
    escaped << std::uppercase;
    escaped << '%' << std::setw(2) << int((unsigned char)c);
    escaped << std::nouppercase;
  }
  return escaped.str();
}

url_get_param()

std::string Slic3r::GUI::url_get_param	(	const std::string &	url,
		const std::string &	key )

{
    size_t start = url.find(key);
    if (start == std::string::npos) return "";
    size_t eq = url.find('=', start);
    if (eq == std::string::npos) return "";
    std::string key_str = url.substr(start, eq - start);
    if (key_str != key)
        return "";
    start += key.size() + 1;
    size_t end = url.find('&', start);
    if (end == std::string::npos) end = url.length(); // Last param
    std::string result = url.substr(start, end - start);
    return result;
}

Referenced by Slic3r::GUI::HttpServer::auth_handle_request(), and Slic3r::GUI::OAuthJob::process().

Here is the caller graph for this function:

use_nozzle_row_font()

void Slic3r::GUI::use_nozzle_row_font ( ComboBox * combo )

static

{
    // A read-only combo draws its value with the font of the TextInput it is built on, and its
    // dropped list carries a font of its own.
    combo->SetFont(Label::Body_13);
    combo->GetDropDown().SetFont(Label::Body_13);
 
    // A row is as tall as the tags of the variant switch: a line of Body_10 text plus the 3 points of
    // padding they put above and below it. TextInput::messureSize() instead sizes a combo as its
    // (hidden) text control plus 8, and on macOS that control's best height is a fixed 16 points
    // whatever font it carries, so the box would keep the height of the Body_14 it was created with.
    // Handing the control the height the row asks for, less those 8 points, keeps messureSize()'s own
    // arithmetic landing on the small box however often it re-measures.
    const int row_height = combo->GetTextExtent("0.4 mm").y + 2 * combo->FromDIP(3);
    auto *text_ctrl = combo->GetTextCtrl();
    text_ctrl->SetFont(Label::Body_13);
    text_ctrl->SetInitialSize(wxSize(text_ctrl->GetBestSize().x, row_height - 8));
 
    combo->SetMinSize(wxSize(combo->GetMinSize().x, row_height));
    combo->SetSize(wxSize(combo->GetSize().x, row_height));
}

References Label::Body_13, ComboBox::GetDropDown(), and ComboBox::SetFont().

Referenced by Slic3r::GUI::ExtruderGroup::ExtruderGroup(), and Slic3r::GUI::ExtruderGroup::create_nozzle_row().

Here is the call graph for this function:

Here is the caller graph for this function:

user_texture_dir()

std::string Slic3r::GUI::user_texture_dir

(

)

{
    const boost::filesystem::path dir = boost::filesystem::path(Slic3r::data_dir()) / "textures" / "displacement";
    boost::system::error_code     ec;
    boost::filesystem::create_directories(dir, ec);
    if (ec) {
        BOOST_LOG_TRIVIAL(error) << "Could not create the user texture directory " << dir.string() << ": " << ec.message();
        return {};
    }
    return dir.string();
}

References Slic3r::data_dir().

Referenced by Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::in_user_texture_dir(), texture_library(), and Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::write_user_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

utf8_offset()

size_t Slic3r::GUI::utf8_offset ( const std::string & str, size_t count )

static

{
    const char* const begin = str.c_str();
    const char* const end   = begin + str.size();
    const char*       pos   = begin;
    for (size_t i = 0; i < count && pos < end; ++i) {
        unsigned int codepoint = 0;
        pos += ImTextCharFromUtf8(&codepoint, pos, end);
    }
    return pos - begin;
}

References count.

Referenced by Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::render().

Here is the caller graph for this function:

validate_custom_gcode_cb() [1/2]

void Slic3r::GUI::validate_custom_gcode_cb ( Tab * tab, ConfigOptionsGroupShp opt_group, const t_config_option_key & opt_key, const boost::any & value )

static

                                                                                                                                           {
    tab->validate_custom_gcodes_was_shown = !Tab::validate_custom_gcode(opt_group->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::OptionsGroup::title, Slic3r::GUI::Tab::update_dirty(), Slic3r::GUI::Tab::validate_custom_gcode(), and Slic3r::GUI::Tab::validate_custom_gcodes_was_shown.

Here is the call graph for this function:

validate_custom_gcode_cb() [2/2]

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(), Slic3r::GUI::Tab::validate_custom_gcode(), and Slic3r::GUI::Tab::validate_custom_gcodes_was_shown.

Referenced by Slic3r::GUI::TabFilament::build(), Slic3r::GUI::TabPrint::build(), and Slic3r::GUI::TabPrinter::build_fff().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_thumbnails_string()

ThumbnailErrors Slic3r::GUI::validate_thumbnails_string	(	wxString &	str,
		const wxString &	def_ext = "PNG" )

{
    std::string input_string = into_u8(str);
 
    str.Clear();
 
    auto [thumbnails_list, errors] = GCodeThumbnails::make_and_check_thumbnail_list(input_string);
    if (!thumbnails_list.empty()) {
        const auto& extentions = ConfigOptionEnum<GCodeThumbnailsFormat>::get_enum_names();
        for (const auto& [format, size] : thumbnails_list)
            str += format_wxstr("%1%x%2%/%3%, ", size.x(), size.y(), extentions[int(format)]);
        str.resize(str.Len() - 2);
    }
 
    return errors;
}

References format(), format_wxstr(), Slic3r::ConfigOptionEnum< T >::get_enum_names(), into_u8(), and Slic3r::GCodeThumbnails::make_and_check_thumbnail_list().

Referenced by Slic3r::GUI::Field::get_value_by_opt_type().

Here is the call graph for this function:

Here is the caller graph for this function:

variant_keys()

std::vector< std::string > Slic3r::GUI::variant_keys ( DynamicPrintConfig const & config )

static

{
    std::vector<std::string> t;
    for (const std::string &opt_key : config.keys()) {
        auto opt = config.option(opt_key);
        if (opt->type() & coVectorType) {
            auto vec = dynamic_cast<ConfigOptionVectorBase const *>(opt);
            for (size_t i = 0; i < vec->size(); i++)
                if (!vec->is_nil(i))
                    t.push_back(opt_key + "#" + std::to_string(i));
        } else {
            t.push_back(opt_key);
        }
    }
    return t;
}

References Slic3r::coVectorType, Slic3r::DynamicConfig::keys(), and Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::Tab::check_extruder_options_status(), Slic3r::GUI::Tab::switch_excluder(), Slic3r::GUI::Tab::sync_excluder(), Slic3r::GUI::Tab::update_all_extruder_options_status(), and Slic3r::GUI::TabPrintModel::update_model_config().

Here is the call graph for this function:

Here is the caller graph for this function:

verify_instances_rotation_synchronized()

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 &rotation0 = volumes[idx_volume_first]->get_instance_transformation().get_matrix();
        for (int i = idx_volume_first + 1; i < (int)volumes.size(); ++i)
            if (volumes[i]->object_idx() == idx_object) {
                const Transform3d &rotation = volumes[i]->get_instance_transformation().get_matrix();
                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:

version_greater_or_equal_to()

bool Slic3r::GUI::version_greater_or_equal_to ( const std::string & version, unsigned int major, unsigned int minor )

static

{
    if (version == "N/A")
        return false;
 
    std::vector<std::string> tokens;
    boost::split(tokens, version, boost::is_any_of(" "), boost::token_compress_on);
 
    if (tokens.empty())
        return false;
 
    std::vector<std::string> numbers;
    boost::split(numbers, tokens[0], boost::is_any_of("."), boost::token_compress_on);
 
    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());
 
    if (gl_major < major)
        return false;
    else if (gl_major > major)
        return true;
    else
        return gl_minor >= minor;
}

Referenced by Slic3r::GUI::OpenGLManager::GLInfo::is_glsl_version_greater_or_equal_to(), and Slic3r::GUI::OpenGLManager::GLInfo::is_version_greater_or_equal_to().

Here is the caller graph for this function:

view_type_config_map()

const std::vector< std::pair< std::string, libvgcode::EViewType > > & Slic3r::GUI::view_type_config_map ( )

static

{
    static const std::vector<std::pair<std::string, libvgcode::EViewType>> map = {
        { "summary",                      libvgcode::EViewType::Summary },
        { "feature_type",                 libvgcode::EViewType::FeatureType },
        { "color_print",                  libvgcode::EViewType::ColorPrint },
        { "speed",                        libvgcode::EViewType::Speed },
        { "actual_speed",                 libvgcode::EViewType::ActualSpeed },
        { "acceleration",                 libvgcode::EViewType::Acceleration },
        { "jerk",                         libvgcode::EViewType::Jerk },
        { "height",                       libvgcode::EViewType::Height },
        { "width",                        libvgcode::EViewType::Width },
        { "volumetric_flow_rate",         libvgcode::EViewType::VolumetricFlowRate },
        { "actual_volumetric_flow_rate",  libvgcode::EViewType::ActualVolumetricFlowRate },
        { "layer_time_linear",            libvgcode::EViewType::LayerTimeLinear },
        { "layer_time_logarithmic",       libvgcode::EViewType::LayerTimeLogarithmic },
        { "fan_speed",                    libvgcode::EViewType::FanSpeed },
        { "temperature",                  libvgcode::EViewType::Temperature },
        { "pressure_advance",             libvgcode::EViewType::PressureAdvance },
    };
    return map;
}

References libvgcode::Acceleration, libvgcode::ActualSpeed, libvgcode::ActualVolumetricFlowRate, libvgcode::ColorPrint, libvgcode::FanSpeed, libvgcode::FeatureType, libvgcode::Height, libvgcode::Jerk, libvgcode::LayerTimeLinear, libvgcode::LayerTimeLogarithmic, libvgcode::PressureAdvance, libvgcode::Speed, libvgcode::Summary, libvgcode::Temperature, libvgcode::VolumetricFlowRate, and libvgcode::Width.

Referenced by Slic3r::GUI::GCodeViewer::default_view_type_choices(), Slic3r::GUI::GCodeViewer::view_type_from_config_name(), and Slic3r::GUI::GCodeViewer::view_type_to_config_name().

Here is the caller graph for this function:

warning_catcher()

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

{
  MessageDialog msg(parent, message, _L("Warning"), wxOK | wxICON_WARNING);
  msg.ShowModal();
}

References _L, and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by Slic3r::GUI::Plater::priv::split_object().

Here is the call graph for this function:

Here is the caller graph for this function:

WKWebView_evaluateJavaScript()

void Slic3r::GUI::WKWebView_evaluateJavaScript	(	void *	web,
		wxString const &	script,
		void(*	callback )(wxString const &) )

{
    [(WKWebView*)web evaluateJavaScript:wxCFStringRef(script).AsNSString() completionHandler: ^(id result, NSError *error) {
        if (callback && error != nil) {
            wxString err = wxCFStringRef(error.localizedFailureReason).AsString();
            callback(err);
        }
    }];
}

Referenced by WebView::RunScript().

Here is the caller graph for this function:

WKWebView_force_display()

void Slic3r::GUI::WKWebView_force_display

(

void *

web

)

{
    WKWebView * webView = (WKWebView*)web;
    if (!webView)
        return;
    [webView setNeedsLayout:YES];
    [webView setNeedsDisplay:YES];
    [[webView layer] setNeedsDisplay];
}

Referenced by Slic3r::GUI::ColorPickerDialog::repaint_webview(), and Slic3r::GUI::SpeedDialWebDialog::repaint_webview().

Here is the caller graph for this function:

WKWebView_setTransparentBackground()

void Slic3r::GUI::WKWebView_setTransparentBackground

(

void *

web

)

{
    WKWebView * webView = (WKWebView*)web;
    [webView layer].backgroundColor = [NSColor clearColor].CGColor;
    [webView registerForDraggedTypes: @[NSFilenamesPboardType]];
}

Referenced by WebView::CreateWebView().

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<EmbossShape> &es = mv->emboss_shape;
    if (!es.has_value())
        return res;
 
    const std::optional<Transform3d> &fix = es->fix_3mf_tr;
    if (!fix.has_value())
        return res;
 
    return res * fix->inverse();
}

References Slic3r::ModelVolume::emboss_shape, get_model_volume(), and Slic3r::GLVolume::world_matrix().

Referenced by calc_surface_offset(), anonymous_namespace{SurfaceDrag.cpp}::start_dragging(), 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(), Slic3r::Model::objects, and world_matrix_fixed().

Here is the call graph for this function:

world_to_screen_px()

wxPoint Slic3r::GUI::world_to_screen_px ( const Camera & cam, const Vec3d & world )

static

{
    // NB: multiply the raw 4x4 matrices, NOT the Transform3d objects — the projection is not
    // affine, so Transform*Transform mangles it (Eigen assumes affine) and yields garbage w.
    const Eigen::Matrix4d m = cam.get_projection_matrix().matrix() * cam.get_view_matrix().matrix();
    const Eigen::Vector4d clip = m * world.homogeneous();
    if (std::abs(clip.w()) < 1e-9) return wxPoint(-1, -1);
    const Vec3d ndc = clip.head<3>() / clip.w();
    const std::array<int, 4>& vp = cam.get_viewport();
    const double sx = vp[0] + (ndc.x() * 0.5 + 0.5) * vp[2];
    const double sy = vp[1] + (1.0 - (ndc.y() * 0.5 + 0.5)) * vp[3];   // GL y-up -> wx y-down
    return wxPoint(int(sx + 0.5), int(sy + 0.5));
}

References Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::GUI::Camera::get_view_matrix(), and Slic3r::GUI::Camera::get_viewport().

Referenced by Slic3r::GUI::DesignSketchTool::constrain_value_anchor(), Slic3r::GUI::DesignSketchTool::draw_dim_label(), Slic3r::GUI::DesignSketchTool::open_next_autoedit_dim(), Slic3r::GUI::DesignSketchTool::open_selection_dimension_editor(), Slic3r::GUI::DesignSketchTool::open_value_editor(), and Slic3r::GUI::DesignSketchTool::resolve_solid_pick().

Here is the call graph for this function:

Here is the caller graph for this function:

wrap_2pi()

double Slic3r::GUI::wrap_2pi ( double a )

static

{
    while (a < 0.0)        a += 2.0 * M_PI;
    while (a >= 2.0 * M_PI) a -= 2.0 * M_PI;
    return a;
}

References M_PI.

write_plan_value()

void Slic3r::GUI::write_plan_value ( std::vector< SketchEntityConstraintDef > & defs, double v )

static

{
    for (auto& d : defs)
        d.value = (d.type == SketchConstraintType::Angle) ? v * M_PI / 180.0 : v;
}

References Slic3r::Angle, and M_PI.

Referenced by Slic3r::GUI::DesignPanel::apply_live_constraint().

Here is the caller graph for this function:

wx_colour_to_recipe_rgb()

ColorDecomposeRgb Slic3r::GUI::wx_colour_to_recipe_rgb ( const wxColour & color )

static

{
    return {
        static_cast<unsigned char>(color.Red()),
        static_cast<unsigned char>(color.Green()),
        static_cast<unsigned char>(color.Blue())
    };
}

Referenced by Slic3r::GUI::ColorDecomposeDialog::compute_decomposition().

Here is the caller graph for this function:

WX_DECLARE_HASH_MAP()

Slic3r::GUI::WX_DECLARE_HASH_MAP	(	wxString	,
		MsgButton *	,
		wxStringHash	,
		wxStringEqual	,
		MsgButtonsHash	)

WX_DECLARE_LIST()

Slic3r::GUI::WX_DECLARE_LIST	(	AmsRadioSelector	,
		AmsRadioSelectorList	)

WX_DEFINE_ARRAY() [1/2]

Slic3r::GUI::WX_DEFINE_ARRAY	(	AmsPanel *	,
		AmsPanelHash	)

WX_DEFINE_ARRAY() [2/2]

Slic3r::GUI::WX_DEFINE_ARRAY	(	AuFiles *	,
		AuFilesHash	)

WX_DEFINE_ARRAY_PTR()

Slic3r::GUI::WX_DEFINE_ARRAY_PTR	(	ObjectDataViewModelNode *	,
		MyObjectTreeModelNodePtrArray	)

WX_DEFINE_LIST()

Slic3r::GUI::WX_DEFINE_LIST

(

AmsRadioSelectorList

)

wxBEGIN_EVENT_TABLE() [1/5]

Slic3r::GUI::wxBEGIN_EVENT_TABLE	(	CameraPopup	,
		PopupWindow	)

References Slic3r::GUI::CameraPopup::OnKillFocus(), Slic3r::GUI::CameraPopup::OnMouse(), Slic3r::GUI::CameraPopup::OnSetFocus(), and Slic3r::GUI::CameraPopup::OnSize().

Here is the call graph for this function:

wxBEGIN_EVENT_TABLE() [2/5]

Slic3r::GUI::wxBEGIN_EVENT_TABLE	(	ObjectGrid	,
		wxGrid	)

{
    input_string = wxEmptyString;
 
    if (type != coBool)
        return false;
 
    bool consumed = false;
    wxGridCellCoords coords(row, col);
 
    //found the grid window for this event
    /*wxGridWindow *gridWindow =
        DevicePosToGridWindow(event.GetPosition() + m_gridWin->GetPosition());
    if ( !gridWindow )
        gridWindow = m_gridWin;
    wxPoint position = CalcGridWindowUnscrolledPosition(event.GetPosition(), gridWindow);*/
 
    //compute the position considering the scrolled rows
#if HAS_COL_HEADER
    wxPoint event_position = event.GetPosition();
    event_position.y -= m_colLabelHeight;
 
    wxPoint position = CalcGridWindowUnscrolledPosition(event_position, nullptr);
#else
    wxPoint position = CalcGridWindowUnscrolledPosition(event.GetPosition(), nullptr);
#endif
 
    int col_right_pos = GetColRight(col);
    int row_up_pos = GetRowTop(row);
    int row_down_pos = GetRowBottom(row);
    int row_offset = ((row_down_pos - row_up_pos) - grid_cell_checkbox_size) /2;
    if (row_offset < 0)
        row_offset = 0;
    bool checkbox_hovered = false;
    if ((position.x > (col_right_pos - grid_cell_checkbox_size)) && (position.y >= (row_up_pos + row_offset)) && (position.y <= (row_down_pos - row_offset)))
        checkbox_hovered = true;
    //wxGridCellRenderer *render = this->GetCellRenderer(row, col);
    //wxDC temp_dc;
    //wxGridCellAttr temp_attr;
    //const wxRect checkBoxRect =
    //    wxGetContentRect(render->GetBestSize(*this, temp_attr, temp_dc, row, col),
    //                     rect, hAlign, vAlign);
    // Process the mouse down event depending on the current cursor mode. Note
    // that this assumes m_cursorMode was set in the mouse move event hendler.
    if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL)
    {
        if (!event.ShiftDown() && !event.CmdDown())
        {
            DisableCellEditControl();
            MakeCellVisible(coords);
            ClearSelection();
 
            if ( m_selection )
            {
                // In row or column selection mode just clicking on the cell
                // should select the row or column containing it: this is more
                // convenient for the kinds of controls that use such selection
                // mode and is compatible with 2.8 behaviour (see #12062).
                switch ( m_selection->GetSelectionMode() )
                {
                    case wxGridSelectNone:
                    case wxGridSelectCells:
                    //case wxGridSelectRowsOrColumns:
                        // nothing to do in these cases
                        //BBS: select this cell when first click
                        m_selection->SelectBlock(coords.GetRow(), coords.GetCol(),
                                             coords.GetRow(), coords.GetCol(),
                                             event);
                        consumed = true;
                        break;
 
                    default:
                        consumed = false;
                        break;
                }
            }
            else
                consumed = true;
 
            if (checkbox_hovered)
                m_waitForSlowClick = true;
            else
                m_waitForSlowClick = false;
            SetCurrentCell(coords);
        }
    }
    return consumed;
}

References Slic3r::coBool, grid_cell_checkbox_size, Slic3r::GUI::ObjectGrid::OnChar(), Slic3r::GUI::ObjectGrid::OnColHeadLeftClick(), Slic3r::GUI::ObjectGrid::OnKeyDown(), Slic3r::GUI::ObjectGrid::OnKeyUp(), and Slic3r::GUI::ObjectGrid::OnRangeSelected().

Here is the call graph for this function:

wxBEGIN_EVENT_TABLE() [3/5]

Slic3r::GUI::wxBEGIN_EVENT_TABLE	(	ObjectTablePanel	,
		wxPanel	)

                    : wxPanel( parent, id, pos, size, style, name ), m_model(modelObj), m_plater(platerObj), m_float_validator(2, nullptr, wxNUM_VAL_ZERO_AS_BLANK)
{
    //m_bg_colour = wxColour(0xfa, 0xfa, 0xfa);
    m_float_validator.SetRange(0, 100);
    m_bg_colour = wxColour("#FFFFFF");
    //m_hover_colour = wxColour(61, 70, 72);
    SetBackgroundColour(m_bg_colour);
 
    SetSize(wxSize(-1, FromDIP(450)));
    SetMinSize(wxSize(-1, FromDIP(450)));
    //SetMaxSize(wxSize(-1, FromDIP(450)));
    
 
    //m_search_line = new wxTextCtrl(this, wxID_ANY, "", wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER);
 
    init_bitmap();
 
    init_filaments_and_colors();
 
  m_top_sizer = new wxBoxSizer(wxHORIZONTAL);
    //m_top_sizer->Add(m_search_line, 0, wxEXPAND | wxLEFT | wxTOP | wxRIGHT, 10);
 
 
    m_object_grid = new ObjectGrid(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxWANTS_CHARS);
    m_object_grid_table = new ObjectGridTable(this);
    this->load_data();
    //m_object_grid_table->SetAttrProvider(new MyGridCellAttrProvider);
    //m_object_grid->AssignTable(m_object_grid_table);
 
    m_side_window = new wxScrolledWindow(this, wxID_ANY, wxDefaultPosition, wxSize(FromDIP(440),FromDIP(480)), wxVSCROLL);
    m_side_window->SetScrollRate(0, FromDIP(20));
    m_page_sizer = new wxBoxSizer(wxVERTICAL);
    //m_page_top_sizer = new wxBoxSizer(wxHORIZONTAL);
    m_side_window->SetBackgroundColour(wxColour(0xff, 0xff, 0xff));
    m_side_window->SetSizer(m_page_sizer);
    m_side_window->SetScrollbars(1, FromDIP(20), 1, 2);
    //m_side_window->ShowScrollbars(wxSHOW_SB_NEVER, wxSHOW_SB_NEVER);
 
    //m_side_window->EnableScrolling(false, true);
    //m_side_window->SetSize(wxSize(128, 512));
 
    /* m_page_text = new wxStaticText(m_side_window, wxID_ANY, wxString(L("Per Object Setting")), wxDefaultPosition, wxSize(-1, 32), wxALIGN_CENTRE_HORIZONTAL|wxST_ELLIPSIZE_END);
     m_page_text->SetMaxSize(wxSize(256, 32));
     m_page_text->SetFont(Label::Head_18);
     m_page_top_sizer->Add(m_page_text, 0, wxEXPAND, 5);*/
 
 
 
 
    //TODO, adjust later
    /*
     _bmp_reset = ScalableBitmap(m_side_window, "undo");
    m_bmp_reset_disable = ScalableBitmap(m_side_window, "dot");
    m_global_reset = new ScalableButton(m_side_window, wxID_ANY, m_bmp_reset);
    m_global_reset->SetToolTip(_(L("Reset All")));
 
    m_global_reset->SetBitmapDisabled(m_bmp_reset_disable.bmp());
 
    m_global_reset->Bind(wxEVT_BUTTON, [this](wxEvent &event) {
        m_object_grid_table->resetValuesInCurrentCell(event);
    });
    m_global_reset->Enable(false);
    m_page_top_sizer->AddSpacer(16);
    m_page_top_sizer->Add(m_global_reset, 0, wxEXPAND, 5);*/
 
 
 
    //create object settings
    m_side_window->SetFont(::Label::Body_12);
    m_object_settings = new ObjectTableSettings(m_side_window, m_object_grid_table);
    m_object_settings->Hide();
    //m_page_sizer->Add(m_page_top_sizer, 0, wxALIGN_CENTER_HORIZONTAL, 0);
    m_page_sizer->Add(m_object_settings->get_sizer(), 1, wxEXPAND | wxALL, 2 );
    m_side_window->Bind(wxEVT_LEFT_DOWN, [this](wxMouseEvent& evt) {
        m_object_grid->SetFocus();
        evt.Skip();
        });
 
    auto m_line_left = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxSize(2, -1), wxTAB_TRAVERSAL);
    m_line_left->SetBackgroundColour(wxColour(0xA6, 0xa9, 0xAA));
 
 
    m_top_sizer->Add(m_object_grid, 1, wxEXPAND,0);
    m_top_sizer->Add(m_line_left, 0, wxEXPAND, 0);
    m_top_sizer->Add(m_side_window, 0, wxEXPAND, 0);
 
    //wxBoxSizer * page_sizer = new wxBoxSizer(wxHORIZONTAL);
 
    SetFont(::Label::Body_13);
    SetSizer(m_top_sizer);
    Layout();
}

References Label::Body_12, Label::Body_13, Slic3r::GUI::ObjectTablePanel::OnCellLeftClick(), Slic3r::GUI::ObjectTablePanel::OnCellValueChanged(), Slic3r::GUI::ObjectTablePanel::OnColSize(), Slic3r::GUI::ObjectTablePanel::OnRangeSelected(), Slic3r::GUI::ObjectTablePanel::OnRowSize(), Slic3r::GUI::ObjectTablePanel::OnSelectCell(), style, and wxMouseEvent.

Here is the call graph for this function:

wxBEGIN_EVENT_TABLE() [4/5]

Slic3r::GUI::wxBEGIN_EVENT_TABLE	(	SliceInfoPopup	,
		PopupWindow	)

References Slic3r::GUI::SliceInfoPopup::OnKillFocus(), Slic3r::GUI::SliceInfoPopup::OnMouse(), Slic3r::GUI::SliceInfoPopup::OnSetFocus(), and Slic3r::GUI::SliceInfoPopup::OnSize().

Here is the call graph for this function:

wxBEGIN_EVENT_TABLE() [5/5]

Slic3r::GUI::wxBEGIN_EVENT_TABLE	(	TextureImportDialog	,
		DPIDialog	)

    : DPIDialog(parent, wxID_ANY, _L("Import Model"),
                wxDefaultPosition, wxDefaultSize,
                (wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER) & ~(wxMINIMIZE_BOX | wxMAXIMIZE_BOX))
    , m_textured_mesh(textured_mesh)
    , m_filament_entries(filament_entries)
    , m_initial_cancel_callback(std::move(initial_cancel_callback))
    , m_initial_progress_callback(std::move(initial_progress_callback))
{
    SetSize(wxSize(FromDIP(960), FromDIP(640)));
 
    m_filament_colors_rgba.reserve(m_filament_entries.size());
    m_filament_color_strs.reserve(m_filament_entries.size());
    m_filament_names.reserve(m_filament_entries.size());
    for (size_t i = 0; i < m_filament_entries.size(); ++i) {
        auto& entry = m_filament_entries[i];
        entry.dialog_index = (int)i;
        entry.color_hex = texture_normalize_color_hex(entry.color_hex);
        if (entry.name.empty())
            entry.name = GUI::format(_u8L("Filament %d"), i + 1);
        m_filament_color_strs.push_back(entry.color_hex);
        m_filament_names.push_back(entry.name);
        m_filament_colors_rgba.push_back(parse_color_string(entry.color_hex));
    }
 
    m_existing_filament_count = m_filament_colors_rgba.size();
    m_default_virtual_filament_preset_name = resolve_default_virtual_filament_preset_name();
 
    Bind(EVT_TEXTURE_COMPUTE_DONE,     &TextureImportDialog::on_computation_complete, this);
    Bind(EVT_TEXTURE_COMPUTE_PROGRESS, &TextureImportDialog::on_computation_progress, this);
    Bind(EVT_TEXTURE_COMPUTE_ERROR,    &TextureImportDialog::on_computation_error,    this);
    Bind(EVT_TEXTURE_MESH_REPAIR_DECISION, &TextureImportDialog::on_mesh_repair_decision_required, this);
 
    build_ui();
    SetMinSize(wxSize(FromDIP(800), FromDIP(500)));
    CenterOnParent();
    wxGetApp().UpdateDlgDarkUI(this);
 
    m_preview_canvas->set_mesh_data(m_textured_mesh.vertices, m_textured_mesh.indices);
 
    // Pre-computed face colors (OBJ vertex colors / MTL face colors):
    // use them directly as the Original preview, skip texture decode.
    if (!m_textured_mesh.precomputed_face_colors.empty()) {
        m_preview_canvas->set_original_face_colors(m_textured_mesh.precomputed_face_colors);
    } else if (!m_textured_mesh.textures.empty()) {
        std::vector<std::vector<unsigned char>> tex_pixels_rgb;
        std::vector<int> tex_widths, tex_heights;
        tex_pixels_rgb.reserve(m_textured_mesh.textures.size());
        tex_widths.reserve(m_textured_mesh.textures.size());
        tex_heights.reserve(m_textured_mesh.textures.size());
 
        for (const auto& ti : m_textured_mesh.textures) {
            std::vector<unsigned char> bgr_pixels;
            int w = 0, h = 0;
            if (Slic3r::decode_texture_to_pixels(ti, bgr_pixels, w, h) && !bgr_pixels.empty()) {
                // Convert BGR to RGB for OpenGL
                for (size_t p = 0; p < bgr_pixels.size(); p += 3)
                    std::swap(bgr_pixels[p], bgr_pixels[p + 2]);
                tex_pixels_rgb.push_back(std::move(bgr_pixels));
            } else {
                tex_pixels_rgb.push_back({});
            }
            tex_widths.push_back(w);
            tex_heights.push_back(h);
        }
 
        const size_t nf = m_textured_mesh.indices.size();
        const bool has_mapping = !m_textured_mesh.material_texture_map.empty();
 
        // Build per-face UV array
        std::vector<std::array<std::array<float,2>, 3>> face_uvs(nf);
        for (size_t fi = 0; fi < nf; ++fi) {
            if (m_textured_mesh.has_face_uvs()) {
                const auto& ui = m_textured_mesh.uv_indices[fi];
                for (int vi = 0; vi < 3; ++vi) {
                    int idx = ui[vi];
                    if (idx >= 0 && static_cast<size_t>(idx) < m_textured_mesh.uv_coords.size())
                        face_uvs[fi][vi] = m_textured_mesh.uv_coords[idx];
                    else
                        face_uvs[fi][vi] = {0.f, 0.f};
                }
            } else if (!m_textured_mesh.uvs.empty()) {
                const auto& face = m_textured_mesh.indices[fi];
                for (int vi = 0; vi < 3; ++vi) {
                    int idx = face[vi];
                    if (idx >= 0 && static_cast<size_t>(idx) < m_textured_mesh.uvs.size())
                        face_uvs[fi][vi] = m_textured_mesh.uvs[idx];
                    else
                        face_uvs[fi][vi] = {0.f, 0.f};
                }
            }
        }
 
        // Build per-face texture index
        std::vector<int> face_tex_ids(nf, 0);
        for (size_t fi = 0; fi < nf; ++fi) {
            int mat_idx = (fi < m_textured_mesh.material_ids.size())
                          ? m_textured_mesh.material_ids[fi] : -1;
            if (has_mapping && mat_idx >= 0
                && static_cast<size_t>(mat_idx) < m_textured_mesh.material_texture_map.size())
                face_tex_ids[fi] = m_textured_mesh.material_texture_map[mat_idx];
            else if (!tex_pixels_rgb.empty())
                face_tex_ids[fi] = 0;
            else
                face_tex_ids[fi] = -1;
        }
 
        m_preview_canvas->set_texture_render_data(
            tex_pixels_rgb, tex_widths, tex_heights, face_uvs, face_tex_ids);
 
        // Still sample per-face colors as fallback
        std::vector<std::array<std::size_t, 3>> orig_colors;
        if (Slic3r::sample_original_face_colors(m_textured_mesh, orig_colors))
            m_preview_canvas->set_original_face_colors(orig_colors);
    }
 
    set_state(TextureImportState::Idle);
}

References _L, _u8L, Slic3r::decode_texture_to_pixels(), format(), Slic3r::GUI::TextureImportDialog::ID_BTN_APPLY, Slic3r::GUI::TextureImportDialog::ID_BTN_SKIP, Slic3r::GUI::TextureImportDialog::ID_COLOR_16, Slic3r::GUI::TextureImportDialog::ID_COLOR_4, Slic3r::GUI::TextureImportDialog::ID_COLOR_8, Slic3r::GUI::TextureImportDialog::ID_COLOR_AUTO, Idle, Slic3r::GUI::TextureImportDialog::on_apply_clicked(), Slic3r::GUI::TextureImportDialog::on_color_preset_clicked(), Slic3r::GUI::TextureImportDialog::on_computation_complete(), Slic3r::GUI::TextureImportDialog::on_computation_error(), Slic3r::GUI::TextureImportDialog::on_computation_progress(), Slic3r::GUI::TextureImportDialog::on_mesh_repair_decision_required(), Slic3r::GUI::TextureImportDialog::on_ok_clicked(), Slic3r::GUI::TextureImportDialog::on_skip_clicked(), parse_color_string(), resolve_default_virtual_filament_preset_name(), Slic3r::sample_original_face_colors(), and texture_normalize_color_hex().

Here is the call graph for this function:

wxDECLARE_EVENT() [1/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_ADD_CUSTOM_FILAMENT	,
		ColorEvent	)

wxDECLARE_EVENT() [2/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_ADD_FILAMENT	,
		SimpleEvent	)

wxDECLARE_EVENT() [3/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_ALREADY_READ_HMS	,
		wxCommandEvent	)

wxDECLARE_EVENT() [4/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AMS_CLIBRATION_AGAIN	,
		wxCommandEvent	)

wxDECLARE_EVENT() [5/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AMS_CLIBRATION_CANCEL	,
		wxCommandEvent	)

wxDECLARE_EVENT() [6/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AMS_EXTRUSION_CALI	,
		wxCommandEvent	)

wxDECLARE_EVENT() [7/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AMS_FILAMENT_BACKUP	,
		SimpleEvent	)

wxDECLARE_EVENT() [8/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AMS_GUIDE_WIKI	,
		wxCommandEvent	)

wxDECLARE_EVENT() [9/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AMS_LOAD	,
		SimpleEvent	)

wxDECLARE_EVENT() [10/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AMS_ON_FILAMENT_EDIT	,
		wxCommandEvent	)

wxDECLARE_EVENT() [11/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AMS_ON_SELECTED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [12/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AMS_REFRESH_RFID	,
		wxCommandEvent	)

wxDECLARE_EVENT() [13/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AMS_RETRY	,
		wxCommandEvent	)

wxDECLARE_EVENT() [14/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AMS_SETTINGS	,
		SimpleEvent	)

wxDECLARE_EVENT() [15/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AMS_SHOW_HUMIDITY_TIPS	,
		wxCommandEvent	)

wxDECLARE_EVENT() [16/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AMS_SWITCH	,
		SimpleEvent	)

wxDECLARE_EVENT() [17/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AMS_UNLOAD	,
		SimpleEvent	)

wxDECLARE_EVENT() [18/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AMS_UNSELETED_AMS	,
		wxCommandEvent	)

wxDECLARE_EVENT() [19/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AMS_UNSELETED_VAMS	,
		wxCommandEvent	)

wxDECLARE_EVENT() [20/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AUXILIARY_DONE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [21/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AUXILIARY_IMPORT	,
		wxCommandEvent	)

wxDECLARE_EVENT() [22/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AUXILIARY_UPDATE_COVER	,
		wxCommandEvent	)

wxDECLARE_EVENT() [23/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AUXILIARY_UPDATE_DELETE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [24/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_AUXILIARY_UPDATE_RENAME	,
		wxCommandEvent	)

wxDECLARE_EVENT() [25/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_BIND_MACHINE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [26/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_BIND_MACHINE_FAIL	,
		wxCommandEvent	)

wxDECLARE_EVENT() [27/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_BIND_MACHINE_SUCCESS	,
		wxCommandEvent	)

wxDECLARE_EVENT() [28/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_BIND_UPDATE_MESSAGE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [29/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_CALI_ACTION	,
		wxCommandEvent	)

wxDECLARE_EVENT() [30/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_CALI_TRAY_CHANGED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [31/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_CALIBRATION_JOB_FINISHED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [32/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_CHECK_IP_ADDRESS_FAILED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [33/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_CHECK_IP_ADDRESS_LAYOUT	,
		wxCommandEvent	)

wxDECLARE_EVENT() [34/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_CHECK_PRIVACY_SHOW	,
		wxCommandEvent	)

wxDECLARE_EVENT() [35/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_CHECK_PRIVACY_VER	,
		wxCommandEvent	)

wxDECLARE_EVENT() [36/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_CHECKBOX_CHANGE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [37/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_CLEAR_IPADDRESS	,
		wxCommandEvent	)

wxDECLARE_EVENT() [38/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_CLOSE_IPADDRESS_DLG	,
		wxCommandEvent	)

wxDECLARE_EVENT() [39/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_CONNECT_LAN_MODE_PRINT	,
		wxCommandEvent	)

References wxDECLARE_EVENT().

Here is the call graph for this function:

wxDECLARE_EVENT() [40/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_CONNECT_LAN_PRINT	,
		wxCommandEvent	)

wxDECLARE_EVENT() [41/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_CREATE_FILAMENT	,
		SimpleEvent	)

wxDECLARE_EVENT() [42/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_CUSTOMEVT_TICKSCHANGED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [43/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DEL_FILAMENT	,
		SimpleEvent	)

wxDECLARE_EVENT() [44/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DEVICE_CHANGED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [45/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DIFF_DIALOG_TRANSFER	,
		SimpleEvent	)

wxDECLARE_EVENT() [46/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DISSMISS_MACHINE_LIST	,
		wxCommandEvent	)

wxDECLARE_EVENT() [47/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DOWNLOAD_NETWORK_FAILED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [48/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DWNLDR_FILE_CANCELED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [49/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DWNLDR_FILE_COMPLETE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [50/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DWNLDR_FILE_ERROR	,
		wxCommandEvent	)

wxDECLARE_EVENT() [51/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DWNLDR_FILE_NAME_CHANGE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [52/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DWNLDR_FILE_PAUSED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [53/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_DWNLDR_FILE_PROGRESS	,
		wxCommandEvent	)

wxDECLARE_EVENT() [54/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_EDIT_PRINT_NAME	,
		wxCommandEvent	)

wxDECLARE_EVENT() [55/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_EJECT_DRIVE_NOTIFICAION_CLICKED	,
		EjectDriveNotificationClickedEvent	)

wxDECLARE_EVENT() [56/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_ENTER_IP_ADDRESS	,
		wxCommandEvent	)

wxDECLARE_EVENT() [57/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_ERROR_DIALOG_BTN_CLICKED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [58/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_EXPORT_GCODE_NOTIFICAION_CLICKED	,
		ExportGcodeNotificationClickedEvent	)

wxDECLARE_EVENT() [59/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_FAN_ADD	,
		wxCommandEvent	)

wxDECLARE_EVENT() [60/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_FAN_CHANGED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [61/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_FAN_DEC	,
		wxCommandEvent	)

wxDECLARE_EVENT() [62/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_FAN_SWITCH_OFF	,
		wxCommandEvent	)

wxDECLARE_EVENT() [63/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_FAN_SWITCH_ON	,
		wxCommandEvent	)

wxDECLARE_EVENT() [64/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_FANCTRL_SWITCH	,
		wxCommandEvent	)

wxDECLARE_EVENT() [65/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_FILAMENT_COLOR_CHANGED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [66/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_FINISHED_UPDATE_MACHINE_LIST	,
		wxCommandEvent	)

wxDECLARE_EVENT() [67/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_ADAPTIVE_LAYER_HEIGHT_PROFILE	,
		Event< float >	)

wxDECLARE_EVENT() [68/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_ARRANGE	,
		SimpleEvent	)

wxDECLARE_EVENT() [69/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_ARRANGE_PARTPLATE	,
		SimpleEvent	)

wxDECLARE_EVENT() [70/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_COLLAPSE_SIDEBAR	,
		SimpleEvent	)

wxDECLARE_EVENT() [71/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_COLOR_MODE_CHANGED	,
		SimpleEvent	)

wxDECLARE_EVENT() [72/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_ENABLE_ACTION_BUTTONS	,
		Event< bool >	)

wxDECLARE_EVENT() [73/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_FORCE_UPDATE	,
		SimpleEvent	)

wxDECLARE_EVENT() [74/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_GIZMO_HIGHLIGHTER_TIMER	,
		wxTimerEvent	)

wxDECLARE_EVENT() [75/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_INCREASE_INSTANCES	,
		Event< int >	)

wxDECLARE_EVENT() [76/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_INSTANCE_MOVED	,
		SimpleEvent	)

wxDECLARE_EVENT() [77/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_INSTANCE_ROTATED	,
		SimpleEvent	)

wxDECLARE_EVENT() [78/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_INSTANCE_SCALED	,
		SimpleEvent	)

wxDECLARE_EVENT() [79/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED	,
		SimpleEvent	)

wxDECLARE_EVENT() [80/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_MOUSE_DRAGGING_STARTED	,
		SimpleEvent	)

wxDECLARE_EVENT() [81/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_OBJECT_SELECT	,
		SimpleEvent	)

wxDECLARE_EVENT() [82/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_ORIENT	,
		SimpleEvent	)

wxDECLARE_EVENT() [83/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_ORIENT_PARTPLATE	,
		SimpleEvent	)

wxDECLARE_EVENT() [84/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_PLATE_NAME_CHANGE	,
		SimpleEvent	)

wxDECLARE_EVENT() [85/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_PLATE_RIGHT_CLICK	,
		RBtnPlateEvent	)

wxDECLARE_EVENT() [86/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_PLATE_SELECT	,
		SimpleEvent	)

wxDECLARE_EVENT() [87/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_PRINTABLE	,
		SimpleEvent	)

wxDECLARE_EVENT() [88/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_QUESTION_MARK	,
		SimpleEvent	)

wxDECLARE_EVENT() [89/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_REDO	,
		SimpleEvent	)

wxDECLARE_EVENT() [90/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_RELOAD_FROM_DISK	,
		SimpleEvent	)

wxDECLARE_EVENT() [91/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_REMOVE_OBJECT	,
		SimpleEvent	)

wxDECLARE_EVENT() [92/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_RENDER_TIMER	,
		wxTimerEvent	)

wxDECLARE_EVENT() [93/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_RESET_LAYER_HEIGHT_PROFILE	,
		SimpleEvent	)

wxDECLARE_EVENT() [94/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_RESETGIZMOS	,
		SimpleEvent	)

wxDECLARE_EVENT() [95/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_RIGHT_CLICK	,
		RBtnEvent	)

wxDECLARE_EVENT() [96/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS	,
		SimpleEvent	)

wxDECLARE_EVENT() [97/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_SELECT_ALL	,
		SimpleEvent	)

wxDECLARE_EVENT() [98/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_SELECT_CURR_PLATE_ALL	,
		SimpleEvent	)

wxDECLARE_EVENT() [99/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_SMOOTH_LAYER_HEIGHT_PROFILE	,
		HeightProfileSmoothEvent	)

wxDECLARE_EVENT() [100/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_SWITCH_TO_GLOBAL	,
		SimpleEvent	)

wxDECLARE_EVENT() [101/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_SWITCH_TO_OBJECT	,
		SimpleEvent	)

wxDECLARE_EVENT() [102/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_TAB	,
		SimpleEvent	)

wxDECLARE_EVENT() [103/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_TOOLBAR_HIGHLIGHTER_TIMER	,
		wxTimerEvent	)

wxDECLARE_EVENT() [104/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_UNDO	,
		SimpleEvent	)

wxDECLARE_EVENT() [105/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_UPDATE	,
		SimpleEvent	)

wxDECLARE_EVENT() [106/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_UPDATE_BED_SHAPE	,
		SimpleEvent	)

wxDECLARE_EVENT() [107/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLCANVAS_UPDATE_GEOMETRY	,
		Vec3dsEvent< 2 >	)

wxDECLARE_EVENT() [108/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_ADD	,
		SimpleEvent	)

wxDECLARE_EVENT() [109/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_ADD_PLATE	,
		SimpleEvent	)

wxDECLARE_EVENT() [110/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_ARRANGE	,
		SimpleEvent	)

wxDECLARE_EVENT() [111/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_CLONE	,
		SimpleEvent	)

wxDECLARE_EVENT() [112/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_COPY	,
		SimpleEvent	)

wxDECLARE_EVENT() [113/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_CUT	,
		SimpleEvent	)

wxDECLARE_EVENT() [114/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_DEL_PLATE	,
		SimpleEvent	)

wxDECLARE_EVENT() [115/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_DELETE	,
		SimpleEvent	)

wxDECLARE_EVENT() [116/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_DELETE_ALL	,
		SimpleEvent	)

wxDECLARE_EVENT() [117/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_EXPORT_ALL_SLICED_FILE	,
		SimpleEvent	)

wxDECLARE_EVENT() [118/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_EXPORT_GCODE	,
		SimpleEvent	)

wxDECLARE_EVENT() [119/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_EXPORT_SLICED_FILE	,
		SimpleEvent	)

wxDECLARE_EVENT() [120/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_FEWER	,
		SimpleEvent	)

wxDECLARE_EVENT() [121/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_FILLCOLOR	,
		IntEvent	)

wxDECLARE_EVENT() [122/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_LAYERSEDITING	,
		SimpleEvent	)

wxDECLARE_EVENT() [123/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_MORE	,
		SimpleEvent	)

wxDECLARE_EVENT() [124/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_OPEN_PROJECT	,
		SimpleEvent	)

wxDECLARE_EVENT() [125/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_ORIENT	,
		SimpleEvent	)

wxDECLARE_EVENT() [126/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_PASTE	,
		SimpleEvent	)

wxDECLARE_EVENT() [127/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_PRINT_ALL	,
		SimpleEvent	)

wxDECLARE_EVENT() [128/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_PRINT_MULTI_MACHINE	,
		SimpleEvent	)

wxDECLARE_EVENT() [129/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_PRINT_PLATE	,
		SimpleEvent	)

wxDECLARE_EVENT() [130/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_PRINT_SELECT	,
		SimpleEvent	)

wxDECLARE_EVENT() [131/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_SELECT_SLICED_PLATE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [132/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_SEND_GCODE	,
		SimpleEvent	)

wxDECLARE_EVENT() [133/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_SEND_TO_PRINTER	,
		SimpleEvent	)

wxDECLARE_EVENT() [134/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_SEND_TO_PRINTER_ALL	,
		SimpleEvent	)

wxDECLARE_EVENT() [135/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_SLICE_ALL	,
		SimpleEvent	)

wxDECLARE_EVENT() [136/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_SLICE_PLATE	,
		SimpleEvent	)

wxDECLARE_EVENT() [137/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_SPLIT_OBJECTS	,
		SimpleEvent	)

wxDECLARE_EVENT() [138/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_SPLIT_VOLUMES	,
		SimpleEvent	)

wxDECLARE_EVENT() [139/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLTOOLBAR_UPLOAD_GCODE	,
		SimpleEvent	)

wxDECLARE_EVENT() [140/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLVIEWTOOLBAR_3D	,
		SimpleEvent	)

wxDECLARE_EVENT() [141/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLVIEWTOOLBAR_ASSEMBLE	,
		SimpleEvent	)

wxDECLARE_EVENT() [142/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_GLVIEWTOOLBAR_PREVIEW	,
		SimpleEvent	)

wxDECLARE_EVENT() [143/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_HTTP_ERROR	,
		wxCommandEvent	)

wxDECLARE_EVENT() [144/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_INDEX_PAGE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [145/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_INSTALL_NETWORK_FAILED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [146/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_INSTALL_PLUGIN_HINT	,
		wxCommandEvent	)

wxDECLARE_EVENT() [147/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_INSTALL_PLUGIN_NETWORKING	,
		wxCommandEvent	)

wxDECLARE_EVENT() [148/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_INSTANCE_GO_TO_FRONT	,
		InstanceGoToFrontEvent	)

wxDECLARE_EVENT() [149/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_LOAD_MODEL_OTHER_INSTANCE	,
		LoadFromOtherInstanceEvent	)

wxDECLARE_EVENT() [150/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_LOCK_DISABLE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [151/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_LOCK_ENABLE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [152/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_MODIFY_FILAMENT	,
		SimpleEvent	)

wxDECLARE_EVENT() [153/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_MULTI_CLOUD_TASK_SELECTED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [154/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_MULTI_DEVICE_SELECTED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [155/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_MULTI_DEVICE_SELECTED_FINHSH	,
		wxCommandEvent	)

wxDECLARE_EVENT() [156/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_MULTI_DEVICE_VIEW	,
		wxCommandEvent	)

wxDECLARE_EVENT() [157/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_MULTI_LOCAL_TASK_SELECTED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [158/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_MULTI_REFRESH	,
		wxCommandEvent	)

wxDECLARE_EVENT() [159/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_NEED_RESORT_LAYERS	,
		wxCommandEvent	)

wxDECLARE_EVENT() [160/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_NOTICE_CHILDE_SIZE_CHANGED	,
		SimpleEvent	)

wxDECLARE_EVENT() [161/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_NOTICE_FULL_SCREEN_CHANGED	,
		IntEvent	)

wxDECLARE_EVENT() [162/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_NOZZLE_SELECTED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [163/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_OAUTH_COMPLETE_MESSAGE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [164/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_OBJ_LIST_OBJECT_SELECT	,
		SimpleEvent	)

wxDECLARE_EVENT() [165/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_OPEN_FILAMENT_MAP_SETTINGS_DIALOG	,
		wxCommandEvent	)

wxDECLARE_EVENT() [166/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_OPEN_PLATESETTINGSDIALOG	,
		wxCommandEvent	)

wxDECLARE_EVENT() [167/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_PARTPLATE_LIST_PLATE_SELECT	,
		IntEvent	)

wxDECLARE_EVENT() [168/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_PRESET_UPDATE_AVAILABLE_CLICKED	,
		PresetUpdateAvailableClickedEvent	)

wxDECLARE_EVENT() [169/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_PREVIEW_ONLY_MODE_HINT	,
		wxCommandEvent	)

wxDECLARE_EVENT() [170/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_PRINT_FROM_SDCARD_VIEW	,
		SimpleEvent	)

wxDECLARE_EVENT() [171/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_PRINTER_CONFIG_UPDATE_AVAILABLE_CLICKED	,
		PrinterConfigUpdateAvailableClickedEvent	)

wxDECLARE_EVENT() [172/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_PRINTHOST_CANCEL	,
		PrintHostQueueDialog::Event	)

wxDECLARE_EVENT() [173/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_PRINTHOST_ERROR	,
		PrintHostQueueDialog::Event	)

wxDECLARE_EVENT() [174/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_PRINTHOST_INFO	,
		PrintHostQueueDialog::Event	)

wxDECLARE_EVENT() [175/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_PRINTHOST_PROGRESS	,
		PrintHostQueueDialog::Event	)

wxDECLARE_EVENT() [176/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_PRIVACY_UPDATE_CANCEL	,
		wxCommandEvent	)

wxDECLARE_EVENT() [177/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_PRIVACY_UPDATE_CONFIRM	,
		wxCommandEvent	)

wxDECLARE_EVENT() [178/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_PROJECT_RELOAD	,
		wxCommandEvent	)

wxDECLARE_EVENT() [179/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_REMOVABLE_DRIVE_EJECTED	,
		RemovableDriveEjectEvent	)

wxDECLARE_EVENT() [180/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_REMOVABLE_DRIVES_CHANGED	,
		RemovableDrivesChangedEvent	)

wxDECLARE_EVENT() [181/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_REPAIR_MODEL	,
		wxCommandEvent	)

wxDECLARE_EVENT() [182/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_RESPONSE_MESSAGE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [183/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_SDCARD_ABSENT_HINT	,
		wxCommandEvent	)

wxDECLARE_EVENT() [184/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_SECONDARY_CHECK_CANCEL	,
		wxCommandEvent	)

wxDECLARE_EVENT() [185/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_SECONDARY_CHECK_CONFIRM	,
		wxCommandEvent	)

wxDECLARE_EVENT() [186/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_SECONDARY_CHECK_DONE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [187/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_SECONDARY_CHECK_RESUME	,
		wxCommandEvent	)

wxDECLARE_EVENT() [188/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_SECONDARY_CHECK_RETRY	,
		wxCommandEvent	)

wxDECLARE_EVENT() [189/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_SELECTED_COLOR	,
		wxCommandEvent	)

wxDECLARE_EVENT() [190/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_SET_BED_TYPE_CONFIRM	,
		wxCommandEvent	)

wxDECLARE_EVENT() [191/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_SET_FINISH_MAPPING	,
		wxCommandEvent	)

Referenced by wxDECLARE_EVENT(), wxDECLARE_EVENT(), and wxDECLARE_EVENT().

Here is the caller graph for this function:

wxDECLARE_EVENT() [192/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_SHOW_IP_DIALOG	,
		wxCommandEvent	)

wxDECLARE_EVENT() [193/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_SLICING_UPDATE	,
		Slic3r::SlicingStatusEvent	)

wxDECLARE_EVENT() [194/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_START_DOWNLOAD_OTHER_INSTANCE	,
		StartDownloadOtherInstanceEvent	)

wxDECLARE_EVENT() [195/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_SWITCH_PRINT_OPTION	,
		wxCommandEvent	)

wxDECLARE_EVENT() [196/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_TEXTURE_COMPUTE_DONE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [197/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_TEXTURE_COMPUTE_ERROR	,
		wxCommandEvent	)

wxDECLARE_EVENT() [198/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_TEXTURE_COMPUTE_PROGRESS	,
		wxCommandEvent	)

wxDECLARE_EVENT() [199/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_TEXTURE_MESH_REPAIR_DECISION	,
		wxCommandEvent	)

wxDECLARE_EVENT() [200/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_UNBIND_MACHINE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [201/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_UPDATE_BUNDLE_COMPLETE	,
		wxCommandEvent	)

References build_plate_tilt_up_direction(), has_filaments(), is_soluble_filament(), is_support_filament(), and wxDECLARE_EVENT().

Here is the call graph for this function:

wxDECLARE_EVENT() [202/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_UPDATE_MACHINE_LIST	,
		wxCommandEvent	)

wxDECLARE_EVENT() [203/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_UPDATE_NOZZLE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [204/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_UPDATE_PLUGINS_WHEN_LAUNCH	,
		wxCommandEvent	)

wxDECLARE_EVENT() [205/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_UPDATE_PRESET_BUNDLE	,
		wxCommandEvent	)

References wxDECLARE_EVENT().

Here is the call graph for this function:

wxDECLARE_EVENT() [206/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_UPDATE_PRESET_CB	,
		SimpleEvent	)

wxDECLARE_EVENT() [207/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_UPDATE_RESULT	,
		wxCommandEvent	)

wxDECLARE_EVENT() [208/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_UPDATE_TEXT_MSG	,
		wxCommandEvent	)

wxDECLARE_EVENT() [209/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_UPDATE_WINDOWS_POSITION	,
		wxCommandEvent	)

wxDECLARE_EVENT() [210/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_UPGRADE_NETWORK_SUCCESS	,
		wxCommandEvent	)

wxDECLARE_EVENT() [211/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_UPGRADE_UPDATE_MESSAGE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [212/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_USER_LOGIN	,
		wxCommandEvent	)

wxDECLARE_EVENT() [213/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_USER_LOGIN_HANDLE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [214/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_VAMS_ON_FILAMENT_EDIT	,
		wxCommandEvent	)

wxDECLARE_EVENT() [215/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_VCAMERA_SWITCH	,
		wxMouseEvent	)

References wxMouseEvent.

wxDECLARE_EVENT() [216/223]

Slic3r::GUI::wxDECLARE_EVENT	(	EVT_WILL_DISMISS_MACHINE_LIST	,
		wxCommandEvent	)

wxDECLARE_EVENT() [217/223]

Slic3r::GUI::wxDECLARE_EVENT	(	wxCUSTOMEVT_LAST_VOLUME_IS_DELETED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [218/223]

Slic3r::GUI::wxDECLARE_EVENT	(	wxEVT_DRAG_DROP_COMPLETED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [219/223]

Slic3r::GUI::wxDECLARE_EVENT	(	wxEVT_GRADIENT_CURVE_CHANGED	,
		wxCommandEvent	)

wxDECLARE_EVENT() [220/223]

Slic3r::GUI::wxDECLARE_EVENT	(	wxEVT_INVALID_MANUAL_MAP	,
		wxCommandEvent	)

wxDECLARE_EVENT() [221/223]

Slic3r::GUI::wxDECLARE_EVENT	(	wxEVT_NOZZLE_JUMP_UPGRADE	,
		wxCommandEvent	)

wxDECLARE_EVENT() [222/223]

Slic3r::GUI::wxDECLARE_EVENT	(	wxEVT_REFRESH_DATA	,
		wxCommandEvent	)

wxDECLARE_EVENT() [223/223]

Slic3r::GUI::wxDECLARE_EVENT	(	wxEVT_THREAD_DONE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [1/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_ADD_CUSTOM_FILAMENT	,
		ColorEvent	)

wxDEFINE_EVENT() [2/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_ADD_FILAMENT	,
		SimpleEvent	)

wxDEFINE_EVENT() [3/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_ALREADY_READ_HMS	,
		wxCommandEvent	)

wxDEFINE_EVENT() [4/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AMS_CLIBRATION_AGAIN	,
		wxCommandEvent	)

wxDEFINE_EVENT() [5/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AMS_CLIBRATION_CANCEL	,
		wxCommandEvent	)

wxDEFINE_EVENT() [6/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AMS_EXTRUSION_CALI	,
		wxCommandEvent	)

wxDEFINE_EVENT() [7/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AMS_FILAMENT_BACKUP	,
		SimpleEvent	)

wxDEFINE_EVENT() [8/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AMS_GUIDE_WIKI	,
		wxCommandEvent	)

wxDEFINE_EVENT() [9/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AMS_LOAD	,
		SimpleEvent	)

wxDEFINE_EVENT() [10/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AMS_ON_FILAMENT_EDIT	,
		wxCommandEvent	)

wxDEFINE_EVENT() [11/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AMS_ON_SELECTED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [12/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AMS_REFRESH_RFID	,
		wxCommandEvent	)

wxDEFINE_EVENT() [13/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AMS_RETRY	,
		wxCommandEvent	)

wxDEFINE_EVENT() [14/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AMS_SETTINGS	,
		SimpleEvent	)

wxDEFINE_EVENT() [15/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AMS_SHOW_HUMIDITY_TIPS	,
		wxCommandEvent	)

wxDEFINE_EVENT() [16/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AMS_SWITCH	,
		SimpleEvent	)

wxDEFINE_EVENT() [17/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AMS_UNLOAD	,
		SimpleEvent	)

wxDEFINE_EVENT() [18/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AMS_UNSELETED_VAMS	,
		wxCommandEvent	)

wxDEFINE_EVENT() [19/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AUXILIARY_DONE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [20/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AUXILIARY_IMPORT	,
		wxCommandEvent	)

wxDEFINE_EVENT() [21/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AUXILIARY_UPDATE_COVER	,
		wxCommandEvent	)

wxDEFINE_EVENT() [22/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AUXILIARY_UPDATE_DELETE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [23/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_AUXILIARY_UPDATE_RENAME	,
		wxCommandEvent	)

wxDEFINE_EVENT() [24/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_BACKUP_POST	,
		wxCommandEvent	)

wxDEFINE_EVENT() [25/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_BIND_MACHINE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [26/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_BIND_MACHINE_FAIL	,
		wxCommandEvent	)

wxDEFINE_EVENT() [27/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_BIND_MACHINE_SUCCESS	,
		wxCommandEvent	)

wxDEFINE_EVENT() [28/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_BIND_UPDATE_MESSAGE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [29/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_CALI_ACTION	,
		wxCommandEvent	)

wxDEFINE_EVENT() [30/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_CALI_TRAY_CHANGED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [31/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_CALIBRATION_JOB_FINISHED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [32/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_CHECK_IP_ADDRESS_FAILED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [33/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_CHECK_IP_ADDRESS_LAYOUT	,
		wxCommandEvent	)

wxDEFINE_EVENT() [34/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_CHECK_PRIVACY_SHOW	,
		wxCommandEvent	)

wxDEFINE_EVENT() [35/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_CHECK_PRIVACY_VER	,
		wxCommandEvent	)

wxDEFINE_EVENT() [36/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_CHECKBOX_CHANGE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [37/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_CLEAR_IPADDRESS	,
		wxCommandEvent	)

wxDEFINE_EVENT() [38/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_CLOSE_IPADDRESS_DLG	,
		wxCommandEvent	)

wxDEFINE_EVENT() [39/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_CONNECT_LAN_MODE_PRINT	,
		wxCommandEvent	)

wxDEFINE_EVENT() [40/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_CONNECT_LAN_PRINT	,
		wxCommandEvent	)

wxDEFINE_EVENT() [41/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_CREATE_FILAMENT	,
		SimpleEvent	)

wxDEFINE_EVENT() [42/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_CUSTOMEVT_TICKSCHANGED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [43/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DEL_FILAMENT	,
		SimpleEvent	)

wxDEFINE_EVENT() [44/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DEVICE_CHANGED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [45/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DIFF_DIALOG_TRANSFER	,
		SimpleEvent	)

wxDEFINE_EVENT() [46/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DISSMISS_MACHINE_LIST	,
		wxCommandEvent	)

wxDEFINE_EVENT() [47/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DOWNLOAD_NETWORK_FAILED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [48/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DOWNLOAD_PROJECT	,
		wxCommandEvent	)

wxDEFINE_EVENT() [49/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DWNLDR_FILE_CANCELED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [50/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DWNLDR_FILE_COMPLETE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [51/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DWNLDR_FILE_ERROR	,
		wxCommandEvent	)

wxDEFINE_EVENT() [52/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DWNLDR_FILE_NAME_CHANGE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [53/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DWNLDR_FILE_PAUSED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [54/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_DWNLDR_FILE_PROGRESS	,
		wxCommandEvent	)

wxDEFINE_EVENT() [55/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_EDIT_PRINT_NAME	,
		wxCommandEvent	)

wxDEFINE_EVENT() [56/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_EJECT_DRIVE_NOTIFICAION_CLICKED	,
		EjectDriveNotificationClickedEvent	)

wxDEFINE_EVENT() [57/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_ENTER_FORCE_UPGRADE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [58/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_ENTER_IP_ADDRESS	,
		wxCommandEvent	)

wxDEFINE_EVENT() [59/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_ERROR_DIALOG_BTN_CLICKED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [60/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_EXPORT_BEGAN	,
		wxCommandEvent	)

wxDEFINE_EVENT() [61/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_EXPORT_FINISHED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [62/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_EXPORT_GCODE_NOTIFICAION_CLICKED	,
		ExportGcodeNotificationClickedEvent	)

wxDEFINE_EVENT() [63/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_FAN_ADD	,
		wxCommandEvent	)

wxDEFINE_EVENT() [64/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_FAN_CHANGED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [65/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_FAN_DEC	,
		wxCommandEvent	)

wxDEFINE_EVENT() [66/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_FAN_SWITCH_OFF	,
		wxCommandEvent	)

wxDEFINE_EVENT() [67/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_FAN_SWITCH_ON	,
		wxCommandEvent	)

wxDEFINE_EVENT() [68/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_FANCTRL_SWITCH	,
		wxCommandEvent	)

wxDEFINE_EVENT() [69/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_FILAMENT_COLOR_CHANGED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [70/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_FINISHED_UPDATE_MACHINE_LIST	,
		wxCommandEvent	)

wxDEFINE_EVENT() [71/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_FINISHED_UPDATE_MLIST	,
		wxCommandEvent	)

wxDEFINE_EVENT() [72/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_ADAPTIVE_LAYER_HEIGHT_PROFILE	,
		Event< float >	)

wxDEFINE_EVENT() [73/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_ARRANGE	,
		SimpleEvent	)

wxDEFINE_EVENT() [74/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_ARRANGE_PARTPLATE	,
		SimpleEvent	)

wxDEFINE_EVENT() [75/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_COLLAPSE_SIDEBAR	,
		SimpleEvent	)

wxDEFINE_EVENT() [76/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_COLOR_MODE_CHANGED	,
		SimpleEvent	)

wxDEFINE_EVENT() [77/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_ENABLE_ACTION_BUTTONS	,
		Event< bool >	)

wxDEFINE_EVENT() [78/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_FORCE_UPDATE	,
		SimpleEvent	)

wxDEFINE_EVENT() [79/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_GIZMO_HIGHLIGHTER_TIMER	,
		wxTimerEvent	)

wxDEFINE_EVENT() [80/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_INCREASE_INSTANCES	,
		Event< int >	)

wxDEFINE_EVENT() [81/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_INSTANCE_MOVED	,
		SimpleEvent	)

wxDEFINE_EVENT() [82/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_INSTANCE_ROTATED	,
		SimpleEvent	)

wxDEFINE_EVENT() [83/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_INSTANCE_SCALED	,
		SimpleEvent	)

wxDEFINE_EVENT() [84/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED	,
		SimpleEvent	)

wxDEFINE_EVENT() [85/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_MOUSE_DRAGGING_STARTED	,
		SimpleEvent	)

wxDEFINE_EVENT() [86/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_OBJECT_SELECT	,
		SimpleEvent	)

wxDEFINE_EVENT() [87/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_ORIENT	,
		SimpleEvent	)

wxDEFINE_EVENT() [88/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_ORIENT_PARTPLATE	,
		SimpleEvent	)

wxDEFINE_EVENT() [89/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_PLATE_NAME_CHANGE	,
		SimpleEvent	)

wxDEFINE_EVENT() [90/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_PLATE_RIGHT_CLICK	,
		RBtnPlateEvent	)

wxDEFINE_EVENT() [91/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_PLATE_SELECT	,
		SimpleEvent	)

wxDEFINE_EVENT() [92/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_PRINTABLE	,
		SimpleEvent	)

References Slic3r::GUI::GLCanvas3D::DefaultCameraZoomToBedMarginFactor, Slic3r::GUI::GLCanvas3D::DefaultCameraZoomToBoxMarginFactor, Slic3r::GUI::GLCanvas3D::DefaultCameraZoomToPlateMarginFactor, and Slic3r::GUI::GLCanvas3D::s_frames_in_progress.

wxDEFINE_EVENT() [93/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_QUESTION_MARK	,
		SimpleEvent	)

wxDEFINE_EVENT() [94/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_REDO	,
		SimpleEvent	)

wxDEFINE_EVENT() [95/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_RELOAD_FROM_DISK	,
		SimpleEvent	)

wxDEFINE_EVENT() [96/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_REMOVE_OBJECT	,
		SimpleEvent	)

wxDEFINE_EVENT() [97/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_RENDER_TIMER	,
		wxTimerEvent	)

wxDEFINE_EVENT() [98/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_RESET_LAYER_HEIGHT_PROFILE	,
		SimpleEvent	)

wxDEFINE_EVENT() [99/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_RESETGIZMOS	,
		SimpleEvent	)

wxDEFINE_EVENT() [100/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_RIGHT_CLICK	,
		RBtnEvent	)

wxDEFINE_EVENT() [101/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS	,
		SimpleEvent	)

wxDEFINE_EVENT() [102/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_SELECT_ALL	,
		SimpleEvent	)

wxDEFINE_EVENT() [103/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_SELECT_CURR_PLATE_ALL	,
		SimpleEvent	)

wxDEFINE_EVENT() [104/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_SMOOTH_LAYER_HEIGHT_PROFILE	,
		HeightProfileSmoothEvent	)

wxDEFINE_EVENT() [105/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_SWITCH_TO_GLOBAL	,
		SimpleEvent	)

wxDEFINE_EVENT() [106/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_SWITCH_TO_OBJECT	,
		SimpleEvent	)

wxDEFINE_EVENT() [107/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_TAB	,
		SimpleEvent	)

wxDEFINE_EVENT() [108/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_TOOLBAR_HIGHLIGHTER_TIMER	,
		wxTimerEvent	)

wxDEFINE_EVENT() [109/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_UNDO	,
		SimpleEvent	)

wxDEFINE_EVENT() [110/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_UPDATE	,
		SimpleEvent	)

wxDEFINE_EVENT() [111/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_UPDATE_BED_SHAPE	,
		SimpleEvent	)

wxDEFINE_EVENT() [112/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLCANVAS_UPDATE_GEOMETRY	,
		Vec3dsEvent< 2 >	)

wxDEFINE_EVENT() [113/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_ADD	,
		SimpleEvent	)

wxDEFINE_EVENT() [114/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_ADD_PLATE	,
		SimpleEvent	)

wxDEFINE_EVENT() [115/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_ARRANGE	,
		SimpleEvent	)

wxDEFINE_EVENT() [116/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_CLONE	,
		SimpleEvent	)

wxDEFINE_EVENT() [117/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_COPY	,
		SimpleEvent	)

wxDEFINE_EVENT() [118/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_CUT	,
		SimpleEvent	)

wxDEFINE_EVENT() [119/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_DEL_PLATE	,
		SimpleEvent	)

wxDEFINE_EVENT() [120/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_DELETE	,
		SimpleEvent	)

wxDEFINE_EVENT() [121/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_DELETE_ALL	,
		SimpleEvent	)

wxDEFINE_EVENT() [122/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_EXPORT_ALL_SLICED_FILE	,
		SimpleEvent	)

wxDEFINE_EVENT() [123/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_EXPORT_GCODE	,
		SimpleEvent	)

wxDEFINE_EVENT() [124/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_EXPORT_SLICED_FILE	,
		SimpleEvent	)

wxDEFINE_EVENT() [125/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_FEWER	,
		SimpleEvent	)

wxDEFINE_EVENT() [126/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_FILLCOLOR	,
		IntEvent	)

wxDEFINE_EVENT() [127/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_LAYERSEDITING	,
		SimpleEvent	)

wxDEFINE_EVENT() [128/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_MORE	,
		SimpleEvent	)

wxDEFINE_EVENT() [129/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_OPEN_PROJECT	,
		SimpleEvent	)

wxDEFINE_EVENT() [130/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_ORIENT	,
		SimpleEvent	)

wxDEFINE_EVENT() [131/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_PASTE	,
		SimpleEvent	)

wxDEFINE_EVENT() [132/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_PRINT_ALL	,
		SimpleEvent	)

wxDEFINE_EVENT() [133/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_PRINT_MULTI_MACHINE	,
		SimpleEvent	)

wxDEFINE_EVENT() [134/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_PRINT_PLATE	,
		SimpleEvent	)

wxDEFINE_EVENT() [135/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_PRINT_SELECT	,
		SimpleEvent	)

wxDEFINE_EVENT() [136/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_SELECT_SLICED_PLATE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [137/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_SEND_GCODE	,
		SimpleEvent	)

wxDEFINE_EVENT() [138/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_SEND_TO_PRINTER	,
		SimpleEvent	)

wxDEFINE_EVENT() [139/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_SEND_TO_PRINTER_ALL	,
		SimpleEvent	)

wxDEFINE_EVENT() [140/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_SLICE_ALL	,
		SimpleEvent	)

wxDEFINE_EVENT() [141/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_SLICE_PLATE	,
		SimpleEvent	)

wxDEFINE_EVENT() [142/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_SPLIT_OBJECTS	,
		SimpleEvent	)

wxDEFINE_EVENT() [143/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_SPLIT_VOLUMES	,
		SimpleEvent	)

wxDEFINE_EVENT() [144/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLTOOLBAR_UPLOAD_GCODE	,
		SimpleEvent	)

wxDEFINE_EVENT() [145/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLVIEWTOOLBAR_3D	,
		SimpleEvent	)

wxDEFINE_EVENT() [146/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLVIEWTOOLBAR_ASSEMBLE	,
		SimpleEvent	)

References Slic3r::GUI::GLToolbarItem::Default_Action_Callback.

wxDEFINE_EVENT() [147/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_GLVIEWTOOLBAR_PREVIEW	,
		SimpleEvent	)

wxDEFINE_EVENT() [148/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_HTTP_ERROR	,
		wxCommandEvent	)

wxDEFINE_EVENT() [149/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_IMPORT_MODEL_ID	,
		wxCommandEvent	)

wxDEFINE_EVENT() [150/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_INDEX_PAGE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [151/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_INSTALL_NETWORK_FAILED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [152/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_INSTALL_PLUGIN_HINT	,
		wxCommandEvent	)

wxDEFINE_EVENT() [153/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_INSTALL_PLUGIN_NETWORKING	,
		wxCommandEvent	)

wxDEFINE_EVENT() [154/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_INSTANCE_GO_TO_FRONT	,
		InstanceGoToFrontEvent	)

wxDEFINE_EVENT() [155/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_LOAD_MODEL_OTHER_INSTANCE	,
		LoadFromOtherInstanceEvent	)

wxDEFINE_EVENT() [156/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_LOAD_PRINTER_URL	,
		LoadPrinterViewEvent	)

wxDEFINE_EVENT() [157/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_LOAD_URL	,
		wxCommandEvent	)

wxDEFINE_EVENT() [158/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_LOCK_DISABLE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [159/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_LOCK_ENABLE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [160/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_MODIFY_FILAMENT	,
		SimpleEvent	)

wxDEFINE_EVENT() [161/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_MULTI_CLOUD_TASK_SELECTED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [162/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_MULTI_DEVICE_SELECTED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [163/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_MULTI_DEVICE_SELECTED_FINHSH	,
		wxCommandEvent	)

wxDEFINE_EVENT() [164/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_MULTI_DEVICE_VIEW	,
		wxCommandEvent	)

wxDEFINE_EVENT() [165/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_MULTI_LOCAL_TASK_SELECTED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [166/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_MULTI_REFRESH	,
		wxCommandEvent	)

wxDEFINE_EVENT() [167/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_NEED_RESORT_LAYERS	,
		wxCommandEvent	)

wxDEFINE_EVENT() [168/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_NOTICE_CHILDE_SIZE_CHANGED	,
		SimpleEvent	)

wxDEFINE_EVENT() [169/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_NOTICE_FULL_SCREEN_CHANGED	,
		IntEvent	)

wxDEFINE_EVENT() [170/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_NOZZLE_SELECTED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [171/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_OAUTH_COMPLETE_MESSAGE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [172/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_OBJ_LIST_OBJECT_SELECT	,
		SimpleEvent	)

wxDEFINE_EVENT() [173/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_OPEN_FILAMENT_MAP_SETTINGS_DIALOG	,
		wxCommandEvent	)

wxDEFINE_EVENT() [174/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_OPEN_PLATESETTINGSDIALOG	,
		wxCommandEvent	)

wxDEFINE_EVENT() [175/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PARTPLATE_LIST_PLATE_SELECT	,
		IntEvent	)

wxDEFINE_EVENT() [176/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PRESET_UPDATE_AVAILABLE_CLICKED	,
		PresetUpdateAvailableClickedEvent	)

wxDEFINE_EVENT() [177/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PREVIEW_ONLY_MODE_HINT	,
		wxCommandEvent	)

wxDEFINE_EVENT() [178/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PRINT_FINISHED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [179/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PRINT_FROM_SDCARD_VIEW	,
		SimpleEvent	)

wxDEFINE_EVENT() [180/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PRINT_JOB_CANCEL	,
		wxCommandEvent	)

wxDEFINE_EVENT() [181/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PRINTER_CONFIG_UPDATE_AVAILABLE_CLICKED	,
		PrinterConfigUpdateAvailableClickedEvent	)

wxDEFINE_EVENT() [182/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PRINTER_PICK	,
		PrinterPickerEvent	)

References Slic3r::GUI::PrinterPicker::PRINTER_PLACEHOLDER.

wxDEFINE_EVENT() [183/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PRINTHOST_CANCEL	,
		PrintHostQueueDialog::Event	)

wxDEFINE_EVENT() [184/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PRINTHOST_ERROR	,
		PrintHostQueueDialog::Event	)

wxDEFINE_EVENT() [185/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PRINTHOST_INFO	,
		PrintHostQueueDialog::Event	)

wxDEFINE_EVENT() [186/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PRINTHOST_PROGRESS	,
		PrintHostQueueDialog::Event	)

wxDEFINE_EVENT() [187/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PRIVACY_UPDATE_CANCEL	,
		wxCommandEvent	)

wxDEFINE_EVENT() [188/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PRIVACY_UPDATE_CONFIRM	,
		wxCommandEvent	)

wxDEFINE_EVENT() [189/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PROCESS_COMPLETED	,
		SlicingProcessCompletedEvent	)

wxDEFINE_EVENT() [190/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_PROJECT_RELOAD	,
		wxCommandEvent	)

wxDEFINE_EVENT() [191/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_REMOVABLE_DRIVE_EJECTED	,
		RemovableDriveEjectEvent	)

wxDEFINE_EVENT() [192/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_REMOVABLE_DRIVES_CHANGED	,
		RemovableDrivesChangedEvent	)

wxDEFINE_EVENT() [193/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_REPAIR_MODEL	,
		wxCommandEvent	)

wxDEFINE_EVENT() [194/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_RESPONSE_MESSAGE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [195/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_RESTORE_PROJECT	,
		wxCommandEvent	)

wxDEFINE_EVENT() [196/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SCHEDULE_BACKGROUND_PROCESS	,
		SimpleEvent	)

wxDEFINE_EVENT() [197/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SDCARD_ABSENT_HINT	,
		wxCommandEvent	)

References wxDEFINE_EVENT().

Here is the call graph for this function:

wxDEFINE_EVENT() [198/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SECONDARY_CHECK_CANCEL	,
		wxCommandEvent	)

wxDEFINE_EVENT() [199/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SECONDARY_CHECK_CONFIRM	,
		wxCommandEvent	)

wxDEFINE_EVENT() [200/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SECONDARY_CHECK_DONE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [201/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SECONDARY_CHECK_RESUME	,
		wxCommandEvent	)

wxDEFINE_EVENT() [202/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SECONDARY_CHECK_RETRY	,
		wxCommandEvent	)

wxDEFINE_EVENT() [203/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SELECT_TAB	,
		wxCommandEvent	)

wxDEFINE_EVENT() [204/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SELECTED_COLOR	,
		wxCommandEvent	)

wxDEFINE_EVENT() [205/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SEND_CALIBRATION_FINISHED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [206/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SEND_FINISHED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [207/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SEND_JOB_SUCCESS	,
		wxCommandEvent	)

wxDEFINE_EVENT() [208/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SET_BED_TYPE_CONFIRM	,
		wxCommandEvent	)

wxDEFINE_EVENT() [209/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SET_FINISH_MAPPING	,
		wxCommandEvent	)

Referenced by wxDEFINE_EVENT().

Here is the caller graph for this function:

wxDEFINE_EVENT() [210/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SHOW_DIALOG	,
		wxCommandEvent	)

wxDEFINE_EVENT() [211/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SHOW_IP_DIALOG	,
		wxCommandEvent	)

wxDEFINE_EVENT() [212/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SHOW_NO_NEW_VERSION	,
		wxCommandEvent	)

wxDEFINE_EVENT() [213/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SLICING_COMPLETED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [214/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SLICING_UPDATE	,
		SlicingStatusEvent	)

wxDEFINE_EVENT() [215/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_START_DOWNLOAD_OTHER_INSTANCE	,
		StartDownloadOtherInstanceEvent	)

wxDEFINE_EVENT() [216/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SWITCH_PRINT_OPTION	,
		wxCommandEvent	)

wxDEFINE_EVENT() [217/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_SYNC_CLOUD_PRESET	,
		SimpleEvent	)

wxDEFINE_EVENT() [218/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_TEXTURE_COMPUTE_DONE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [219/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_TEXTURE_COMPUTE_ERROR	,
		wxCommandEvent	)

wxDEFINE_EVENT() [220/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_TEXTURE_COMPUTE_PROGRESS	,
		wxCommandEvent	)

wxDEFINE_EVENT() [221/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_TEXTURE_MESH_REPAIR_DECISION	,
		wxCommandEvent	)

wxDEFINE_EVENT() [222/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_UNBIND_MACHINE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [223/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_UPDATE_BUNDLE_COMPLETE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [224/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_UPDATE_MACHINE_LIST	,
		wxCommandEvent	)

wxDEFINE_EVENT() [225/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_UPDATE_NOZZLE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [226/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_UPDATE_PLUGINS_WHEN_LAUNCH	,
		wxCommandEvent	)

wxDEFINE_EVENT() [227/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_UPDATE_PRESET_BUNDLE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [228/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_UPDATE_PRESET_CB	,
		SimpleEvent	)

wxDEFINE_EVENT() [229/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_UPDATE_RESULT	,
		wxCommandEvent	)

wxDEFINE_EVENT() [230/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_UPDATE_TEXT_MSG	,
		wxCommandEvent	)

wxDEFINE_EVENT() [231/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_UPDATE_USER_MACHINE_LIST	,
		wxCommandEvent	)

wxDEFINE_EVENT() [232/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_UPDATE_USER_MLIST	,
		wxCommandEvent	)

wxDEFINE_EVENT() [233/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_UPDATE_WINDOWS_POSITION	,
		wxCommandEvent	)

wxDEFINE_EVENT() [234/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_UPGRADE_NETWORK_SUCCESS	,
		wxCommandEvent	)

wxDEFINE_EVENT() [235/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_UPGRADE_UPDATE_MESSAGE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [236/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_USER_LOGIN	,
		wxCommandEvent	)

wxDEFINE_EVENT() [237/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_USER_LOGIN_HANDLE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [238/244]

Slic3r::GUI::wxDEFINE_EVENT	(	EVT_VAMS_ON_FILAMENT_EDIT	,
		wxCommandEvent	)

wxDEFINE_EVENT() [239/244]

Slic3r::GUI::wxDEFINE_EVENT	(	wxCUSTOMEVT_LAST_VOLUME_IS_DELETED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [240/244]

Slic3r::GUI::wxDEFINE_EVENT	(	wxEVT_DRAG_DROP_COMPLETED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [241/244]

Slic3r::GUI::wxDEFINE_EVENT	(	wxEVT_GRADIENT_CURVE_CHANGED	,
		wxCommandEvent	)

wxDEFINE_EVENT() [242/244]

Slic3r::GUI::wxDEFINE_EVENT	(	wxEVT_INVALID_MANUAL_MAP	,
		wxCommandEvent	)

wxDEFINE_EVENT() [243/244]

Slic3r::GUI::wxDEFINE_EVENT	(	wxEVT_NOZZLE_JUMP_UPGRADE	,
		wxCommandEvent	)

wxDEFINE_EVENT() [244/244]

Slic3r::GUI::wxDEFINE_EVENT	(	wxEVT_REFRESH_DATA	,
		wxCommandEvent	)

wxImage_to_wxBitmap_with_alpha()

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::insert(), Slic3r::GUI::BitmapCache::insert_raw_rgba(), Slic3r::GUI::BitmapCache::load_png(), Slic3r::GUI::BitmapCache::load_svg2(), and Slic3r::GUI::BitmapCache::mksolid().

Here is the call graph for this function:

Here is the caller graph for this function:

wxIMPLEMENT_CLASS() [1/3]

Slic3r::GUI::wxIMPLEMENT_CLASS	(	CameraPopup	,
		PopupWindow	)

wxIMPLEMENT_CLASS() [2/3]

Slic3r::GUI::wxIMPLEMENT_CLASS	(	ObjectTablePanel	,
		wxPanel	)

wxIMPLEMENT_CLASS() [3/3]

Slic3r::GUI::wxIMPLEMENT_CLASS	(	SliceInfoPopup	,
		PopupWindow	)

wxMakeEventFunctor()

wxEventFunctor & Slic3r::GUI::wxMakeEventFunctor	(	const int	,
		wxEventFunctorRef	func )

{
    return *func.func;
}

References Slic3r::GUI::wxEventFunctorRef::func.

xf_compose()

Transform3d Slic3r::GUI::xf_compose ( const Vec3d & t, const Vec3d & axis, const Vec3d & pivot, double deg )

static

{
    Transform3d r = Transform3d::Identity();
    if (std::abs(deg) > 1e-12 && axis.norm() > 1e-9)
        r = Transform3d(Eigen::Translation3d(pivot))
          * Transform3d(Eigen::AngleAxisd(deg * M_PI / 180.0, axis.normalized()))
          * Transform3d(Eigen::Translation3d(-pivot));
    return Transform3d(Eigen::Translation3d(t)) * r;
}

References M_PI.

Referenced by Slic3r::GUI::DesignPanel::xf_live_preview().

Here is the caller graph for this function:

zero_pressure_advance_where_disabled()

void Slic3r::GUI::zero_pressure_advance_where_disabled ( DynamicPrintConfig * filament_config )

static

{
    auto enable_pa   = filament_config->option<ConfigOptionBools>("enable_pressure_advance");
    auto pa          = filament_config->option<ConfigOptionFloats>("pressure_advance");
    auto adaptive_pa = filament_config->option<ConfigOptionBools>("adaptive_pressure_advance");
    if (!enable_pa || !pa || !adaptive_pa || pa->empty() || adaptive_pa->empty())
        return;
    // All variant keys share the variant count; widen a short one rather than index past it.
    if (pa->size() < enable_pa->size())
        pa->resize(enable_pa->size());
    if (adaptive_pa->size() < enable_pa->size())
        adaptive_pa->resize(enable_pa->size());
    for (size_t variant = 0; variant < enable_pa->size(); ++variant) {
        if (enable_pa->get_at(variant))
            continue;
        enable_pa->values[variant]   = true;
        pa->values[variant]          = 0.0;
        adaptive_pa->values[variant] = false;
    }
}

References Slic3r::ConfigOptionVector< double >::empty(), Slic3r::ConfigOptionVector< unsigned char >::empty(), Slic3r::ConfigBase::option(), Slic3r::ConfigOptionVector< double >::resize(), Slic3r::ConfigOptionVector< unsigned char >::resize(), Slic3r::ConfigOptionVector< double >::size(), Slic3r::ConfigOptionVector< unsigned char >::size(), Slic3r::ConfigOptionVector< double >::values, and Slic3r::ConfigOptionVector< unsigned char >::values.

Referenced by Slic3r::GUI::Plater::Calib_Cornering(), Slic3r::GUI::Plater::calib_input_shaping_damp(), and Slic3r::GUI::Plater::calib_input_shaping_freq().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

ABORT_WAIT_MAX_MS

int Slic3r::GUI::ABORT_WAIT_MAX_MS = 10000

constexpr

Referenced by Slic3r::GUI::BoostThreadWorker::~BoostThreadWorker().

ACCESSORY_DISPLAY_STR

const std::unordered_map<wxString, wxString> Slic3r::GUI::ACCESSORY_DISPLAY_STR

static

Initial value:

= {
    {"N3F", "AMS 2 PRO"},
    {"N3S", "AMS HT"},
    {"O2L_PC", L("Air Pump")},
    {"O2L_10B", L("Laser 10W")},
    {"O2L_40B", L("Laser 40W")},
    {"O2L_PCM", L("Cutting Module")},
    {"O2L_ACM", L("Active Cutting Module")},
    {"O2L_UCM", L("Ultrasonic Cutting Module")},
    {"O2L-AFP", L("Auto Fire Extinguishing System")},
    {"O2L-FTS", L("Filament Track Switch")},
}

                                                                          {
    {"N3F", "AMS 2 PRO"},
    {"N3S", "AMS HT"},
    {"O2L_PC", L("Air Pump")},
    {"O2L_10B", L("Laser 10W")},
    {"O2L_40B", L("Laser 40W")},
    {"O2L_PCM", L("Cutting Module")},
    {"O2L_ACM", L("Active Cutting Module")},
    {"O2L_UCM", L("Ultrasonic Cutting Module")},
    {"O2L-AFP", L("Auto Fire Extinguishing System")},
    {"O2L-FTS", L("Filament Track Switch")},
};

Referenced by Slic3r::GUI::MachineInfoPanel::update_ams_ext().

ADD_VOLUME_MENU_ITEMS

const constexpr std::array<std::pair<const char *, const char *>, 11> Slic3r::GUI::ADD_VOLUME_MENU_ITEMS

staticconstexpr

Initial value:

= {{
    
        {L("Add Part"),              "menu_add_part" },           
        {L("Add Negative Part"),     "menu_add_negative" },       
        {L("Add Modifier"),          "menu_add_modifier"},         
        {L("Add Support Blocker"),   "menu_support_blocker"},     
        {L("Add Support Enforcer"),  "menu_support_enforcer"},     
        
        {L("Add Precise Seam"),      "menu_precise_seam_center"},     
        {L("Add Precise Seam"),      "menu_precise_seam_left"},       
        {L("Add Precise Seam"),      "menu_precise_seam_right"},      
        {L("Add Precise Seam"),      "menu_precise_seam_enforced"},   
        {L("Add Precise Seam"),      "menu_precise_seam_blocked"},    
        {L("Add Precise Seam"),      "menu_precise_seam_neutral"},    
}}

                                                                                                 {{
    //       menu_item Name              menu_item bitmap name
        {L("Add Part"),              "menu_add_part" },           // ~ModelVolumeType::MODEL_PART
        {L("Add Negative Part"),     "menu_add_negative" },       // ~ModelVolumeType::NEGATIVE_VOLUME
        {L("Add Modifier"),          "menu_add_modifier"},         // ~ModelVolumeType::PARAMETER_MODIFIER
        {L("Add Support Blocker"),   "menu_support_blocker"},     // ~ModelVolumeType::SUPPORT_BLOCKER
        {L("Add Support Enforcer"),  "menu_support_enforcer"},     // ~ModelVolumeType::SUPPORT_ENFORCER
        // Precise Seam modifiers (all 6 subtypes - only first one shown in menu, others used for tree icons)
        {L("Add Precise Seam"),      "menu_precise_seam_center"},     // ~ModelVolumeType::PRECISE_SEAM_CENTER
        {L("Add Precise Seam"),      "menu_precise_seam_left"},       // ~ModelVolumeType::PRECISE_SEAM_LEFT
        {L("Add Precise Seam"),      "menu_precise_seam_right"},      // ~ModelVolumeType::PRECISE_SEAM_RIGHT
        {L("Add Precise Seam"),      "menu_precise_seam_enforced"},   // ~ModelVolumeType::PRECISE_SEAM_ENFORCED
        {L("Add Precise Seam"),      "menu_precise_seam_blocked"},    // ~ModelVolumeType::PRECISE_SEAM_BLOCKED
        {L("Add Precise Seam"),      "menu_precise_seam_neutral"},    // ~ModelVolumeType::PRECISE_SEAM_NEUTRAL
}};

Referenced by append_menu_itemm_add_(), Slic3r::GUI::MenuFactory::append_menu_items_add_volume(), and Slic3r::GUI::MenuFactory::get_volume_bitmaps().

AMS_DRY_STATUS_IMAGE_SIZE

const int Slic3r::GUI::AMS_DRY_STATUS_IMAGE_SIZE = 96

Referenced by Slic3r::GUI::AMSDryCtrWin::update_image().

AMS_FAVORITE_FILAMENT_IDS_KEY

const char* Slic3r::GUI::AMS_FAVORITE_FILAMENT_IDS_KEY = "ams_favorite_filament_ids"

static

Referenced by Slic3r::GUI::AMSMaterialsSetting::load_favorite_filament_ids(), and Slic3r::GUI::AMSMaterialsSetting::save_favorite_filament_ids().

AMS_TRAY_DEFAULT_COL

const wxColour Slic3r::GUI::AMS_TRAY_DEFAULT_COL = wxColour(255, 255, 255)

static

Referenced by Slic3r::GUI::AMSinfo::parse_ams_info(), and Slic3r::GUI::AMSinfo::parse_ext_info().

AngleResolution

const unsigned int Slic3r::GUI::AngleResolution = 64

Referenced by init_from_angle_arc().

BACKGROUND_COLOR_DARK

const ImU32 Slic3r::GUI::BACKGROUND_COLOR_DARK = IM_COL32(65, 65, 71, 255)

static

Referenced by Slic3r::GUI::IMSlider::draw_background_and_groove(), Slic3r::GUI::IMSlider::draw_colored_band(), Slic3r::GUI::IMSlider::horizontal_slider(), and Slic3r::GUI::IMSlider::vertical_slider().

BACKGROUND_COLOR_LIGHT

const ImU32 Slic3r::GUI::BACKGROUND_COLOR_LIGHT = IM_COL32(255, 255, 255, 255)

static

Referenced by Slic3r::GUI::IMSlider::draw_background_and_groove(), Slic3r::GUI::IMSlider::draw_colored_band(), Slic3r::GUI::IMSlider::horizontal_slider(), and Slic3r::GUI::IMSlider::vertical_slider().

BackGroundColor

const wxColour Slic3r::GUI::BackGroundColor = wxColour("#FFFFFF")

static

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

bed_temp_range

const int Slic3r::GUI::bed_temp_range[2] = {20, 120}

static

{20, 120};

Referenced by Slic3r::GUI::StatusBasePanel::create_temp_control().

bed_type_thumbnails

std::map<BedType, std::string> Slic3r::GUI::bed_type_thumbnails

static

Initial value:

= {
    {BedType::btPC,        "bed_cool"           },
    {BedType::btEP,        "bed_engineering"    },
    {BedType::btPEI,       "bed_high_templ"     },
    {BedType::btPTE,       "bed_pei"            },
    {BedType::btPCT,       "bed_pei_cool"       },
    {BedType::btSuperTack, "bed_cool_supertack" }
}

                                                        {
    {BedType::btPC,        "bed_cool"           },
    {BedType::btEP,        "bed_engineering"    },
    {BedType::btPEI,       "bed_high_templ"     },
    {BedType::btPTE,       "bed_pei"            },
    {BedType::btPCT,       "bed_pei_cool"       },
    {BedType::btSuperTack, "bed_cool_supertack" }
};

Referenced by Slic3r::GUI::Sidebar::get_cur_select_bed_image().

BgDisableColor

const wxColour Slic3r::GUI::BgDisableColor = wxColour("#CECECE")

static

Referenced by Slic3r::GUI::FilamentMapBtnPanel::UpdateStatus().

BgNormalColor [1/3]

const wxColour Slic3r::GUI::BgNormalColor = wxColour("#FFFFFF")

static

Referenced by Slic3r::GUI::FilamentMapManualPanel::FilamentMapManualPanel(), Slic3r::GUI::CapsuleButton::OnPaint(), Slic3r::GUI::FilamentMapBtnPanel::OnPaint(), Slic3r::GUI::PurgeModeBtnPanel::OnPaint(), Slic3r::GUI::CapsuleButton::UpdateStatus(), Slic3r::GUI::FilamentMapBtnPanel::UpdateStatus(), and Slic3r::GUI::PurgeModeBtnPanel::UpdateStatus().

BgNormalColor [2/3]

const wxColour Slic3r::GUI::BgNormalColor = wxColour("#FFFFFF")

static

BgNormalColor [3/3]

const wxColour Slic3r::GUI::BgNormalColor = wxColour("#FFFFFF")

static

BgSelectColor [1/3]

const wxColour Slic3r::GUI::BgSelectColor = wxColour("#E5F0EE")

static

Referenced by Slic3r::GUI::CapsuleButton::OnPaint(), Slic3r::GUI::FilamentMapBtnPanel::OnPaint(), Slic3r::GUI::PurgeModeBtnPanel::OnPaint(), Slic3r::GUI::CapsuleButton::UpdateStatus(), Slic3r::GUI::FilamentMapBtnPanel::UpdateStatus(), and Slic3r::GUI::PurgeModeBtnPanel::UpdateStatus().

BgSelectColor [2/3]

const wxColour Slic3r::GUI::BgSelectColor = wxColour("#E5F0EE")

static

BgSelectColor [3/3]

const wxColour Slic3r::GUI::BgSelectColor = wxColour("#E5F0EE")

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().

BorderDisableColor

const wxColour Slic3r::GUI::BorderDisableColor = wxColour("#EEEEEE")

static

BorderNormalColor [1/3]

const wxColour Slic3r::GUI::BorderNormalColor = wxColour("#CECECE")

static

Referenced by Slic3r::GUI::CapsuleButton::OnPaint(), Slic3r::GUI::FilamentMapBtnPanel::OnPaint(), and Slic3r::GUI::PurgeModeBtnPanel::OnPaint().

BorderNormalColor [2/3]

const wxColour Slic3r::GUI::BorderNormalColor = wxColour("#CECECE")

static

BorderNormalColor [3/3]

const wxColour Slic3r::GUI::BorderNormalColor = wxColour("#CECECE")

static

BorderSelectColor

const wxColour Slic3r::GUI::BorderSelectColor = wxColour("#009688")

static

Referenced by Slic3r::GUI::CapsuleButton::OnPaint().

BorderSelectedColor [1/2]

const wxColour Slic3r::GUI::BorderSelectedColor = wxColour("#009688")

static

Referenced by Slic3r::GUI::FilamentMapManualPanel::FilamentMapManualPanel(), Slic3r::GUI::FilamentMapBtnPanel::OnPaint(), and Slic3r::GUI::PurgeModeBtnPanel::OnPaint().

BorderSelectedColor [2/2]

const wxColour Slic3r::GUI::BorderSelectedColor = wxColour("#009688")

static

BRAND_COLOR

const ImU32 Slic3r::GUI::BRAND_COLOR = IM_COL32(0, 150, 136, 255)

static

Referenced by Slic3r::GUI::IMSlider::horizontal_slider(), and Slic3r::GUI::IMSlider::vertical_slider().

BRIM_EAR_RADIUS_MAX

float Slic3r::GUI::BRIM_EAR_RADIUS_MAX = 100.f

staticconstexpr

Referenced by Slic3r::GUI::GLGizmoBrimEars::get_brim_default_radius(), Slic3r::GUI::GLGizmoBrimEars::gizmo_event(), and Slic3r::GUI::GLGizmoBrimEars::on_render_input_window().

BRIM_EAR_RADIUS_MIN

float Slic3r::GUI::BRIM_EAR_RADIUS_MIN = 0.1f

staticconstexpr

Referenced by Slic3r::GUI::GLGizmoBrimEars::get_brim_default_radius(), Slic3r::GUI::GLGizmoBrimEars::gizmo_event(), and Slic3r::GUI::GLGizmoBrimEars::on_render_input_window().

btn_bg_green [1/2]

StateColor Slic3r::GUI::btn_bg_green(std::pair< wxColour, int >(wxColour(194, 194, 194), StateColor::Disabled), std::pair< wxColour, int >(wxColour(27, 136, 68), StateColor::Pressed), std::pair< wxColour, int >(wxColour(61, 203, 115), StateColor::Hovered), std::pair< wxColour, int >(wxColour(0, 177, 66), StateColor::Normal)) ( std::pair< wxColour, int > wxColour(194, 194, 194), StateColor::Disabled, std::pair< wxColour, int > wxColour(27, 136, 68), StateColor::Pressed, std::pair< wxColour, int > wxColour(61, 203, 115), StateColor::Hovered, std::pair< wxColour, int > wxColour(0, 177, 66), StateColor::Normal )

static

btn_bg_green [2/2]

StateColor Slic3r::GUI::btn_bg_green(std::pair< wxColour, int >(wxColour(206, 206, 206), StateColor::Disabled), std::pair< wxColour, int >(wxColour(0, 137, 123), StateColor::Pressed), std::pair< wxColour, int >(wxColour(38, 166, 154), StateColor::Hovered), std::pair< wxColour, int >(wxColour(0, 150, 136), StateColor::Normal)) ( std::pair< wxColour, int > wxColour(206, 206, 206), StateColor::Disabled, std::pair< wxColour, int > wxColour(0, 137, 123), StateColor::Pressed, std::pair< wxColour, int > wxColour(38, 166, 154), StateColor::Hovered, std::pair< wxColour, int > wxColour(0, 150, 136), StateColor::Normal )

static

Referenced by Slic3r::GUI::CaliPageButton::CaliPageButton(), Slic3r::GUI::EditDevNameDialog::EditDevNameDialog(), Slic3r::GUI::MultiNozzleSyncDialog::MultiNozzleSyncDialog(), Slic3r::GUI::PrinterPartsDialog::PrinterPartsDialog(), Slic3r::GUI::AmsReplaceMaterialDialog::create(), Slic3r::GUI::ConfirmBeforeSendDialog::edit_cancel_button_txt(), and Slic3r::GUI::AuxiliaryPanel::init_tabpanel().

build_commit_hash

const char *const Slic3r::GUI::build_commit_hash = GIT_COMMIT_HASH

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

build_commit_label

const char *const Slic3r::GUI::build_commit_label = GIT_COMMIT_HASH GIT_COMMIT_SUFFIX

Referenced by Slic3r::GUI::AboutDialog::AboutDialog(), Slic3r::GUI::TroubleshootDialog::TroubleshootDialog(), Slic3r::anonymous_namespace{PluginHostApp.cpp}::app_info(), Slic3r::GUI::TroubleshootDialog::GetSysInfoAll(), Slic3r::GUI::GUI_App::init_app_config(), and Slic3r::GUI::anonymous_namespace{SceneBenchmark.cpp}::SceneBenchmarkDialog::report().

BUTTON_HOVER_COL

const wxColour Slic3r::GUI::BUTTON_HOVER_COL = wxColour(0, 150, 136)

static

Referenced by Slic3r::GUI::StatusBasePanel::create_bed_control(), Slic3r::GUI::StatusBasePanel::create_extruder_control(), and Slic3r::GUI::StatusBasePanel::create_temp_control().

BUTTON_NORMAL1_COL

const wxColour Slic3r::GUI::BUTTON_NORMAL1_COL = wxColour(238, 238, 238)

static

Referenced by Slic3r::GUI::StatusBasePanel::create_bed_control(), and Slic3r::GUI::StatusBasePanel::create_extruder_control().

BUTTON_NORMAL2_COL

const wxColour Slic3r::GUI::BUTTON_NORMAL2_COL = wxColour(206, 206, 206)

static

Referenced by Slic3r::GUI::StatusBasePanel::create_bed_control().

BUTTON_PRESS_COL

const wxColour Slic3r::GUI::BUTTON_PRESS_COL = wxColour(172, 172, 172)

static

Referenced by Slic3r::GUI::StatusBasePanel::create_bed_control(), and Slic3r::GUI::StatusBasePanel::create_extruder_control().

cameraProjection

const float Slic3r::GUI::cameraProjection[16] = {1.f, 0.f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f, 0.f, 0.f, 1.f}

static

{1.f, 0.f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f, 0.f, 0.f, 1.f};

Referenced by Slic3r::GUI::GLCanvas3D::_render_3d_navigator().

cannot_input_key

std::set<int> Slic3r::GUI::cannot_input_key = {9, 10, 13, 33, 35, 36, 37, 38, 40, 41, 42, 44, 46, 47, 59, 60, 62, 63, 64, 92, 94, 95, 124, 126}

static

{9, 10, 13, 33, 35, 36, 37, 38, 40, 41, 42, 44, 46, 47, 59, 60, 62, 63, 64, 92, 94, 95, 124, 126};

Referenced by Slic3r::GUI::CreatePrinterPresetDialog::create_nozzle_diameter_item(), Slic3r::GUI::CreatePrinterPresetDialog::create_printer_item(), Slic3r::GUI::CreateFilamentPresetDialog::create_serial_item(), and Slic3r::GUI::CreateFilamentPresetDialog::create_vendor_item().

CANVAS_BORDER_COLOR

const wxColour Slic3r::GUI::CANVAS_BORDER_COLOR = wxColour(0xCECECE)

static

CANVAS_TOOLBAR_BUTTON

float Slic3r::GUI::CANVAS_TOOLBAR_BUTTON = 36.f

staticconstexpr

Referenced by Slic3r::GUI::GLCanvas3D::_render_canvas_toolbar(), canvas_corner_height(), and Slic3r::GUI::GLCanvas3D::get_canvas_toolbar_right().

CANVAS_TOOLBAR_MARGIN

float Slic3r::GUI::CANVAS_TOOLBAR_MARGIN = 10.f

staticconstexpr

Referenced by Slic3r::GUI::GLCanvas3D::_render_canvas_toolbar(), Slic3r::GUI::GLCanvas3D::_render_plate_switcher(), canvas_corner_height(), and Slic3r::GUI::GLCanvas3D::get_canvas_toolbar_right().

CANVAS_TOOLBAR_PADDING

float Slic3r::GUI::CANVAS_TOOLBAR_PADDING = 2.f

staticconstexpr

Referenced by Slic3r::GUI::GLCanvas3D::_render_canvas_toolbar(), canvas_corner_height(), and Slic3r::GUI::GLCanvas3D::get_canvas_toolbar_right().

CANVAS_TOOLBAR_SPACING

float Slic3r::GUI::CANVAS_TOOLBAR_SPACING = 6.f

staticconstexpr

Referenced by Slic3r::GUI::GLCanvas3D::_render_canvas_toolbar(), and canvas_corner_height().

check_gcode_failed_str [1/2]

auto Slic3r::GUI::check_gcode_failed_str = _u8L("Abnormal print file data: please slice again.")

static

Referenced by Slic3r::GUI::PrintJob::process(), and Slic3r::GUI::SendJob::process().

check_gcode_failed_str [2/2]

auto Slic3r::GUI::check_gcode_failed_str = _u8L("Abnormal print file data: please slice again.")

static

CIRCLE_ID

const int Slic3r::GUI::CIRCLE_ID = 300

static

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

COLOR_PICKER_MAX_GRADIENT_COLORS

std::size_t Slic3r::GUI::COLOR_PICKER_MAX_GRADIENT_COLORS = 7

inlineconstexpr

Referenced by Slic3r::GUI::anonymous_namespace{ColorPickerDialog.cpp}::color_selection_from_json(), Slic3r::GUI::anonymous_namespace{ColorPickerDialog.cpp}::normalize_color_selection(), and Slic3r::GUI::ColorPickerDialog::send_initial_state().

config_filename

const std::string Slic3r::GUI::config_filename = "test_config.3mf"

static

Referenced by Slic3r::GUI::CalibUtils::process_and_store_3mf(), Slic3r::GUI::CalibUtils::send_to_print(), and Slic3r::GUI::CalibUtils::send_to_print().

CONFIG_KEY_GROUP

const char* Slic3r::GUI::CONFIG_KEY_GROUP = "printhost_group"

static

Referenced by Slic3r::GUI::PrintHostSendDialog::EndModal(), Slic3r::GUI::ElegooPrintHostSendDialog::init(), and Slic3r::GUI::PrintHostSendDialog::init().

CONFIG_KEY_PATH

const char* Slic3r::GUI::CONFIG_KEY_PATH = "printhost_path"

static

Referenced by Slic3r::GUI::PrintHostSendDialog::EndModal(), Slic3r::GUI::ElegooPrintHostSendDialog::init(), Slic3r::GUI::FlashforgePrintHostSendDialog::init(), and Slic3r::GUI::PrintHostSendDialog::init().

CONFIG_KEY_STORAGE

const char* Slic3r::GUI::CONFIG_KEY_STORAGE = "printhost_storage"

static

Referenced by Slic3r::GUI::PrintHostSendDialog::EndModal(), Slic3r::GUI::ElegooPrintHostSendDialog::init(), and Slic3r::GUI::PrintHostSendDialog::init().

conflict_ids_mutex

std::mutex Slic3r::GUI::conflict_ids_mutex

static

Referenced by Slic3r::GUI::GUI_App::force_push_conflicting_preset(), and Slic3r::GUI::GUI_App::start_sync_user_preset().

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().

CTRL_STR

const std::string Slic3r::GUI::CTRL_STR

static

Initial value:

=
 
 
 
    "Ctrl"

ctrlWidth

int Slic3r::GUI::ctrlWidth = 50

constexpr

Referenced by Slic3r::GUI::OG_CustomCtrl::msw_rescale(), and Slic3r::GUI::OG_CustomCtrl::update_visibility().

CUT_PLANE_DEF_COLOR

const ColorRGBA Slic3r::GUI::CUT_PLANE_DEF_COLOR = ColorRGBA(0.9f, 0.9f, 0.9f, 0.5f)

static

Referenced by Slic3r::GUI::GLGizmoCut3D::apply_color_clip_plane_colors(), and Slic3r::GUI::GLGizmoCut3D::render_cut_plane().

CUT_PLANE_ERR_COLOR

const ColorRGBA Slic3r::GUI::CUT_PLANE_ERR_COLOR = ColorRGBA(1.0f, 0.8f, 0.8f, 0.5f)

static

Referenced by Slic3r::GUI::GLGizmoCut3D::render_cut_plane().

DEF_COLOR

const ColorRGBA Slic3r::GUI::DEF_COLOR = {0.7f, 0.7f, 0.7f, 1.f}

static

{0.7f, 0.7f, 0.7f, 1.f};

Referenced by Slic3r::GUI::GLGizmoBrimEars::render_points().

default_champer_temp_max

const int Slic3r::GUI::default_champer_temp_max = 60

static

Referenced by Slic3r::GUI::StatusBasePanel::create_temp_control().

default_champer_temp_min

const int Slic3r::GUI::default_champer_temp_min = 20

static

Referenced by Slic3r::GUI::StatusBasePanel::create_temp_control().

DEFAULT_PROJECT_NAME

const wxString Slic3r::GUI::DEFAULT_PROJECT_NAME = L("Untitled")

Referenced by Slic3r::GUI::Plater::load_gcode().

desc_fail_not_exist [1/2]

auto Slic3r::GUI::desc_fail_not_exist = _u8L("Print file not found; please slice it again and send it for printing.")

static

Referenced by Slic3r::GUI::PrintJob::process(), and Slic3r::GUI::SendJob::process().

desc_fail_not_exist [2/2]

auto Slic3r::GUI::desc_fail_not_exist = _u8L("Print file not found; please slice it again and send it for printing.")

static

desc_file_too_large [1/2]

auto Slic3r::GUI::desc_file_too_large = _u8L("The size of the print file is too large. Please adjust the file size and try again.")

static

Referenced by Slic3r::GUI::PrintJob::process(), and Slic3r::GUI::SendJob::process().

desc_file_too_large [2/2]

auto Slic3r::GUI::desc_file_too_large = _u8L("The size of the print file is too large. Please adjust the file size and try again.")

static

desc_network_error [1/2]

auto Slic3r::GUI::desc_network_error = _u8L("Check the current status of the Bambu Lab server by clicking on the link above.")

static

Referenced by Slic3r::GUI::PrintJob::process(), and Slic3r::GUI::SendJob::process().

desc_network_error [2/2]

auto Slic3r::GUI::desc_network_error = _u8L("Check the current status of the Bambu Lab server by clicking on the link above.")

static

desc_upload_ftp_failed [1/2]

auto Slic3r::GUI::desc_upload_ftp_failed = _u8L("Failed to upload print file via FTP. Please check the network status and try again.")

static

Referenced by Slic3r::GUI::PrintJob::process(), and Slic3r::GUI::SendJob::process().

desc_upload_ftp_failed [2/2]

auto Slic3r::GUI::desc_upload_ftp_failed = _u8L("Failed to upload print file via FTP. Please check the network status and try again.")

static

dialogStack

std::deque< wxDialog * > Slic3r::GUI::dialogStack

Referenced by Slic3r::GUI::DPIDialog::EndModal(), Slic3r::GUI::GUI_App::on_init_inner(), Slic3r::GUI::GUI_App::ShowDownNetPluginDlg(), and Slic3r::GUI::DPIAware< wxFrame >::ShowModal().

DISCONNECT_TEXT_COL

const wxColour Slic3r::GUI::DISCONNECT_TEXT_COL = wxColour(171, 172, 172)

static

Referenced by Slic3r::GUI::StatusBasePanel::create_axis_control(), Slic3r::GUI::StatusBasePanel::create_bed_control(), Slic3r::GUI::StatusBasePanel::create_misc_control(), Slic3r::GUI::StatusBasePanel::create_temp_control(), and Slic3r::GUI::StatusPanel::show_printing_status().

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().

dynamic_filament_list

DynamicFilamentList Slic3r::GUI::dynamic_filament_list

static

Referenced by Slic3r::GUI::Sidebar::Sidebar(), and Slic3r::GUI::Sidebar::update_dynamic_filament_list().

dynamic_lists

std::map<std::string, DynamicList*> Slic3r::GUI::dynamic_lists

static

Referenced by Slic3r::GUI::Choice::BUILD(), and Slic3r::GUI::Choice::register_dynamic_list().

dynamic_physical_filament_list

DynamicFilamentList Slic3r::GUI::dynamic_physical_filament_list(true) ( true )

static

Referenced by Slic3r::GUI::Sidebar::Sidebar(), and Slic3r::GUI::Sidebar::update_dynamic_filament_list().

EDGE_ID

const int Slic3r::GUI::EDGE_ID = 200

static

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

ERR_COLOR

const ColorRGBA Slic3r::GUI::ERR_COLOR = {1.0f, 0.3f, 0.3f, 0.5f}

static

{1.0f, 0.3f, 0.3f, 0.5f};

Referenced by Slic3r::GUI::GLGizmoBrimEars::render_points().

error_messages

const std::map<int, std::string> Slic3r::GUI::error_messages

static

Initial value:

= {
    {SendToPrinterDialog::ERROR_PIPE, L("Reconnecting the printer, the operation cannot be completed immediately, please try again later.")},
    {SendToPrinterDialog::ERROR_RES_BUSY, L("The device cannot handle more conversations. Please retry later.")},
    {SendToPrinterDialog::ERROR_TIME_OUT, L("Timeout, please try again.")},
    {SendToPrinterDialog::FILE_NO_EXIST, L("File does not exist.")},
    {SendToPrinterDialog::FILE_CHECK_ERR, L("File checksum error. Please retry.")},
    {SendToPrinterDialog::FILE_TYPE_ERR, L("Not supported on the current printer version.")},
    {SendToPrinterDialog::STORAGE_UNAVAILABLE, L("Current firmware does not support file transfer to internal storage.")},
    {SendToPrinterDialog::API_VERSION_UNSUPPORT, L("The firmware version of the printer is too low. Please update the firmware and try again.")},
    {SendToPrinterDialog::FILE_EXIST, L("The file already exists, do you want to replace it?")},
    {SendToPrinterDialog::STORAGE_SPACE_NOT_ENOUGH, L("Insufficient storage space, please clear the space and try again.")},
    {SendToPrinterDialog::FILE_CREATE_ERR, L("File creation failed, please try again.")},
    {SendToPrinterDialog::FILE_WRITE_ERR, L("File write failed, please try again.")},
    {SendToPrinterDialog::MD5_COMPARE_ERR, L("MD5 verification failed, please try again.")},
    {SendToPrinterDialog::FILE_RENAME_ERR, L("File renaming failed, please try again.")},
    {SendToPrinterDialog::SEND_ERR, L("File upload failed, please try again.")}
}

                                                     {
    {SendToPrinterDialog::ERROR_PIPE, L("Reconnecting the printer, the operation cannot be completed immediately, please try again later.")},
    {SendToPrinterDialog::ERROR_RES_BUSY, L("The device cannot handle more conversations. Please retry later.")},
    {SendToPrinterDialog::ERROR_TIME_OUT, L("Timeout, please try again.")},
    {SendToPrinterDialog::FILE_NO_EXIST, L("File does not exist.")},
    {SendToPrinterDialog::FILE_CHECK_ERR, L("File checksum error. Please retry.")},
    {SendToPrinterDialog::FILE_TYPE_ERR, L("Not supported on the current printer version.")},
    {SendToPrinterDialog::STORAGE_UNAVAILABLE, L("Current firmware does not support file transfer to internal storage.")},
    {SendToPrinterDialog::API_VERSION_UNSUPPORT, L("The firmware version of the printer is too low. Please update the firmware and try again.")},
    {SendToPrinterDialog::FILE_EXIST, L("The file already exists, do you want to replace it?")},
    {SendToPrinterDialog::STORAGE_SPACE_NOT_ENOUGH, L("Insufficient storage space, please clear the space and try again.")},
    {SendToPrinterDialog::FILE_CREATE_ERR, L("File creation failed, please try again.")},
    {SendToPrinterDialog::FILE_WRITE_ERR, L("File write failed, please try again.")},
    {SendToPrinterDialog::MD5_COMPARE_ERR, L("MD5 verification failed, please try again.")},
    {SendToPrinterDialog::FILE_RENAME_ERR, L("File renaming failed, please try again.")},
    {SendToPrinterDialog::SEND_ERR, L("File upload failed, please try again.")}
};

Referenced by ParseErrorCode(), and Slic3r::GUI::MediaPlayCtrl::Stop().

extruder_variant_keys

std::pair<std::string, std::string> Slic3r::GUI::extruder_variant_keys[]

static

Initial value:

{
    {},                                                  
    {"print_extruder_id", "print_extruder_variant"},     
    {},                                                  
    {"", "filament_extruder_variant"},                   
    {},                                                  
    {"printer_extruder_id", "printer_extruder_variant"}, 
}

                                                            {
    {},                                                  // invalid
    {"print_extruder_id", "print_extruder_variant"},     // Preset::TYPE_PRINT
    {},                                                  // invalid
    {"", "filament_extruder_variant"},                   // Preset::TYPE_FILAMENT filament don't use id anymore
    {},                                                  // invalid
    {"printer_extruder_id", "printer_extruder_variant"}, // Preset::TYPE_PRINTER
};

Referenced by Slic3r::GUI::Tab::check_extruder_options_status(), Slic3r::GUI::Tab::switch_excluder(), Slic3r::GUI::Tab::sync_excluder(), and Slic3r::GUI::Tab::update_all_extruder_options_status().

fail_image

wxImage Slic3r::GUI::fail_image

static

Referenced by Slic3r::GUI::ScoreDialog::create_oss_thumbnail(), and Slic3r::GUI::ScoreDialog::init().

failed_in_cloud_service_str [1/2]

auto Slic3r::GUI::failed_in_cloud_service_str = _u8L("Cloud service connection failed. Please try again.")

static

Referenced by Slic3r::GUI::PrintJob::process(), and Slic3r::GUI::SendJob::process().

failed_in_cloud_service_str [2/2]

auto Slic3r::GUI::failed_in_cloud_service_str = _u8L("Cloud service connection failed. Please try again.")

static

filament_printable_error_msg

wxString Slic3r::GUI::filament_printable_error_msg

Referenced by Slic3r::GUI::GLCanvas3D::_set_warning_notification(), Slic3r::GUI::GLCanvas3D::reload_scene(), and Slic3r::GUI::Plater::validate_current_plate().

filament_types

const std::vector<std::string> Slic3r::GUI::filament_types

static

Initial value:

= {"PLA",    "rPLA",  "PLA+",      "PLA Tough", "PETG",  "ABS",    "ASA",    "FLEX",   "HIPS",   "PA",     "PACF",
                                                        "NYLON",  "PVA",   "PVB",       "PC",        "PCABS", "PCTG",   "PCCF",   "PHA",    "PP",     "PEI",    "PET",
                                                        "PETGCF", "PTBA",  "PTBA90A",   "PEEK",  "TPU93A", "TPU75D", "TPU",       "TPU92A", "TPU98A", "Misc",
                                                        "TPE",    "GLAZE", "Nylon",     "CPE",   "METAL",  "ABST",   "Carbon Fiber", "SBS"}

                                                   {"PLA",    "rPLA",  "PLA+",      "PLA Tough", "PETG",  "ABS",    "ASA",    "FLEX",   "HIPS",   "PA",     "PACF",
                                                        "NYLON",  "PVA",   "PVB",       "PC",        "PCABS", "PCTG",   "PCCF",   "PHA",    "PP",     "PEI",    "PET",
                                                        "PETGCF", "PTBA",  "PTBA90A",   "PEEK",  "TPU93A", "TPU75D", "TPU",       "TPU92A", "TPU98A", "Misc",
                                                        "TPE",    "GLAZE", "Nylon",     "CPE",   "METAL",  "ABST",   "Carbon Fiber", "SBS"};

Referenced by Slic3r::GUI::ColorDecomposeDialog::ColorDecomposeDialog(), Slic3r::GUI::EditFilamentPresetDialog::EditFilamentPresetDialog(), Slic3r::GUI::PartPlate::check_filament_printable(), Slic3r::GUI::PartPlate::check_mixture_filament_compatible(), Slic3r::GUI::PartPlate::check_mixture_of_pla_and_petg(), Slic3r::GUI::CreateFilamentPresetDialog::get_filament_presets_by_machine(), Slic3r::GUI::CreatePresetForPrinterDialog::get_visible_printer_and_compatible_filament_presets(), Slic3r::GUI::CrealityPrintHostSendDialog::init(), Slic3r::GUI::CalibrationPresetPage::is_filaments_compatiable(), Slic3r::GUI::Plater::open_filament_map_setting_dialog(), and try_pop_up_before_slice().

filament_vendors

const std::vector<std::string> Slic3r::GUI::filament_vendors

static

Initial value:

= 
    {"3Dgenius",               "3DJake",                 "3DXTECH",                "3D BEST-Q",              "3D Hero",
     "3D-Fuel",                "Aceaddity",              "AddNorth",               "Amazon Basics",          "AMOLEN",
     "Ankermake",              "Anycubic",               "Atomic",                 "AzureFilm",              "BASF",
     "Bblife",                 "BCN3D",                  "Beyond Plastic",         "California Filament",    "Capricorn",
     "CC3D",                   "colorFabb",              "Comgrow",                "Cookiecad",              "Creality",
     "CERPRiSE",               "Das Filament",           "DO3D",                   "DOW",                    "DREMC",
     "DSM",                    "Duramic",                "ELEGOO",                 "Eryone",                 "Essentium",
     "eSUN",                   "Extrudr",                "Fiberforce",             "Fiberlogy",              "FilaCube",
     "Filamentive",            "Fillamentum",            "FLASHFORGE",            "Formfutura",             "Francofil",
     "FusRock",                "FilamentOne",            "Fil X",                  "GEEETECH",               "Giantarm",
     "Gizmo Dorks",            "GreenGate3D",            "HATCHBOX",               "Hello3D",                "IC3D",
     "IEMAI",                  "IIID Max",               "INLAND",                 "iProspect",              "iSANMATE",
     "Justmaker",             "Keene Village Plastics",  "Kexcelled",              "LDO",                    "MakerBot",
     "MatterHackers",         "MIKA3D",                  "NinjaTek",               "Nobufil",                "Novamaker",
     "OVERTURE",              "OVVNYXE",                 "Polymaker",              "Priline",                "Printed Solid",
     "Protopasta",            "Prusament",               "Push Plastic",           "R3D",                    "re3D",
     "Re-pet3D",              "Recreus",                 "Regen",                  "RatRig",                 "Sain SMART",             
     "SliceWorx",             "Snapmaker",               "SnoLabs",                "Spectrum",               "SUNLU",                  
     "TTYT3D",                "Tianse",                  "UltiMaker",              "Valment",                "Verbatim",               
     "VO3D",                  "Voxelab",                 "VOXELPLA",               "YOOPAI",                 "Yousu",                  
     "Ziro",                  "Zyltech"}

    {"3Dgenius",               "3DJake",                 "3DXTECH",                "3D BEST-Q",              "3D Hero",
     "3D-Fuel",                "Aceaddity",              "AddNorth",               "Amazon Basics",          "AMOLEN",
     "Ankermake",              "Anycubic",               "Atomic",                 "AzureFilm",              "BASF",
     "Bblife",                 "BCN3D",                  "Beyond Plastic",         "California Filament",    "Capricorn",
     "CC3D",                   "colorFabb",              "Comgrow",                "Cookiecad",              "Creality",
     "CERPRiSE",               "Das Filament",           "DO3D",                   "DOW",                    "DREMC",
     "DSM",                    "Duramic",                "ELEGOO",                 "Eryone",                 "Essentium",
     "eSUN",                   "Extrudr",                "Fiberforce",             "Fiberlogy",              "FilaCube",
     "Filamentive",            "Fillamentum",            "FLASHFORGE",            "Formfutura",             "Francofil",
     "FusRock",                "FilamentOne",            "Fil X",                  "GEEETECH",               "Giantarm",
     "Gizmo Dorks",            "GreenGate3D",            "HATCHBOX",               "Hello3D",                "IC3D",
     "IEMAI",                  "IIID Max",               "INLAND",                 "iProspect",              "iSANMATE",
     "Justmaker",             "Keene Village Plastics",  "Kexcelled",              "LDO",                    "MakerBot",
     "MatterHackers",         "MIKA3D",                  "NinjaTek",               "Nobufil",                "Novamaker",
     "OVERTURE",              "OVVNYXE",                 "Polymaker",              "Priline",                "Printed Solid",
     "Protopasta",            "Prusament",               "Push Plastic",           "R3D",                    "re3D",
     "Re-pet3D",              "Recreus",                 "Regen",                  "RatRig",                 "Sain SMART",             
     "SliceWorx",             "Snapmaker",               "SnoLabs",                "Spectrum",               "SUNLU",                  
     "TTYT3D",                "Tianse",                  "UltiMaker",              "Valment",                "Verbatim",               
     "VO3D",                  "Voxelab",                 "VOXELPLA",               "YOOPAI",                 "Yousu",                  
     "Ziro",                  "Zyltech"};

Referenced by Slic3r::GUI::CreateFilamentPresetDialog::create_vendor_item().

file_is_not_exists_str [1/2]

auto Slic3r::GUI::file_is_not_exists_str = _u8L("Print file not found; please slice again.")

static

Referenced by Slic3r::GUI::PrintJob::process(), and Slic3r::GUI::SendJob::process().

file_is_not_exists_str [2/2]

auto Slic3r::GUI::file_is_not_exists_str = _u8L("Print file not found; please slice again.")

static

file_over_size_str [1/2]

auto Slic3r::GUI::file_over_size_str = _u8L("The print file exceeds the maximum allowable size (1GB). Please simplify the model and slice again.")

static

Referenced by Slic3r::GUI::PrintJob::process(), and Slic3r::GUI::SendJob::process().

file_over_size_str [2/2]

auto Slic3r::GUI::file_over_size_str = _u8L("The print file exceeds the maximum allowable size (1GB). Please simplify the model and slice again.")

static

file_wildcards_by_type

const FileWildcards Slic3r::GUI::file_wildcards_by_type[FT_SIZE]

static

Initial value:

= {
        { L("STEP files"),      { ".stp"sv, ".step"sv } },
         { L("STL files"),       { ".stl"sv } },
         { L("OBJ files"),       { ".obj"sv } },
         { L("AMF files"),       { ".amf"sv, ".zip.amf"sv, ".xml"sv } },
         { L("3MF files"),       { ".3mf"sv } },
     {L("G-code 3MF files"), {".gcode.3mf"sv}},
       { L("G-code files"),    { ".gcode"sv} },
 
 
 
 
    
    {L("Supported files"), {".3mf"sv, ".stl"sv, ".oltp"sv, ".stp"sv, ".step"sv, ".svg"sv, ".amf"sv, ".obj"sv, ".gltf"sv, ".glb"sv, ".fbx"sv, ".drc"sv}},
 
         { L("ZIP files"),       { ".zip"sv } },
     { L("Project files"),   { ".3mf"sv} },
     { L("Known files"),     { ".stl"sv, ".obj"sv } },
 
         { L("INI files"),       { ".ini"sv } },
         { L("SVG files"),       { ".svg"sv } },
         { L("Texture"),         { ".png"sv, ".svg"sv } },
         { L("Masked SLA files"), { ".sl1"sv, ".sl1s"sv } },
         { L("Draco files"),     { ".drc"sv } },
}

                                                             {
    /* FT_STEP */    { L("STEP files"),      { ".stp"sv, ".step"sv } },
    /* FT_STL */     { L("STL files"),       { ".stl"sv } },
    /* FT_OBJ */     { L("OBJ files"),       { ".obj"sv } },
    /* FT_AMF */     { L("AMF files"),       { ".amf"sv, ".zip.amf"sv, ".xml"sv } },
    /* FT_3MF */     { L("3MF files"),       { ".3mf"sv } },
    /* FT_GCODE_3MF */ {L("G-code 3MF files"), {".gcode.3mf"sv}},
    /* FT_GCODE */   { L("G-code files"),    { ".gcode"sv} },
#ifdef __APPLE__
    /* FT_MODEL */
    {L("Supported files"), {".3mf"sv, ".stl"sv, ".oltp"sv, ".stp"sv, ".step"sv, ".svg"sv, ".amf"sv, ".obj"sv, ".gltf"sv, ".glb"sv, ".fbx"sv, ".usd"sv, ".usda"sv, ".usdc"sv, ".usdz"sv, ".abc"sv, ".ply"sv, ".drc"sv}},
#else
    /* FT_MODEL */
    {L("Supported files"), {".3mf"sv, ".stl"sv, ".oltp"sv, ".stp"sv, ".step"sv, ".svg"sv, ".amf"sv, ".obj"sv, ".gltf"sv, ".glb"sv, ".fbx"sv, ".drc"sv}},
#endif
    /* FT_ZIP */     { L("ZIP files"),       { ".zip"sv } },
    /* FT_PROJECT */ { L("Project files"),   { ".3mf"sv} },
    /* FT_GALLERY */ { L("Known files"),     { ".stl"sv, ".obj"sv } },
 
    /* FT_INI */     { L("INI files"),       { ".ini"sv } },
    /* FT_SVG */     { L("SVG files"),       { ".svg"sv } },
    /* FT_TEX */     { L("Texture"),         { ".png"sv, ".svg"sv } },
    /* FT_SL1 */     { L("Masked SLA files"), { ".sl1"sv, ".sl1s"sv } },
    /* FT_DRC */     { L("Draco files"),     { ".drc"sv } },
};

Referenced by file_wildcards().

font_icons

const std::map<const wchar_t, std::string> Slic3r::GUI::font_icons

static

                                                           {
    {ImGui::PrintIconMarker       , "cog"                           },
    {ImGui::PrinterIconMarker     , "printer"                       },
    // remove sla_printer
    //{ImGui::PrinterSlaIconMarker  , "sla_printer"                   },
    {ImGui::FilamentIconMarker    , "spool"                         },
    {ImGui::MaterialIconMarker    , "blank_16"                      },
    {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"},
#if ENABLE_ENHANCED_IMGUI_SLIDER_FLOAT
    {ImGui::SliderFloatEditBtnIcon, "edit_button"                    },
#endif // ENABLE_ENHANCED_IMGUI_SLIDER_FLOAT
    {ImGui::ClipboardBtnIcon      , "copy_menu"                     },
    {ImGui::CircleButtonIcon       , "circle_paint"                  },
    {ImGui::TriangleButtonIcon     , "triangle_paint"                },
    {ImGui::FillButtonIcon         , "fill_paint"                    },
    {ImGui::HeightRangeIcon        , "height_range"                  },
    {ImGui::ConfirmIcon            , "confirm"                       },
    {ImGui::GapFillIcon            , "gap_fill"                      },
    {ImGui::FoldButtonIcon         , "im_fold"                       },
    {ImGui::UnfoldButtonIcon       , "im_unfold"                     },
    {ImGui::gCodeButtonIcon        , "im_code"                       }, //ORCA
    {ImGui::VisibleIcon            , "im_visible"                    }, //ORCA
    {ImGui::HiddenIcon             , "im_hidden"                     }, //ORCA
    {ImGui::SphereButtonIcon       , "toolbar_modifier_sphere"       },
    // dark mode icon
    {ImGui::MinimalizeDarkButton       , "notification_minimalize_dark"       },
    {ImGui::MinimalizeHoverDarkButton  , "notification_minimalize_hover_dark" },
    {ImGui::RightArrowDarkButton       , "notification_right_dark"            },
    {ImGui::RightArrowHoverDarkButton  , "notification_right_hover_dark"      },
    //{ImGui::PreferencesDarkButton      , "notification_preferences_dark"      },
    //{ImGui::PreferencesHoverDarkButton , "notification_preferences_hover_dark"},
 
    {ImGui::ClipboardBtnDarkIcon       , "copy_menu_dark"                     },
    {ImGui::CircleButtonDarkIcon       , "circle_paint_dark"                  },
    {ImGui::TriangleButtonDarkIcon     , "triangle_paint_dark"                },
    {ImGui::FillButtonDarkIcon         , "fill_paint_dark"                    },
    {ImGui::HeightRangeDarkIcon        , "height_range_dark"                  },
    {ImGui::ConfirmDarkIcon            , "confirm_dark"                       },
    {ImGui::GapFillDarkIcon            , "gap_fill_dark"                      },
    {ImGui::SphereButtonDarkIcon       , "toolbar_modifier_sphere_dark"       },
 
    {ImGui::TextSearchIcon             , "im_text_search"             },
    {ImGui::TextSearchCloseIcon        , "im_text_search_close"       },
 
    {ImGui::ExpandBtn                  , "expand_btn"                 },
    {ImGui::CollapseBtn                , "collapse_btn"               },
    {ImGui::RevertBtn                  , "revert_btn"                 },
 
    //{ImGui::HorizontalHide        , "horizontal_hide"               }, // ORCA use ExpandBtn / CollapseBtn
    //{ImGui::HorizontalShow        , "horizontal_show"               },
 
    {ImGui::CloseBlockNotifButton      , "block_notification_close"           },
    {ImGui::CloseBlockNotifHoverButton , "block_notification_close_hover"     },
 
    {ImGui::CollapseArrowIcon,            "notification_collapse"             },
    {ImGui::ExpandArrowIcon,              "notification_expand"               },
    {ImGui::OpenArrowIcon,                "notification_arrow_open"           },
};

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:

= {
    
    
}

                                                                       {
    //BBS do not use notification_clippy
    //{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

                                                                 {
    {ImGui::CloseNotifButton        , "notification_close"              },
    {ImGui::CloseNotifHoverButton   , "notification_close_hover"        },
    //BBS removed
    {ImGui::EjectButton             , "notification_eject_sd"           },
    {ImGui::EjectHoverButton        , "notification_eject_sd_hover"     },
    //{ImGui::WarningMarker           , "notification_warning"            },
    //{ImGui::ErrorMarker             , "notification_error"              },
    {ImGui::CancelButton            , "notification_cancel"             },
    {ImGui::CancelHoverButton       , "notification_cancel_hover"       },
 
//    {ImGui::SinkingObjectMarker     , "move"                            },
//    {ImGui::CustomSupportsMarker    , "toolbar_support"                    },
//    {ImGui::CustomSeamMarker        , "seam"                            },
//    {ImGui::MmuSegmentationMarker   , "mmu_segmentation"                },
//    {ImGui::VarLayerHeightMarker    , "layers"                          },
    //{ImGui::DocumentationButton     , "notification_documentation"      },
    //{ImGui::DocumentationHoverButton, "notification_documentation_hover"},
    //{ImGui::InfoMarker              , "notification_info"               },
    // dark mode icon
    {ImGui::CloseNotifDarkButton        , "notification_close_dark"              },
    {ImGui::CloseNotifHoverDarkButton   , "notification_close_hover_dark"        },
    //{ImGui::DocumentationDarkButton     , "notification_documentation_dark"      },
    //{ImGui::DocumentationHoverDarkButton, "notification_documentation_hover_dark"},
    {ImGui::BlockNotifErrorIcon,          "block_notification_error"             },
    {ImGui::PrevArrowBtnIcon,             "notification_arrow_left"              },
    {ImGui::NextArrowBtnIcon,             "notification_arrow_right"             },
    {ImGui::CompleteIcon,                 "notification_slicing_complete"        },
    {ImGui::FilamentGreen,                "filament_green"                       },
 
    {ImGui::PlayButton,                   "notification_play"                    },
    {ImGui::PlayDarkButton,               "notification_play_dark"               },
    {ImGui::PlayHoverButton,              "notification_play_hover"              },
    {ImGui::PlayHoverDarkButton,          "notification_play_hover_dark"         },
    {ImGui::PauseButton,                  "notification_pause"                   },
    {ImGui::PauseDarkButton,              "notification_pause_dark"              },
    {ImGui::PauseHoverButton,             "notification_pause_hover"             },
    {ImGui::PauseHoverDarkButton,         "notification_pause_hover_dark"        },
    {ImGui::OpenButton,                   "notification_open"                    },
    {ImGui::OpenDarkButton,               "notification_open_dark"               },
    {ImGui::OpenHoverButton,              "notification_open_hover"              },
    {ImGui::OpenHoverDarkButton,          "notification_open_hover_dark"         },
};

Referenced by Slic3r::GUI::ImGuiWrapper::init_font().

FREQ_SETTINGS_BUNDLE_FFF

SettingsFactory::Bundle Slic3r::GUI::FREQ_SETTINGS_BUNDLE_FFF

static

Initial value:

=
{
    
    { L("Quality"), { "layer_height" } },
    { L("Shell"), { "wall_loops", "top_shell_layers", "bottom_shell_layers"} },
    { L("Infill")               , { "sparse_infill_density", "sparse_infill_pattern" } },
    
    { L("Support")     , { "enable_support", "support_type", "support_threshold_angle", "support_threshold_overlap",
                                    "support_base_pattern", "support_on_build_plate_only","support_critical_regions_only",
                                    "support_remove_small_overhang",
                                    "support_base_pattern_spacing", "support_expansion"}},
    
    { L("Flush options")         , { "flush_into_infill", "flush_into_objects", "flush_into_support"} }
}

{
    //BBS
    { L("Quality"), { "layer_height" } },
    { L("Shell"), { "wall_loops", "top_shell_layers", "bottom_shell_layers"} },
    { L("Infill")               , { "sparse_infill_density", "sparse_infill_pattern" } },
    // BBS
    { L("Support")     , { "enable_support", "support_type", "support_threshold_angle", "support_threshold_overlap",
                                    "support_base_pattern", "support_on_build_plate_only","support_critical_regions_only",
                                    "support_remove_small_overhang",
                                    "support_base_pattern_spacing", "support_expansion"}},
    //BBS
    { L("Flush options")         , { "flush_into_infill", "flush_into_objects", "flush_into_support"} }
};

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_settings(), Slic3r::GUI::MenuFactory::append_menu_items_flush_options(), and create_freq_settings_popupmenu().

FREQ_SETTINGS_BUNDLE_SLA

SettingsFactory::Bundle Slic3r::GUI::FREQ_SETTINGS_BUNDLE_SLA

static

Initial value:

=
{
    
}

{
    // BBS: remove SLA freq settings
};

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_settings(), and create_freq_settings_popupmenu().

g_dialog_height

int Slic3r::GUI::g_dialog_height = 0

static

Referenced by Slic3r::GUI::ObjectTableDialog::ObjectTableDialog(), and Slic3r::GUI::ObjectTableDialog::OnClose().

g_dialog_max_height

int Slic3r::GUI::g_dialog_max_height = 0

static

Referenced by Slic3r::GUI::ObjectTableDialog::ObjectTableDialog(), Slic3r::GUI::ObjectTablePanel::OnColSize(), and Slic3r::GUI::ObjectTablePanel::OnRowSize().

g_dialog_max_width

int Slic3r::GUI::g_dialog_max_width = 0

static

Referenced by Slic3r::GUI::ObjectTableDialog::ObjectTableDialog(), Slic3r::GUI::ObjectTablePanel::OnColSize(), and Slic3r::GUI::ObjectTablePanel::OnRowSize().

g_dialog_width

int Slic3r::GUI::g_dialog_width = 0

static

Referenced by Slic3r::GUI::ObjectTableDialog::ObjectTableDialog(), and Slic3r::GUI::ObjectTableDialog::OnClose().

g_extra_height

const int Slic3r::GUI::g_extra_height = 64

static

Referenced by Slic3r::GUI::ObjectTablePanel::get_init_size().

g_max_size_from_parent

wxSize Slic3r::GUI::g_max_size_from_parent

static

Referenced by Slic3r::GUI::ObjectTableDialog::ObjectTableDialog(), Slic3r::GUI::ObjectTablePanel::OnColSize(), and Slic3r::GUI::ObjectTablePanel::OnRowSize().

g_min_row_count

const int Slic3r::GUI::g_min_row_count = 16

static

Referenced by Slic3r::GUI::ObjectTablePanel::get_init_size().

g_min_row_size

const int Slic3r::GUI::g_min_row_size = 36

static

Referenced by Slic3r::GUI::ObjectTablePanel::get_init_size().

g_min_setting_width

const int Slic3r::GUI::g_min_setting_width = 464

static

Referenced by Slic3r::GUI::ObjectTablePanel::get_init_size().

g_overflow_row_count

const int Slic3r::GUI::g_overflow_row_count = 50

static

Referenced by Slic3r::GUI::ObjectTablePanel::get_init_size().

g_vscroll_width

const int Slic3r::GUI::g_vscroll_width = 48

static

Referenced by Slic3r::GUI::ObjectTablePanel::get_init_size().

gcode_filename

const std::string Slic3r::GUI::gcode_filename = "temp.gcode"

static

Referenced by Slic3r::GUI::CalibUtils::process_and_store_3mf().

GCODE_VIEWER_SLIDER_SCALE

const float Slic3r::GUI::GCODE_VIEWER_SLIDER_SCALE = 0.6f

static

Referenced by Slic3r::GUI::GLCanvas3D::_check_and_update_toolbar_icon_scale(), Slic3r::GUI::GLCanvas3D::_render_frame(), Slic3r::GUI::GLCanvas3D::_render_gcode_overlay(), and Slic3r::GUI::GCodeViewer::sequential_view_height().

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::DesignSketchTool::render(), Slic3r::GUI::DesignSketchTool::render_mate_connectors(), Slic3r::GUI::ModelNode::UpdateEnabling(), and Slic3r::GUI::ModelNode::UpdateIcons().

GreyColor

const wxColour Slic3r::GUI::GreyColor = wxColour("#6B6B6B")

static

Referenced by Slic3r::GUI::FilamentGroupPopup::FilamentGroupPopup(), Slic3r::GUI::FilamentGroupPopup::Init(), and Slic3r::GUI::FilamentGroupPopup::MakeSmartFilamentSection().

grid_cell_border_height

const int Slic3r::GUI::grid_cell_border_height = 2

static

Referenced by Slic3r::GUI::GridCellComboBoxRenderer::Draw(), and Slic3r::GUI::GridCellFilamentsRenderer::Draw().

grid_cell_border_width

const int Slic3r::GUI::grid_cell_border_width = 2

static

Referenced by Slic3r::GUI::GridCellComboBoxRenderer::Draw(), and Slic3r::GUI::GridCellFilamentsRenderer::Draw().

grid_cell_checkbox_size

const int Slic3r::GUI::grid_cell_checkbox_size = 16

static

Referenced by wxBEGIN_EVENT_TABLE().

GROOVE_COLOR_DARK

const ImU32 Slic3r::GUI::GROOVE_COLOR_DARK = IM_COL32(45, 45, 49, 255)

static

Referenced by Slic3r::GUI::IMSlider::draw_background_and_groove(), and Slic3r::GUI::IMSlider::draw_colored_band().

GROOVE_COLOR_LIGHT

const ImU32 Slic3r::GUI::GROOVE_COLOR_LIGHT = IM_COL32(206, 206, 206, 255)

static

Referenced by Slic3r::GUI::IMSlider::draw_background_and_groove(), and Slic3r::GUI::IMSlider::draw_colored_band().

GROOVE_WIDTH

const float Slic3r::GUI::GROOVE_WIDTH = 12.0f

static

Referenced by Slic3r::GUI::IMSlider::horizontal_slider(), and Slic3r::GUI::IMSlider::vertical_slider().

GROUP_STATIC_LINE_COL

const wxColour Slic3r::GUI::GROUP_STATIC_LINE_COL = wxColour(206, 206, 206)

static

GROUP_TITLE_FONT_COL

wxColour Slic3r::GUI::GROUP_TITLE_FONT_COL = wxColour(172, 172, 172)

static

HORIZONTAL_SLIDER_WINDOW_HEIGHT

const float Slic3r::GUI::HORIZONTAL_SLIDER_WINDOW_HEIGHT = 64.0f

static

Referenced by Slic3r::GUI::IMSlider::render().

HOVER_COLOR [1/2]

const ColorRGBA Slic3r::GUI::HOVER_COLOR = {0.7f, 0.7f, 0.7f, 0.5f}

static

{0.7f, 0.7f, 0.7f, 0.5f};

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

HOVER_COLOR [2/2]

const Slic3r::ColorRGBA Slic3r::GUI::HOVER_COLOR = ColorRGBA::GREEN()

static

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().

IMEX_GHOST_ALPHA

float Slic3r::GUI::IMEX_GHOST_ALPHA = 0.55f

staticconstexpr

Referenced by Slic3r::GUI::PartPlate::update_imex_ghost_colors().

INFO_ITEMS

const std::map<InfoItemType, InfoItemAtributes> Slic3r::GUI::INFO_ITEMS

Initial value:

{
 
            { InfoItemType::CustomSupports,      {L("Support Painting"),       "toolbar_support" },     },
            
            { InfoItemType::MmSegmentation,     {L("Color Painting"),          "mmu_segmentation"},  },
            
            { InfoItemType::CutConnectors,       {L("Cut connectors"),          "cut_connectors" },    },
            { InfoItemType::FuzzySkin,           {L("Paint-on fuzzy skin"),     "objlist_fuzzy_skin_paint" }, },
}

                                                        {
//           info_item Type                         info_item Name              info_item BitmapName
            { InfoItemType::CustomSupports,      {L("Support Painting"),       "toolbar_support" },     },
            //{ InfoItemType::CustomSeam,          {L("Paint-on seam"),           "seam_" },             },
            { InfoItemType::MmSegmentation,     {L("Color Painting"),          "mmu_segmentation"},  },
            //{ InfoItemType::Sinking,             {L("Sinking"),                 "objlist_sinking"}, },
            { InfoItemType::CutConnectors,       {L("Cut connectors"),          "cut_connectors" },    },
            { InfoItemType::FuzzySkin,           {L("Paint-on fuzzy skin"),     "objlist_fuzzy_skin_paint" }, },
};

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

is_in_full_screen_mode

bool Slic3r::GUI::is_in_full_screen_mode = false

Referenced by set_tag_when_enter_full_screen(), and NSTextField(textColor)::setTextColor2:.

IsFinishFn

template<class Fn>

bool Slic3r::GUI::IsFinishFn = std::is_invocable_v<Fn, bool, std::exception_ptr&>

constexpr

IsProcessFn

template<class Fn>

bool Slic3r::GUI::IsProcessFn = std::is_invocable_v<Fn, Job::Ctl&>

constexpr

kArcFacets

int Slic3r::GUI::kArcFacets = 24

staticconstexpr

Referenced by Slic3r::GUI::DesignSketchTool::entity_polyline().

kBearChin

const Vec2d Slic3r::GUI::kBearChin[]

static

Initial value:

= {            
    {-0.2682, -0.3578}, {+0.2628, -0.3578}, {+0.2237, -0.1786},
}

                                 {            // the CHIN BAR, flat. The muzzle is relief — see kBearCrest.
    {-0.2682, -0.3578}, {+0.2628, -0.3578}, {+0.2237, -0.1786},
};

Referenced by Slic3r::GUI::DesignSketchTool::render_mate_face().

kBearCrest

const Vec3d Slic3r::GUI::kBearCrest[]

static

Initial value:

= {       
    {-0.0048, -0.1793, +0.2073},
    {-0.0048, +0.1605, +0.1279},
}

                                  {       // nose (tall) -> tail (short)
    {-0.0048, -0.1793, +0.2073},
    {-0.0048, +0.1605, +0.1279},
};

Referenced by Slic3r::GUI::DesignSketchTool::render_mate_face().

kBearMarks

const Vec3d Slic3r::GUI::kBearMarks[]

static

Initial value:

= {
    {-0.1997, +0.1760, +0.0590},
    {+0.1947, +0.1760, +0.0590},
    {+0.2797, +0.0760, +0.0380},
}

                                  {
    {-0.1997, +0.1760, +0.0590},
    {+0.1947, +0.1760, +0.0590},
    {+0.2797, +0.0760, +0.0380},
};

Referenced by Slic3r::GUI::DesignSketchTool::render_mate_face().

kBearOutline

const Vec2d Slic3r::GUI::kBearOutline[]

static

Initial value:

= {        
    {+0.3842, +0.3294}, {+0.3156, +0.4002}, {+0.2424, +0.3294},
    {-0.2524, +0.3294}, {-0.3377, +0.3877}, {-0.3693, +0.3298},
    {-0.3256, +0.2631}, {-0.4893, -0.3337}, {-0.3960, -0.4002},
    {+0.4151, -0.4002}, {+0.5000, -0.3154}, {+0.3156, +0.2631},
}

                                    {        // 12 verts, RDP eps 0.030, CCW
    {+0.3842, +0.3294}, {+0.3156, +0.4002}, {+0.2424, +0.3294},
    {-0.2524, +0.3294}, {-0.3377, +0.3877}, {-0.3693, +0.3298},
    {-0.3256, +0.2631}, {-0.4893, -0.3337}, {-0.3960, -0.4002},
    {+0.4151, -0.4002}, {+0.5000, -0.3154}, {+0.3156, +0.2631},
};

Referenced by Slic3r::GUI::DesignSketchTool::render_mate_face().

kBearPlateZ

const double Slic3r::GUI::kBearPlateZ = +0.0360

static

Referenced by Slic3r::GUI::DesignSketchTool::render_mate_face().

kBearSnoutBase

const Vec2d Slic3r::GUI::kBearSnoutBase[]

static

Initial value:

= {   
    {-0.0727, -0.2417},
    {+0.0630, -0.2417},
    {+0.0259, +0.1939},
    {-0.0356, +0.1939},
}

                                      {   // CCW from the nose end
    {-0.0727, -0.2417},
    {+0.0630, -0.2417},
    {+0.0259, +0.1939},
    {-0.0356, +0.1939},
};

Referenced by Slic3r::GUI::DesignSketchTool::render_mate_face().

kBedRow

int Slic3r::GUI::kBedRow = 1

static

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

kCadRightClickDriftPx

int Slic3r::GUI::kCadRightClickDriftPx = 3

inlineconstexpr

Referenced by Slic3r::GUI::DesignCanvas::set_on_context_menu().

kCellDip

int Slic3r::GUI::kCellDip = 20

staticconstexpr

Referenced by Slic3r::GUI::DesignRowList::cell_rect(), and Slic3r::GUI::DesignRowList::measure_row().

kCloudUrl

const char* const Slic3r::GUI::kCloudUrl = "https://cloud.orcaslicer.com"

static

Referenced by Slic3r::GUI::WebViewPanel::reset_browser(), and Slic3r::GUI::WebViewPanel::set_cloud_mode().

kDecomposeBambuPresetPrefix

const char* Slic3r::GUI::kDecomposeBambuPresetPrefix = "Bambu "

inlineconstexpr

Referenced by Slic3r::GUI::ColorDecomposeDialog::create_filament_selector(), find_decompose_standard_preset_name(), find_existing_decompose_component(), and official_basic_type_from_preset_name().

kDecomposePetgBasicType

const char* Slic3r::GUI::kDecomposePetgBasicType = "PETG Basic"

inlineconstexpr

Referenced by decompose_basic_filament_id(), decompose_basic_type_from_source(), find_existing_decompose_component(), lookup_decompose_official_component(), and official_basic_type_from_preset_name().

kDecomposePetgFilamentId

const char* Slic3r::GUI::kDecomposePetgFilamentId = "GFG00"

inlineconstexpr

Referenced by decompose_basic_filament_id(), decompose_basic_type_from_source(), find_existing_decompose_component(), and set_created_standard_component_metadata().

kDecomposePetgShortType

const char* Slic3r::GUI::kDecomposePetgShortType = "PETG"

inlineconstexpr

Referenced by decompose_basic_type_from_source(), find_existing_decompose_component(), and set_created_standard_component_metadata().

kDecomposePlaBasicType

const char* Slic3r::GUI::kDecomposePlaBasicType = "PLA Basic"

inlineconstexpr

Referenced by Slic3r::GUI::ColorDecomposeDialog::create_filament_selector(), decompose_basic_type_from_source(), find_existing_decompose_component(), official_basic_type_from_preset_name(), Slic3r::GUI::ColorDecomposeDialog::try_build_single_base_result(), and Slic3r::GUI::ColorDecomposeDialog::update_card_visibility().

kDecomposePlaFilamentId

const char* Slic3r::GUI::kDecomposePlaFilamentId = "GFA00"

inlineconstexpr

Referenced by decompose_basic_filament_id(), decompose_basic_type_from_source(), find_existing_decompose_component(), and set_created_standard_component_metadata().

kDecomposePlaShortType

const char* Slic3r::GUI::kDecomposePlaShortType = "PLA"

inlineconstexpr

Referenced by decompose_basic_type_from_source(), filament_type_for_color_decompose(), find_existing_decompose_component(), and set_created_standard_component_metadata().

kDpTokens

const DpToken Slic3r::GUI::kDpTokens[TokCount]

static

Initial value:

= {
    { wxColour(0xEC,0xEC,0xEE), wxColour(0x36,0x36,0x3C) },   
    { wxColour(0xD7,0xD7,0xDB), wxColour(0x4D,0x4D,0x54) },   
    { wxColour(0xFB,0xFB,0xFD), wxColour(0x2D,0x2D,0x30) },   
    { wxColour(0x66,0x66,0x68), wxColour(0x81,0x81,0x83) },   
    { wxColour(0x35,0x35,0x37), wxColour(0xC8,0xC8,0xC8) },   
    { wxColour(0x2C,0x2C,0x2E), wxColour(0xE0,0xE0,0xE0) },   
    { wxColour(0xA0,0xA0,0xA2), wxColour(0x80,0x80,0x80) },   
    
    
    { wxColour(0xDB,0xDB,0xDB), wxColour(0x4A,0x4A,0x51) },
}

                                           {
    { wxColour(0xEC,0xEC,0xEE), wxColour(0x36,0x36,0x3C) },   // ribbon
    { wxColour(0xD7,0xD7,0xDB), wxColour(0x4D,0x4D,0x54) },   // ribbon hover
    { wxColour(0xFB,0xFB,0xFD), wxColour(0x2D,0x2D,0x30) },   // sidebar / lists
    { wxColour(0x66,0x66,0x68), wxColour(0x81,0x81,0x83) },   // secondary text
    { wxColour(0x35,0x35,0x37), wxColour(0xC8,0xC8,0xC8) },   // control text
    { wxColour(0x2C,0x2C,0x2E), wxColour(0xE0,0xE0,0xE0) },   // list item text
    { wxColour(0xA0,0xA0,0xA2), wxColour(0x80,0x80,0x80) },   // dimmed list item
    // Prepare's control-outline grey, sampled from its sidebar: #DBDBDB on light, #4A4A51 on the
    // #2D2D31 dark panel. Every framed thing in Design uses this so the tab matches.
    { wxColour(0xDB,0xDB,0xDB), wxColour(0x4A,0x4A,0x51) },
};

Referenced by dp_retheme(), dp_tok(), make_card(), and make_spin().

kFontKey

const char* Slic3r::GUI::kFontKey = "cad_text_font"

static

Referenced by Slic3r::GUI::DesignTextDialog::DesignTextDialog(), and Slic3r::GUI::DesignTextDialog::accept().

kGapDip

int Slic3r::GUI::kGapDip = 6

staticconstexpr

Referenced by Slic3r::GUI::DesignRowList::label_rect().

kHeightKey

const char* Slic3r::GUI::kHeightKey = "cad_text_height"

static

Referenced by Slic3r::GUI::DesignTextDialog::DesignTextDialog(), and Slic3r::GUI::DesignTextDialog::accept().

kIconPx

int Slic3r::GUI::kIconPx = 16

staticconstexpr

Referenced by Slic3r::GUI::DesignRowList::load_icons().

kImexIconPx

int Slic3r::GUI::kImexIconPx = 20

staticconstexpr

Referenced by Slic3r::GUI::IMEXModesCtrl::rebuild_info_and_header().

kLeftNavWidth

const int Slic3r::GUI::kLeftNavWidth = 220 + 1

static

Referenced by Slic3r::GUI::WebViewPanel::apply_cloud_layout().

kNameColPx

int Slic3r::GUI::kNameColPx = 176

staticconstexpr

Referenced by Slic3r::GUI::IMEXModesCtrl::add_row(), and Slic3r::GUI::IMEXModesCtrl::rebuild_info_and_header().

kOfferRowCount

const int Slic3r::GUI::kOfferRowCount = 9

static

Referenced by Slic3r::GUI::DesignPanel::show_offer_menu().

kOfferRowFlat

const bool Slic3r::GUI::kOfferRowFlat[]

static

Initial value:

= {
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    true,
}

                                    {
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    true,
};

Referenced by Slic3r::GUI::DesignPanel::show_offer_menu().

kOfferRowNames

const char* const Slic3r::GUI::kOfferRowNames[]

static

Initial value:

= {
    L("Create"),
    L("Add material"),
    L("Remove"),
    L("Fillet / chamfer / draft"),
    L("Repeat"),
    L("Transform"),
    L("Reference"),
    L("Modify"),
    "Top",
}

                                            {
    L("Create"),
    L("Add material"),
    L("Remove"),
    L("Fillet / chamfer / draft"),
    L("Repeat"),
    L("Transform"),
    L("Reference"),
    L("Modify"),
    "Top",
};

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_list_verbs(), and Slic3r::GUI::DesignPanel::show_offer_menu().

kOfferVerbCount

const int Slic3r::GUI::kOfferVerbCount = 93

static

Referenced by Slic3r::GUI::DesignPanel::DesignPanel(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_list_verbs(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_run_verb(), Slic3r::GUI::DesignPanel::mcp_run_verb(), and Slic3r::GUI::DesignPanel::show_offer_menu().

kOfferVerbs

const OfferVerb Slic3r::GUI::kOfferVerbs[]

static

                                       {
    {"sketch", L_CONTEXT("Sketch", "Design"), 0, "Shift+S", "key:S+S", L("Select a flat face or a reference plane to sketch on"), 0x00000403u, 0, 0, false, false, nullptr, "design_sketch", L("Sketch on the selected flat face or plane, or click one next")},
    {"extrude", L_CONTEXT("Extrude", "Design"), 1, "Shift+E", "key:S+E", L("Create a sketch, or pick a solid face, first"), 0x00004002u, 0, 0, false, false, nullptr, "design_extrude", L("Extrude a sketch profile, or push/pull a picked face")},
    {"revolve", L_CONTEXT("Revolve", "Design"), 1, "Shift+R", "key:S+R", L("Create a sketch profile to revolve first"), 0x00004000u, 0, 0, false, false, nullptr, "design_revolve", L("Revolve a profile about an axis")},
    {"sweep", L_CONTEXT("Sweep", "Design"), 1, "Shift+W", "key:S+W", L("Create a profile sketch to sweep first"), 0x00004000u, 0, 2, false, false, nullptr, "design_sweep", L("Sweep a profile along a path")},
    {"loft", L_CONTEXT("Loft", "Design"), 1, "Shift+L", "key:S+L", L("Create at least two profile sketches to loft"), 0x00004000u, 0, 2, false, false, nullptr, "design_loft", L("Loft (skin) between two or more profiles")},
    {"thicken", L_CONTEXT("Thicken", "Design"), 1, nullptr, "fly:material#4", L("Thicken needs a solid body — add or import one first"), 0x0000000au, 1, 0, false, false, nullptr, "design_thicken", L("Offset a solid face into a thin plate (new body)")},
    {"rib", L_CONTEXT("Rib", "Design"), 1, "R", "fly:material#5", L("Rib needs a solid body — add or import one first"), 0x00010000u, 1, 0, false, false, nullptr, "design_rib", L("Grow a thin wall from an open sketch line, fused to a body")},
    {"boolean", L_CONTEXT("Join", "Design"), 1, "Shift+B", "btn:bool#0", L("Boolean needs two bodies — add or import a second one"), 0x00000200u, 2, 0, false, false, nullptr, "design_boolean", L("Fuse the tool body into the target — one solid, no seam")},
    {"bool_subtract", L_CONTEXT("Subtract", "Design"), 1, nullptr, "btn:bool#1", L("Boolean needs two bodies — add or import a second one"), 0x00000200u, 2, 0, false, false, nullptr, "design_boolean", L("Cut the tool body out of the target")},
    {"bool_intersect", L_CONTEXT("Intersect", "Design"), 1, nullptr, "btn:bool#2", L("Boolean needs two bodies — add or import a second one"), 0x00000200u, 2, 0, false, false, nullptr, "design_boolean", L("Keep only where the two bodies overlap")},
    {"surf_extrude", L_CONTEXT("Surface Extrude", "Design"), 1, "Shift+G", "key:S+G", L("Create a sketch first"), 0x00004000u, 0, 0, false, false, nullptr, "design_extrude", L("Extrude a sketch into a sheet body (no end caps)")},
    {"surf_revolve", L_CONTEXT("Surface Revolve", "Design"), 1, nullptr, "fly:surface#1", L("Create a sketch profile to revolve first"), 0x00004000u, 0, 0, false, false, nullptr, "design_revolve", L("Revolve a sketch profile into a sheet body")},
    {"surf_loft", L_CONTEXT("Surface Loft", "Design"), 1, nullptr, "fly:surface#2", L("Create at least two profile sketches to loft"), 0x00004000u, 0, 2, false, false, nullptr, "design_loft", L("Loft (skin) between 2+ profiles, open (no end caps)")},
    {"surf_fill", L_CONTEXT("Surface Fill", "Design"), 1, nullptr, "fly:surface#3", L("Create a closed sketch first"), 0x00004000u, 0, 0, false, false, nullptr, "design_surface", L("Fill a sketch boundary with a smooth face")},
    {"thicken_surf", L_CONTEXT("Thicken Surface", "Design"), 1, nullptr, "fly:surface#5", L("Thicken Surface needs a surface body — make one with a Surface tool first"), 0x00000100u, 0, 0, true, false, nullptr, "design_thicken", L("Thicken a sheet body into a solid")},
    {"hole", L_CONTEXT("Hole", "Design"), 2, "Shift+H", "key:S+H", L("Pick a face or a plane to drill into"), 0x00000402u, 1, 0, false, false, nullptr, "design_hole", L("Drill a hole, centered on a picked face or placed on a plane")},
    {"thread", L_CONTEXT("Thread", "Design"), 2, "Shift+T", "key:S+T", L("Pick a cylindrical surface (bore / outer) or a circular edge for a thread"), 0x00000024u, 1, 0, false, false, nullptr, "design_thread", L("Thread a cylindrical surface (inner bore / outer) or a circular edge")},
    {"shell", L_CONTEXT("Shell", "Design"), 2, "Shift+K", "key:S+K", L("Shell needs a solid body — add or import one first"), 0x00000082u, 1, 0, false, false, nullptr, "design_shell", L("Hollow the body to a wall thickness, opening a picked face")},
    {"cut", L_CONTEXT("Cut", "Design"), 2, "Shift+X", "key:S+X", L("Cut needs a solid body — add or import one first"), 0x000004feu, 1, 0, false, false, nullptr, "design_cut", L("Trim the body with a plane — drag the offset arrow; keep one half or both")},
    {"split", L_CONTEXT("Split", "Design"), 2, nullptr, nullptr, L("Split needs a solid body — add or import one first"), 0x000000feu, 1, 0, false, false, nullptr, nullptr, L("Split the body along a picked face into two solids")},
    {"fillet", L_CONTEXT("Fillet", "Design"), 3, "Shift+F", "btn:dress#0", L("Pick an edge to round"), 0x000000b2u, 1, 0, false, false, nullptr, "design_filletedge", L("Pick an edge, then drag the radius arrow or type it")},
    {"chamfer", L_CONTEXT("Chamfer", "Design"), 3, nullptr, "btn:dress#1", L("Pick an edge to bevel"), 0x000000b2u, 1, 0, false, false, nullptr, "design_chamfer", L("Pick an edge, then drag the distance arrow or type it")},
    {"draft", L_CONTEXT("Draft", "Design"), 3, "Shift+D", "key:S+D", L("Pick a face to taper"), 0x0000000au, 1, 0, false, false, nullptr, "design_draft", L("Tilt a picked face by a draft angle")},
    {"surf_offset", L_CONTEXT("Surface Offset", "Design"), 3, nullptr, "fly:surface#4", L("Surface Offset needs a surface body — make one with a Surface tool first"), 0x00000100u, 0, 0, true, false, nullptr, "design_offset", L("Offset a sheet body's shell by a signed distance")},
    {"pattern", L_CONTEXT("Linear pattern", "Design"), 4, "Shift+N", "btn:pat#0", L("Pattern needs a solid body — add or import one first"), 0x00006082u, 1, 0, false, false, nullptr, "design_array", L("Repeat the body along a direction — drag the spacing, set the count")},
    {"pattern_circular", L_CONTEXT("Circular pattern", "Design"), 4, nullptr, "btn:pat#1", L("Pattern needs a solid body — add or import one first"), 0x00006082u, 1, 0, false, false, nullptr, "design_polararray", L("Repeat the body around an axis — set the count and sweep")},
    {"mirror", L_CONTEXT("Mirror", "Design"), 4, "Shift+Z", "key:S+Z", L("Mirror needs a body — add or import one first"), 0x000004feu, 1, 0, false, false, nullptr, "design_mirror", L("Reflect a body about a plane")},
    {"pat_curve", L_CONTEXT("Pattern on Curve", "Design"), 4, nullptr, nullptr, L("Pattern on Curve needs a body and a curve"), 0x00000090u, 1, 0, false, false, nullptr, nullptr, L("Repeat the body along a picked curve")},
    {"transform", L_CONTEXT("Move", "Design"), 5, "Shift+Y", "key:S+Y", L("Transform needs a body — add or import one first"), 0x000021feu, 1, 0, false, false, nullptr, "design_move", L("Move and/or rotate an existing body")},
    {"mate", L_CONTEXT("Mate", "Design"), 5, nullptr, "fly:placement#2", L("Mate needs two coordinate systems — create them first"), 0x00001202u, 2, 0, false, false, nullptr, "design_c_coincident", L("Assembly: align two coordinate systems (fastened, planar, revolute, slider, cylindrical)")},
    {"align", L_CONTEXT("Align to", "Design"), 5, nullptr, nullptr, L("Align needs a body — add or import one first"), 0x00000002u, 1, 0, false, false, nullptr, nullptr, L("Align the body to a picked face or plane")},
    {"plane", L_CONTEXT("Plane", "Design"), 6, "Shift+P", "key:S+P", nullptr, 0x00000453u, 0, 0, false, false, nullptr, "design_plane", L("Reference plane (offset / tilt / midplane / tangent / two edges / coincident)")},
    {"axis", L_CONTEXT("Axis", "Design"), 6, "Shift+A", "key:S+A", nullptr, 0x00000057u, 0, 0, false, false, nullptr, "design_line", L("Datum axis (two points, face normal, cylinder centerline, two planes, along edge)")},
    {"coordsys_v", L_CONTEXT("Coordinate system", "Design"), 6, "Shift+C", "key:S+C", nullptr, 0x00000043u, 0, 0, false, false, nullptr, "design_point", L("Datum coordinate system (world point, or face + direction edge)")},
    {"helix", L_CONTEXT("Helix", "Design"), 6, nullptr, "fly:plane#3", nullptr, 0x00000405u, 0, 0, false, false, nullptr, "design_thread", L("Helical curve (spring path) — use as a sweep path for coils / springs / augers")},
    {"project", L_CONTEXT("Project", "Design"), 6, nullptr, "fly:plane#4", L("Project needs a body — add or import one first"), 0x00000482u, 1, 0, false, false, nullptr, "design_sketch", L("Project body edges onto a plane as sketch entities")},
    {"measure", L_CONTEXT("Measure", "Design"), 6, nullptr, nullptr, nullptr, 0x000b03feu, 0, 0, false, false, nullptr, nullptr, L("Measure between the picked points, edges or faces")},
    {"mass_props", L_CONTEXT("Volume and area", "Design"), 6, nullptr, "btn:mass", nullptr, 0x000000feu, 1, 0, false, false, nullptr, "info", L("Report the volume and surface area of the selected body")},
    {"interference", L_CONTEXT("Interference", "Design"), 6, nullptr, "btn:interference", L("Interference needs at least two bodies"), 0x00000280u, 2, 0, false, false, nullptr, nullptr, L("Check whether two bodies overlap — reports, changes nothing")},
    {"edit_feature", L_CONTEXT("Edit", "Design"), 7, nullptr, "btn:edit", nullptr, 0x00007d8eu, 0, 0, false, false, nullptr, "design_edit", L("Reopen the selected feature to change what it was made from")},
    {"rename", L_CONTEXT("Rename…", "Design"), 8, "F2", "btn:rename", L("Select a feature, or a body, to rename it"), 0x00004080u, 0, 0, false, false, nullptr, nullptr, L("Give this feature a name you will recognise in the tree (a body takes its name from the feature that makes it)")},
    {"delete_face", L_CONTEXT("Delete Face", "Design"), 7, nullptr, "fly:dressup#3", L("Delete Face needs a body — add or import one first"), 0x0000000eu, 1, 0, false, false, nullptr, "design_delete", L("Remove faces from a body and heal the solid")},
    {"colour", L_CONTEXT("Color", "Design"), 8, nullptr, "btn:colour", nullptr, 0x000001feu, 1, 0, false, false, nullptr, "color_palette", L("Set the selected body's display color")},
    {"zoom_to", L_CONTEXT("Zoom to selection", "Design"), 8, nullptr, "btn:zoom_to", nullptr, 0x000041feu, 0, 0, false, false, nullptr, "design_zoom", L("Frame the selection in the view, keeping the view direction")},
    {"delete", L_CONTEXT("Delete", "Design"), 7, "Del", "btn:delete", nullptr, 0x000f7c00u, 0, 0, false, false, nullptr, "design_delete", L("Delete what is selected")},
    {"delete_body", L_CONTEXT("Delete Body", "Design"), 7, nullptr, "btn:delete_body", nullptr, 0x000001feu, 1, 0, false, false, nullptr, "design_delete", L("Delete this whole body — removes the feature it was made from")},
    {"sk_line_t", L_CONTEXT("Line", "Design"), 0, "L", "key:L", nullptr, 0x000f8000u, 0, 0, false, true, L("Line"), "design_line", L("Line — click start, then end")},
    {"sk_polyline", L_CONTEXT("Polyline", "Design"), 0, nullptr, "fly:design_line#1", nullptr, 0x000f8000u, 0, 0, false, true, L("Line"), "design_polyline", L("Click points; click the first point to close the loop, right-click to end it open")},
    {"sk_rect", L_CONTEXT("Corner rectangle", "Design"), 0, "R", "key:R", nullptr, 0x000f8000u, 0, 0, false, true, L("Rectangle"), "design_rect", L("Rectangle — click two opposite corners")},
    {"sk_rect_center", L_CONTEXT("Center rectangle", "Design"), 0, nullptr, "fly:design_rect#1", nullptr, 0x000f8000u, 0, 0, false, true, L("Rectangle"), "design_crect", L("Click center, then a corner")},
    {"sk_rect_oblique", L_CONTEXT("Oblique rectangle", "Design"), 0, nullptr, "fly:design_rect#2", nullptr, 0x000f8000u, 0, 0, false, true, L("Rectangle"), "design_rect_oblique", L("Click two corners of one edge, then a point for the width")},
    {"sk_rect_rounded", L_CONTEXT("Rounded rectangle", "Design"), 0, nullptr, "fly:design_rect#3", nullptr, 0x000f8000u, 0, 0, false, true, L("Rectangle"), "design_rect_rounded", L("Click two opposite corners, then a point for the corner radius")},
    {"sk_circle", L_CONTEXT("Center circle", "Design"), 0, "C", "key:C", nullptr, 0x000f8000u, 0, 0, false, true, L("Circle"), "design_circle", L("Circle — click center, then radius")},
    {"sk_circle_2pt", L_CONTEXT("2-point circle", "Design"), 0, nullptr, "fly:design_circle#1", nullptr, 0x000f8000u, 0, 0, false, true, L("Circle"), "design_circle2pt", L("Click two ends of the diameter")},
    {"sk_circle_3pt", L_CONTEXT("3-point circle", "Design"), 0, nullptr, "fly:design_circle#2", nullptr, 0x000f8000u, 0, 0, false, true, L("Circle"), "design_circle3pt", L("Click three points on the circle")},
    {"sk_arc_t", L_CONTEXT("3-point arc", "Design"), 0, "A", "key:A", nullptr, 0x000f8000u, 0, 0, false, true, L("Arc"), "design_arc3pt", L("Arc — click start, end, then a point")},
    {"sk_arc_tangent", L_CONTEXT("Tangent arc", "Design"), 0, nullptr, "fly:design_arc3pt#1", nullptr, 0x000f8000u, 0, 0, false, true, L("Arc"), "design_tangentarc", L("Click start (on the last entity) then end")},
    {"sk_arc_center", L_CONTEXT("Center-point arc", "Design"), 0, nullptr, "fly:design_arc3pt#2", nullptr, 0x000f8000u, 0, 0, false, true, L("Arc"), "design_arc_center", L("Click center, then start, then a point for the end angle")},
    {"sk_slot", L_CONTEXT("Slot", "Design"), 0, "S", "key:S", nullptr, 0x000f8000u, 0, 0, false, true, L("Slot"), "design_slot", L("Slot — two centerline ends, then the width")},
    {"sk_slot_arc", L_CONTEXT("Arc slot", "Design"), 0, nullptr, "fly:design_slot#1", nullptr, 0x000f8000u, 0, 0, false, true, L("Slot"), "design_slot_arc", L("Click center, start, end, then a point for the width")},
    {"sk_ellipse", L_CONTEXT("Ellipse", "Design"), 0, "E", "key:E", nullptr, 0x000f8000u, 0, 0, false, true, L("Ellipse"), "design_ellipse", L("Ellipse — center, major end, minor point")},
    {"sk_ellipse_arc", L_CONTEXT("Elliptical arc", "Design"), 0, nullptr, "fly:design_ellipse#1", nullptr, 0x000f8000u, 0, 0, false, true, L("Ellipse"), "design_ellipse_arc", L("Click center, major-axis end, minor point, then arc start and end")},
    {"sk_spline", L_CONTEXT("Spline", "Design"), 0, "B", "key:B", nullptr, 0x000f8000u, 0, 0, false, true, nullptr, "design_bspline", L("Spline — click control points")},
    {"sk_poly_3", L_CONTEXT("Triangle", "Design"), 0, nullptr, "btn:poly#3", nullptr, 0x000f8000u, 0, 0, false, true, L("Polygon"), "design_polygon", L("Triangle — click center, then a vertex")},
    {"sk_poly_4", L_CONTEXT("Square", "Design"), 0, nullptr, "btn:poly#4", nullptr, 0x000f8000u, 0, 0, false, true, L("Polygon"), "design_polygon", L("Square — click center, then a vertex")},
    {"sk_poly_5", L_CONTEXT("Pentagon", "Design"), 0, nullptr, "btn:poly#5", nullptr, 0x000f8000u, 0, 0, false, true, L("Polygon"), "design_polygon", L("Pentagon — click center, then a vertex")},
    {"sk_polygon", L_CONTEXT("Hexagon", "Design"), 0, "G", "btn:poly#6", nullptr, 0x000f8000u, 0, 0, false, true, L("Polygon"), "design_polygon", L("Hexagon — click center, then a vertex")},
    {"sk_poly_8", L_CONTEXT("Octagon", "Design"), 0, nullptr, "btn:poly#8", nullptr, 0x000f8000u, 0, 0, false, true, L("Polygon"), "design_polygon", L("Octagon — click center, then a vertex")},
    {"sk_poly_12", L_CONTEXT("Dodecagon", "Design"), 0, nullptr, "btn:poly#12", nullptr, 0x000f8000u, 0, 0, false, true, L("Polygon"), "design_polygon", L("Dodecagon — click center, then a vertex")},
    {"sk_poly_inscribed", L_CONTEXT("Inscribed", "Design"), 0, nullptr, "btn:polyfit#0", nullptr, 0x000f8000u, 0, 0, false, true, L("Polygon"), "design_polygon", L("Measure the polygon to its corners (inscribed)")},
    {"sk_poly_circumscribed", L_CONTEXT("Circumscribed", "Design"), 0, nullptr, "btn:polyfit#1", nullptr, 0x000f8000u, 0, 0, false, true, L("Polygon"), "design_polygon", L("Measure the polygon to its flats (circumscribed)")},
    {"sk_point_t", L_CONTEXT("Point", "Design"), 0, "P", "key:P", nullptr, 0x000f8000u, 0, 0, false, true, nullptr, "design_point", L("Point — click to place")},
    {"sk_text", L_CONTEXT("Text", "Design"), 0, nullptr, "btn:text", nullptr, 0x000f8000u, 0, 0, false, true, nullptr, "design_text", L("Type text; it becomes a Text feature on this sketch's plane, editable later")},
    {"sk_svg", L_CONTEXT("SVG", "Design"), 0, nullptr, "btn:svg", nullptr, 0x000f8000u, 0, 0, false, true, nullptr, "design_svg", L("Import an SVG outline into this sketch as editable lines")},
    {"sk_offset", L_CONTEXT("Offset", "Design"), 1, "O", "key:O", nullptr, 0x000b0000u, 0, 0, false, true, nullptr, "design_offset", L("Offset — pick an entity, drag the distance")},
    {"sk_trim", L_CONTEXT("Trim", "Design"), 2, "T", "key:T", nullptr, 0x000b0000u, 0, 0, false, true, nullptr, "design_trim", L("Trim — click a segment to trim it")},
    {"sk_fillet", L_CONTEXT("Fillet", "Design"), 3, "F", "key:F", nullptr, 0x00090000u, 0, 0, false, true, nullptr, "design_filletedge", L("Fillet — pick two lines, set the radius")},
    {"sk_chamfer", L_CONTEXT("Chamfer", "Design"), 3, "H", "key:H", nullptr, 0x00090000u, 0, 0, false, true, nullptr, "design_chamfer", L("Chamfer — pick two lines, set the distance")},
    {"sk_array", L_CONTEXT("Linear array", "Design"), 4, nullptr, "fly:design_array#0", nullptr, 0x000b0000u, 0, 0, false, true, L("Array"), "design_array", L("Pick entities, drag the spacing handle, click the count; click empty to apply")},
    {"sk_array_polar", L_CONTEXT("Polar array", "Design"), 4, nullptr, "fly:design_array#1", nullptr, 0x000b0000u, 0, 0, false, true, L("Array"), "design_polararray", L("Pick entities, drag the sweep handle, click the count; click empty to apply")},
    {"sk_mirror", L_CONTEXT("Mirror", "Design"), 4, "M", "key:M", nullptr, 0x000b0000u, 0, 0, false, true, nullptr, "design_mirror", L("Mirror — pick axis, then entities")},
    {"sk_move", L_CONTEXT("Move", "Design"), 5, nullptr, "fly:design_move#0", nullptr, 0x000f0000u, 0, 0, false, true, L("Move"), "design_move", L("Pick entities, then drag the handle or click the distance; click empty to apply")},
    {"sk_rotate", L_CONTEXT("Rotate", "Design"), 5, nullptr, "fly:design_move#1", nullptr, 0x000f0000u, 0, 0, false, true, L("Move"), "design_rotate", L("Pick entities, then drag around the pivot or click the angle; click empty to apply")},
    {"sk_scale", L_CONTEXT("Scale", "Design"), 5, nullptr, "fly:design_move#2", nullptr, 0x000f0000u, 0, 0, false, true, L("Move"), "design_scale", L("Pick entities, then drag the handle or click the factor; click empty to apply")},
    {"sk_dimension", L_CONTEXT("Dimension", "Design"), 6, "D", "key:D", nullptr, 0x000f8000u, 0, 0, false, true, nullptr, "design_dimension", L("Dimension — click 2 points or an entity")},
    {"sk_constrain", L_CONTEXT("Constrain", "Design"), 6, "K", "key:K", nullptr, 0x000f0000u, 0, 0, false, true, nullptr, "design_constrain", L("Constrain the selected sketch entities to each other")},
    // Same verb, model-mode vocabulary: offered when a SKETCH is selected (bit 14, SkLoop), the
    // state a user is in right after finishing one. Without this row the only way in was the
    // toolbar icon, and constraints read as absent — see the Onshape-comparison report.
    // It sits in the Reference row, the address the sketch-mode Constrain has: one verb, one row.
    {"constrain", L_CONTEXT("Constrain sketch", "Design"), 6, nullptr, "btn:constrain", L("Select a sketch to constrain it"), 0x00004000u, 0, 1, false, false, nullptr, "design_constrain", L("Add dimensions and relations (coincident, tangent, parallel...) to the selected sketch")},
    {"sk_construct", L_CONTEXT("Construction", "Design"), 6, "Q", "key:Q", nullptr, 0x000b8000u, 0, 0, false, true, nullptr, nullptr, L("Toggle construction: geometry that guides but is never built")},
    {"sk_extend", L_CONTEXT("Extend", "Design"), 7, "X", "key:X", nullptr, 0x000b0000u, 0, 0, false, true, nullptr, "design_extend", L("Extend — click a line/arc to extend it")},
    {"sk_delete", L_CONTEXT("Delete", "Design"), 7, "Del", "btn:sk_delete", nullptr, 0x000f0000u, 0, 0, false, true, nullptr, "design_delete", L("Delete the selected sketch entities")},
    // Typing the defining number of the element you pointed at. Three rows rather than one so
    // each names the quantity in the drawing-office word for THAT element; all three land on
    // the same handler, because dimension_kind() already resolves the quantity from the
    // selection. Without these, an element's own numbers were reachable only by arming the
    // Dimension tool and re-picking geometry that was already selected.
    {"sk_length", L_CONTEXT("Length…", "Design"), 7, "V", "key:V", nullptr, 0x00010000u, 0, 0, false, true, nullptr, "design_dimension", L("Type the length of this line")},
    {"sk_radius", L_CONTEXT("Radius / diameter…", "Design"), 7, "V", "key:V", nullptr, 0x00020000u, 0, 0, false, true, nullptr, "design_dimension", L("Type the radius of this arc, or the diameter of this circle")},
    {"sk_angdist", L_CONTEXT("Angle / distance…", "Design"), 7, "V", "key:V", nullptr, 0x00080000u, 0, 0, false, true, nullptr, "design_dimension", L("Type the angle between two lines, or the distance between the two picks")},
};

Referenced by Slic3r::GUI::DesignPanel::DesignPanel(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_list_verbs(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_run_verb(), Slic3r::GUI::DesignPanel::mcp_run_verb(), and Slic3r::GUI::DesignPanel::show_offer_menu().

kOrcaSourceKey

const char* Slic3r::GUI::kOrcaSourceKey = "orca"

inlineconstexpr

Referenced by Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::CommandAction::CommandAction(), Slic3r::GUI::anonymous_namespace{ActionRegistry.cpp}::PlateAction::PlateAction(), Slic3r::GUI::anonymous_namespace{ActionRegistry.cpp}::RecentProjectAction::RecentProjectAction(), Slic3r::GUI::anonymous_namespace{ActionRegistry.cpp}::SettingAction::SettingAction(), Slic3r::GUI::anonymous_namespace{ActionRegistry.cpp}::PlateAction::id_for(), Slic3r::GUI::anonymous_namespace{ActionRegistry.cpp}::RecentProjectAction::id_for(), and Slic3r::GUI::ActionRegistry::relocalize_builtins().

kOrcaSourceName

const char* Slic3r::GUI::kOrcaSourceName = "OrcaSlicer"

inlineconstexpr

Referenced by Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::CommandAction::CommandAction(), and Slic3r::GUI::ActionRegistry::materialize_plate_actions().

kOriginRow

int Slic3r::GUI::kOriginRow = 0

staticconstexpr

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

kPadDip

int Slic3r::GUI::kPadDip = 4

staticconstexpr

Referenced by Slic3r::GUI::DesignRowList::cell_rect(), Slic3r::GUI::DesignRowList::label_rect(), and Slic3r::GUI::DesignRowList::OnDrawItem().

kSidebarContextMenuFilamentId

int Slic3r::GUI::kSidebarContextMenuFilamentId = -2

inlineconstexpr

Referenced by Slic3r::GUI::MenuFactory::create_filament_action_menu(), and Slic3r::GUI::Sidebar::decompose_filament_color().

label_scale_values

const char* Slic3r::GUI::label_scale_values[2][3]

static

Initial value:

= {
{ "##scale_x", "##scale_y", "##scale_z"},
{ "##size_x", "##size_y", "##size_z"}
}

                                              {
{ "##scale_x", "##scale_y", "##scale_z"},
{ "##size_x", "##size_y", "##size_z"}
};

Referenced by Slic3r::GUI::GizmoObjectManipulation::do_render_scale_input_window().

label_values

const char* Slic3r::GUI::label_values[3][3]

static

Initial value:

= {
{ "##position_x", "##position_y", "##position_z"},
{ "##rotation_x", "##rotation_y", "##rotation_z"},
{ "##absolute_rotation_x", "##absolute_rotation_y", "##absolute_rotation_z"}
}

                                        {
{ "##position_x", "##position_y", "##position_z"},
{ "##rotation_x", "##rotation_y", "##rotation_z"},
{ "##absolute_rotation_x", "##absolute_rotation_y", "##absolute_rotation_z"}
};

Referenced by Slic3r::GUI::GizmoObjectManipulation::do_render_move_window(), and Slic3r::GUI::GizmoObjectManipulation::do_render_rotate_window().

LabelDisableColor

const wxColour Slic3r::GUI::LabelDisableColor = wxColour("#ACACAC")

static

Referenced by Slic3r::GUI::FilamentGroupPopup::Init().

LabelEnableColor

const wxColour Slic3r::GUI::LabelEnableColor = wxColour("#262E30")

static

Referenced by Slic3r::GUI::FilamentGroupPopup::FilamentGroupPopup(), and Slic3r::GUI::FilamentGroupPopup::Init().

last_directory

std::string Slic3r::GUI::last_directory = ""

static

Referenced by Slic3r::GUI::CreatePrinterPresetDialog::load_model_stl(), and Slic3r::GUI::CreatePrinterPresetDialog::load_texture().

layer_height

std::string Slic3r::GUI::layer_height = "layer_height"

static

Referenced by Slic3r::GUI::TabPrintLayer::TabPrintLayer(), Slic3r::GUI::GLCanvas3D::_render_sla_slices(), adjust_settings_for_flowrate_calib(), Slic3r::GUI::CalibUtils::calib_flowrate(), Slic3r::GUI::CalibUtils::calib_max_vol_speed(), Slic3r::GUI::Plater::calib_max_vol_speed(), Slic3r::GUI::CalibUtils::calib_retraction(), Slic3r::GUI::Plater::calib_retraction(), Slic3r::GUI::CalibUtils::calib_VFA(), Slic3r::GUI::Plater::calib_VFA(), Slic3r::GUI::ConfigManipulation::check_layer_height(), Slic3r::GUI::ObjectList::del_settings_from_config(), Slic3r::GUI::ObjectList::edit_layer_range(), Slic3r::GUI::PartPlate::estimate_wipe_tower_footprint(), generate_max_speed_parameter_value(), Slic3r::GUI::CreatePrinterPresetDialog::generate_process_presets_data(), Slic3r::GUI::ObjectList::get_default_layer_config(), Slic3r::GUI::IMSlider::get_label(), Slic3r::GUI::LayerRangeEditor::get_value(), Slic3r::GUI::TabPrintLayer::notify_changed(), Slic3r::GUI::TabPrintLayer::update_custom_dirty(), Slic3r::GUI::ConfigManipulation::update_print_fff_config(), and update_speed_parameter().

LayerIcon

char Slic3r::GUI::LayerIcon[] = "height_range_layer"

staticconstexpr

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

LayerRootIcon

char Slic3r::GUI::LayerRootIcon[] = "height_range_modifier"

staticconstexpr

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

LEFT_MARGIN

const float Slic3r::GUI::LEFT_MARGIN = 13.0f + 100.0f

static

Referenced by Slic3r::GUI::IMSlider::render().

LEFT_OFFSET

const int Slic3r::GUI::LEFT_OFFSET = 2

Referenced by Slic3r::GUI::MaterialItem::doRender(), and Slic3r::GUI::MaterialSyncItem::get_real_offset().

LeftExtruderIdx

const int Slic3r::GUI::LeftExtruderIdx = 0

static

Referenced by Slic3r::GUI::ExtruderBadge::ExtruderBadge(), Slic3r::GUI::ExtruderBadge::MarkRelatedItems(), Slic3r::GUI::ExtruderBadge::SetExtruderInfo(), and Slic3r::GUI::ExtruderBadge::UnMarkRelatedItems().

legacy_preset_map

const std::unordered_map<std::string, std::pair<std::string, std::string> > Slic3r::GUI::legacy_preset_map

static

Initial value:

{{
}}

                                                                                          {{
}};

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

license_list

const std::vector< std::string > Slic3r::GUI::license_list

Initial value:

= {
    "",
    "CC0",
    "BY",
    "BY-SA",
    "BY-ND",
    "BY-NC",
    "BY-NC-SA",
    "BY-NC-ND",
}

                                          {
    "",
    "CC0",
    "BY",
    "BY-SA",
    "BY-ND",
    "BY-NC",
    "BY-NC-SA",
    "BY-NC-ND",
};

Referenced by Slic3r::GUI::DesignerPanel::init_license_list(), and Slic3r::GUI::DesignerPanel::on_select_license().

LockIcon

char Slic3r::GUI::LockIcon[] = "cut_"

staticconstexpr

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

LOGICAL_BED_GAP

const constexpr double Slic3r::GUI::LOGICAL_BED_GAP = 1. / 5.

staticconstexpr

Referenced by bed_stride_x(), and bed_stride_y().

login_failed_str

auto Slic3r::GUI::login_failed_str = _u8L("Login failed")

static

LOWER_PART_COLOR

const ColorRGBA Slic3r::GUI::LOWER_PART_COLOR = ColorRGBA::MAGENTA()

static

Referenced by Slic3r::GUI::GLGizmoCut3D::apply_color_clip_plane_colors(), 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(), Slic3r::GUI::ObjectDataViewModel::~ObjectDataViewModel(), Slic3r::GUI::ObjectDataViewModelNode::update_settings_digest_bitmaps(), and Slic3r::GUI::ObjectDataViewModel::UpdateBitmapForNode().

m_is_dark_mode

bool Slic3r::GUI::m_is_dark_mode = false

static

Referenced by Slic3r::GUI::ImGuiWrapper::on_change_color_mode(), Slic3r::GUI::ImGuiWrapper::push_button_disable_style(), Slic3r::GUI::ImGuiWrapper::push_cancel_button_style(), Slic3r::GUI::ImGuiWrapper::push_combo_style(), Slic3r::GUI::ImGuiWrapper::push_common_window_style(), Slic3r::GUI::ImGuiWrapper::push_confirm_button_style(), Slic3r::GUI::ImGuiWrapper::push_menu_style(), Slic3r::GUI::ImGuiWrapper::push_radio_style(), and Slic3r::GUI::ImGuiWrapper::push_toolbar_style().

m_tick_rect

ImVec4 Slic3r::GUI::m_tick_rect

static

Referenced by Slic3r::GUI::IMSlider::draw_ticks(), and Slic3r::GUI::IMSlider::vertical_slider().

m_tick_value

int Slic3r::GUI::m_tick_value = -1

static

Referenced by Slic3r::GUI::IMSlider::draw_ticks(), and Slic3r::GUI::IMSlider::vertical_slider().

MachineBedTypeString

std::string Slic3r::GUI::MachineBedTypeString[7]

static

Initial value:

= {
    "auto",
    "suprtack",
    "pc",
    "ep",
    "pei",
    "pte",
    "pct",
}

                                           {
    "auto",
    "suprtack",
    "pc",
    "ep",
    "pei",
    "pte",
    "pct",
};

Referenced by Slic3r::GUI::CalibUtils::send_to_print(), and Slic3r::GUI::CalibUtils::send_to_print().

mainframe_text_field

NSTextField* Slic3r::GUI::mainframe_text_field = nil

Referenced by set_miniaturizable(), set_title_colour_after_set_title(), and NSTextField(textColor)::setTextColor2:.

MAPPED_NOZZLE_STR_MAX_CHARS_PER_LINE

size_t Slic3r::GUI::MAPPED_NOZZLE_STR_MAX_CHARS_PER_LINE = 7

staticconstexpr

Referenced by s_wrap_mapped_nozzle_str().

marker_radii

std::array<double, 4> Slic3r::GUI::marker_radii { 9., 7., 6., 5. }

staticconstexpr

{ 9., 7., 6., 5. };

Referenced by Slic3r::GUI::GLCanvas3D::CenterOfMass::on_left_down(), and Slic3r::GUI::GLCanvas3D::CenterOfMass::render_details().

MAX_COMPONENTS

int Slic3r::GUI::MAX_COMPONENTS = 3

staticconstexpr

Referenced by Slic3r::GUI::MixedFilamentDialog::apply_uniform_label_width(), Slic3r::GUI::MixedFilamentDialog::on_add_material(), and Slic3r::GUI::MixedFilamentDialog::update_component_count_ui().

MAX_LAYER_VALUE

int Slic3r::GUI::MAX_LAYER_VALUE = INT_MAX - 1

staticconstexpr

Referenced by Slic3r::GUI::LayerNumberTextInput::LayerNumberTextInput(), Slic3r::GUI::OtherLayersSeqPanel::append_layer(), Slic3r::GUI::LayerNumberTextInput::get_layer_number(), and Slic3r::GUI::LayerNumberTextInput::set_layer_number().

MAX_PA_HISTORY_RESULTS_NUMS

const int Slic3r::GUI::MAX_PA_HISTORY_RESULTS_NUMS = 16

static

Referenced by Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

MAX_PA_K_VALUE

const double Slic3r::GUI::MAX_PA_K_VALUE = 2.0

Referenced by Slic3r::GUI::ExtrusionCalibration::check_k_n_validation(), Slic3r::GUI::ExtrusionCalibration::check_k_validation(), Slic3r::GUI::CaliPASaveManualPanel::get_result(), Slic3r::GUI::CaliPASaveP1PPanel::get_result(), is_pa_params_valid(), Slic3r::GUI::ExtrusionCalibration::on_click_save(), Slic3r::GUI::NewCalibrationHistoryDialog::on_ok(), Slic3r::GUI::EditCalibrationHistoryDialog::on_save(), Slic3r::GUI::AMSMaterialsSetting::on_select_ok(), Slic3r::GUI::CaliPASaveAutoPanel::save_to_result_from_widgets(), and Slic3r::GUI::CalibUtils::validate_input_k_value().

MEASURE_PLNE_NORMAL_OFFSET

const float Slic3r::GUI::MEASURE_PLNE_NORMAL_OFFSET = 0.05

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

MESH_IMPORT_MERGE_ANGLE_DEG

double Slic3r::GUI::MESH_IMPORT_MERGE_ANGLE_DEG = 5.0

staticconstexpr

Referenced by Slic3r::GUI::DesignPanel::on_import_mesh().

MESH_IMPORT_TOLERANCE

double Slic3r::GUI::MESH_IMPORT_TOLERANCE = 0.01

staticconstexpr

Referenced by Slic3r::GUI::DesignPanel::on_import_mesh().

MESH_IMPORT_TRIANGLE_WARN

size_t Slic3r::GUI::MESH_IMPORT_TRIANGLE_WARN = 50000

staticconstexpr

Referenced by Slic3r::GUI::DesignPanel::on_import_mesh().

message_containing_retry

std::unordered_set<std::string> Slic3r::GUI::message_containing_retry

static

Initial value:

{
    "0701-8004",
    "0701-8005",
    "0701-8007",
    "0701-8012",
    "0702-8012",
    "0703-8012",
    "07FF-8012",
    "07FF-8013",
}

                                                           {
    "0701-8004",
    "0701-8005",
    "0701-8007",
    "0701-8012",
    "0702-8012",
    "0703-8012",
    "07FF-8012",
    "07FF-8013",
};

Referenced by Slic3r::GUI::DeviceErrorDialog::show_error_code().

MIN_COMPONENT_RATIO

int Slic3r::GUI::MIN_COMPONENT_RATIO = 10

staticconstexpr

Referenced by Slic3r::GUI::MixedFilamentDialog::apply_dragged_triangle_ratio(), Slic3r::GUI::MixedFilamentDialog::apply_manual_ratio(), and Slic3r::GUI::MixedFilamentDialog::create_ratio_slider().

MIN_LAYER_VALUE

int Slic3r::GUI::MIN_LAYER_VALUE = 2

staticconstexpr

Referenced by Slic3r::GUI::LayerNumberTextInput::LayerNumberTextInput(), Slic3r::GUI::OtherLayersSeqPanel::append_layer(), Slic3r::GUI::LayerNumberTextInput::is_layer_number_valid(), and Slic3r::GUI::LayerSeqInfo::operator<().

MIN_PA_K_VALUE

const double Slic3r::GUI::MIN_PA_K_VALUE = 0.0

Referenced by Slic3r::GUI::CaliPASaveManualPanel::get_result(), Slic3r::GUI::CaliPASaveP1PPanel::get_result(), is_pa_params_valid(), Slic3r::GUI::ExtrusionCalibration::on_click_save(), Slic3r::GUI::NewCalibrationHistoryDialog::on_ok(), Slic3r::GUI::EditCalibrationHistoryDialog::on_save(), Slic3r::GUI::AMSMaterialsSetting::on_select_ok(), and Slic3r::GUI::CaliPASaveAutoPanel::save_to_result_from_widgets().

MIN_PA_K_VALUE_STEP

const float Slic3r::GUI::MIN_PA_K_VALUE_STEP = 0.001

static

Referenced by is_pa_params_valid().

model_filename

const std::string Slic3r::GUI::model_filename = "test.3mf"

static

Referenced by Slic3r::GUI::Bed3D::detect_type(), Slic3r::GUI::CalibUtils::process_and_store_3mf(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::CalibUtils::send_to_print(), and Slic3r::GUI::Bed3D::set_shape().

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().

mutex_delete_cache_presets

std::mutex Slic3r::GUI::mutex_delete_cache_presets

static

Referenced by Slic3r::GUI::GUI_App::delete_preset_from_cloud(), Slic3r::GUI::GUI_App::get_delete_cache_presets_lock(), and Slic3r::GUI::GUI_App::preset_deleted_from_cloud().

NA_STR [1/4]

const wxString Slic3r::GUI::NA_STR = _L("N/A")

static

Referenced by Slic3r::GUI::NetworkTestDialog::get_dns_info(), Slic3r::GUI::CalibrationCaliPage::reset_printing_values(), Slic3r::GUI::StatusPanel::reset_printing_values(), Slic3r::GUI::NetworkTestDialog::set_default(), Slic3r::GUI::PrintingTaskPanel::update_left_time(), Slic3r::GUI::CalibrationCaliPage::update_subtask(), and Slic3r::GUI::StatusPanel::update_subtask().

NA_STR [2/4]

const wxString Slic3r::GUI::NA_STR = _L("N/A")

static

NA_STR [3/4]

wxString Slic3r::GUI::NA_STR = _L("N/A")

static

NA_STR [4/4]

const wxString Slic3r::GUI::NA_STR = _L("N/A")

static

NAVIGATOR_SIZE

float Slic3r::GUI::NAVIGATOR_SIZE = 128.f

staticconstexpr

Referenced by Slic3r::GUI::GLCanvas3D::_render_3d_navigator(), canvas_corner_height(), and Slic3r::GUI::GLCanvas3D::get_canvas_toolbar_right().

NEUTRAL_COLOR

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

static

{0.5f, 0.5f, 0.5f, 1.0f};

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

none

std::string Slic3r::GUI::none {"none"}

static

{"none"};

Referenced by Slic3r::GUI::DesignPanel::feature_faces(), preset_type_options(), and Slic3r::GUI::DesignPanel::rebuild_constraint_list().

NORMAL_FAN_TEXT_COL

const wxColour Slic3r::GUI::NORMAL_FAN_TEXT_COL = wxColour(107, 107, 107)

static

Referenced by Slic3r::GUI::StatusBasePanel::create_misc_control().

NORMAL_TEXT_COL

const wxColour Slic3r::GUI::NORMAL_TEXT_COL = wxColour(48,58,60)

static

Referenced by Slic3r::GUI::StatusBasePanel::create_axis_control(), Slic3r::GUI::StatusBasePanel::create_bed_control(), Slic3r::GUI::StatusBasePanel::create_misc_control(), and Slic3r::GUI::StatusBasePanel::create_temp_control().

not_show_fan_speed_warning_dlg

bool Slic3r::GUI::not_show_fan_speed_warning_dlg = false

static

Referenced by Slic3r::GUI::FanControlNew::check_printing_state(), and Slic3r::GUI::FanOperate::check_printing_state().

not_support_auto_pa_cali_filaments

std::vector<std::string> Slic3r::GUI::not_support_auto_pa_cali_filaments

Initial value:

= {
    "GFU03", 
    "GFU04"  
}

                                                          {
    "GFU03", // TPU 90A
    "GFU04"  // TPU 85A
};

Referenced by Slic3r::GUI::CalibUtils::is_support_auto_pa_cali().

nozzle_diameter_list

float Slic3r::GUI::nozzle_diameter_list[NOZZLE_LIST_COUNT] = {0.2, 0.4, 0.6, 0.8 }

{0.2, 0.4, 0.6, 0.8 };

Referenced by Slic3r::GUI::NewCalibrationHistoryDialog::NewCalibrationHistoryDialog(), Slic3r::GUI::CalibrationPresetPage::get_nozzle_diameter(), Slic3r::GUI::CalibrationPresetPage::get_preset_info(), Slic3r::GUI::CalibrationPresetPage::init_selection_values(), Slic3r::GUI::CalibrationPresetPage::init_with_machine(), and Slic3r::GUI::HistoryWindow::on_device_connected().

nozzle_diameter_map

std::unordered_map<std::string, float> Slic3r::GUI::nozzle_diameter_map

static

Initial value:

= {{"0.15", 0.15}, {"0.2", 0.2},   {"0.25", 0.25}, {"0.3", 0.3},
                                                                     {"0.35", 0.35}, {"0.4", 0.4},   {"0.5", 0.5},   {"0.6", 0.6},
                                                                     {"0.75", 0.75}, {"0.8", 0.8},   {"1.0", 1.0},   {"1.2", 1.2}, 
                                                                     {"1.75", 1.75}}

                                                                {{"0.15", 0.15}, {"0.2", 0.2},   {"0.25", 0.25}, {"0.3", 0.3},
                                                                     {"0.35", 0.35}, {"0.4", 0.4},   {"0.5", 0.5},   {"0.6", 0.6},
                                                                     {"0.75", 0.75}, {"0.8", 0.8},   {"1.0", 1.0},   {"1.2", 1.2}, 
                                                                     {"1.75", 1.75}};

Referenced by Slic3r::GUI::CreateFilamentPresetDialog::create_filament_preset_item(), Slic3r::GUI::CreatePrinterPresetDialog::create_page2_dialog_buttons(), Slic3r::GUI::CreatePrinterPresetDialog::generate_process_presets_data(), Slic3r::GUI::CreateFilamentPresetDialog::get_filament_presets_by_machine(), Slic3r::GUI::CreatePrinterPresetDialog::on_select_printer_model(), and Slic3r::GUI::CreateFilamentPresetDialog::sort_printer_by_nozzle().

nozzle_diameter_vec

std::vector<std::string> Slic3r::GUI::nozzle_diameter_vec = {"0.4", "0.15", "0.2", "0.25", "0.3", "0.35", "0.5", "0.6", "0.75", "0.8", "1.0", "1.2", "1.75"}

static

{"0.4", "0.15", "0.2", "0.25", "0.3", "0.35", "0.5", "0.6", "0.75", "0.8", "1.0", "1.2", "1.75"};

Referenced by Slic3r::GUI::CreatePrinterPresetDialog::create_nozzle_diameter_item().

nozzle_not_set_text

wxString Slic3r::GUI::nozzle_not_set_text = _L("The printer nozzle information has not been set.\nPlease configure it before proceeding with the calibration.")

static

Referenced by Slic3r::GUI::CalibUtils::check_printable_status_before_cali(), and Slic3r::GUI::CalibUtils::check_printable_status_before_cali().

nozzle_volume_type_not_match_text

wxString Slic3r::GUI::nozzle_volume_type_not_match_text = _L("The nozzle type does not match the actual printer nozzle type.\nPlease click the Sync button above and restart the calibration.")

static

Referenced by Slic3r::GUI::CalibUtils::check_printable_status_before_cali(), and Slic3r::GUI::CalibUtils::check_printable_status_before_cali().

ONE_LAYER_BUTTON_SIZE

const ImVec2 Slic3r::GUI::ONE_LAYER_BUTTON_SIZE = ImVec2(56.0f, 56.0f)

static

Referenced by Slic3r::GUI::IMSlider::horizontal_slider(), Slic3r::GUI::IMSlider::render(), and Slic3r::GUI::IMSlider::vertical_slider().

ONE_LAYER_MARGIN

const ImVec2 Slic3r::GUI::ONE_LAYER_MARGIN = ImVec2(20.0f, 20.0f)

static

Referenced by Slic3r::GUI::IMSlider::horizontal_slider(), Slic3r::GUI::IMSlider::render(), and Slic3r::GUI::IMSlider::vertical_slider().

orange

std::string Slic3r::GUI::orange = "#ed6b21"

static

Referenced by Slic3r::GUI::FullCompareDialog::FullCompareDialog(), Slic3r::GUI::ModelNode::ModelNode(), Slic3r::GUI::DesignSketchTool::render(), Slic3r::GUI::GLCanvas3D::render_thumbnail_internal(), and Slic3r::GUI::ModelNode::UpdateEnabling().

PA_LINE

int Slic3r::GUI::PA_LINE = 0

static

Referenced by Slic3r::GUI::CalibrationPresetPage::get_pa_cali_method().

PA_PATTERN

int Slic3r::GUI::PA_PATTERN = 1

static

Referenced by Slic3r::GUI::CalibrationPresetPage::get_pa_cali_method().

PAGE_TITLE_FONT

const wxFont Slic3r::GUI::PAGE_TITLE_FONT = Label::Body_14

static

PAGE_TITLE_FONT_COL

wxColour Slic3r::GUI::PAGE_TITLE_FONT_COL = wxColour(107, 107, 107)

static

Referenced by Slic3r::GUI::StatusBasePanel::create_machine_control_page(), Slic3r::GUI::StatusBasePanel::create_monitoring_page(), and Slic3r::GUI::PrintingTaskPanel::create_panel().

ParamsInfo

const std::map<ParamType, std::string> Slic3r::GUI::ParamsInfo

Initial value:

{
 
    { ParamType::Scalar,        "custom-gcode_single"          },
    { ParamType::Vector,        "custom-gcode_vector"          },
    { ParamType::FilamentVector,"custom-gcode_vector-index" },
}

                                              {
//    Type                      BitmapName
    { ParamType::Scalar,        "custom-gcode_single"          },
    { ParamType::Vector,        "custom-gcode_vector"          },
    { ParamType::FilamentVector,"custom-gcode_vector-index" },
};

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

percent_bg

StateColor Slic3r::GUI::percent_bg(std::pair< wxColour, int >(wxColour(255, 255, 255), StateColor::Disabled), std::pair< wxColour, int >(wxColour(255, 255, 255), StateColor::Pressed), std::pair< wxColour, int >(wxColour(255, 255, 255), StateColor::Hovered), std::pair< wxColour, int >(wxColour(255, 255, 255), StateColor::Enabled), std::pair< wxColour, int >(wxColour(255, 255, 255), StateColor::Normal))	(	std::pair< wxColour, int >	wxColour(255, 255, 255), StateColor::Disabled,
		std::pair< wxColour, int >	wxColour(255, 255, 255), StateColor::Pressed,
		std::pair< wxColour, int >	wxColour(255, 255, 255), StateColor::Hovered,
		std::pair< wxColour, int >	wxColour(255, 255, 255), StateColor::Enabled,
		std::pair< wxColour, int >	wxColour(255, 255, 255), StateColor::Normal )

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

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::init_plane_glmodel().

plate_keys

const std::vector<std::string> Slic3r::GUI::plate_keys = { "curr_bed_type", "skirt_start_angle", "first_layer_print_sequence", "first_layer_sequence_choice", "other_layers_print_sequence", "other_layers_sequence_choice", "print_sequence", "spiral_mode"}

static

{ "curr_bed_type", "skirt_start_angle", "first_layer_print_sequence", "first_layer_sequence_choice", "other_layers_print_sequence", "other_layers_sequence_choice", "print_sequence", "spiral_mode"};

Referenced by Slic3r::GUI::TabPrintPlate::TabPrintPlate(), and Slic3r::GUI::TabPrintModel::update_model_config().

PLATE_TOOLBAR_SCROLLBAR

float Slic3r::GUI::PLATE_TOOLBAR_SCROLLBAR = 14.f

staticconstexpr

Referenced by Slic3r::GUI::GLCanvas3D::_render_imgui_select_plate_toolbar(), and Slic3r::GUI::GLCanvas3D::_render_plate_switcher().

POINT_ID

const int Slic3r::GUI::POINT_ID = 100

static

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

print_canceled_str [1/2]

auto Slic3r::GUI::print_canceled_str = _u8L("Task canceled.")

static

Referenced by Slic3r::GUI::PrintJob::process(), and Slic3r::GUI::SendJob::process().

print_canceled_str [2/2]

auto Slic3r::GUI::print_canceled_str = _u8L("Task canceled.")

static

printer_model_map

const std::unordered_map<std::string, std::vector<std::string> > Slic3r::GUI::printer_model_map

static

    {{"Anker",             {"Anker M5",                   "Anker M5 All-Metal Hot End", "Anker M5C"}},
     {"Anycubic",          {"Anycubic i3 Mega S",    "Anycubic Chiron",       "Anycubic Vyper",        "Anycubic Kobra",        "Anycubic Kobra Max",
                            "Anycubic Kobra Plus",   "Anycubic 4Max Pro",     "Anycubic 4Max Pro 2",   "Anycubic Kobra 2",      "Anycubic Kobra 2 Plus",
                            "Anycubic Kobra 2 Max",  "Anycubic Kobra 2 Pro",  "Anycubic Kobra 2 Neo",  "Anycubic Kobra 3",      "Anycubic Kobra 3 Max", "Anycubic Kobra S1", "Anycubic Predator", }},
     {"Artillery",         {"Artillery Sidewinder X1",      "Artillery Genius",             "Artillery Genius Pro",         "Artillery Sidewinder X2",      "Artillery Hornet",
                            "Artillery Sidewinder X3 Pro",  "Artillery Sidewinder X3 Plus", "Artillery Sidewinder X4 Pro",  "Artillery Sidewinder X4 Plus"}},
     {"Bambulab",          {"Bambu Lab X1 Carbon", "Bambu Lab X1",        "Bambu Lab X1E",       "Bambu Lab P1P",       "Bambu Lab P1S",
                            "Bambu Lab A1 mini",   "Bambu Lab A1"}},
     {"BIQU",              {"BIQU B1",      "BIQU BX",      "BIQU Hurakan"}},
     {"Blocks",            {"BLOCKS Pro S100", "BLOCKS RD50 V2",  "BLOCKS RF50"}},
     {"Chuanying",         {"Chuanying X1"}},
     {"Co Print",          {"Co Print ChromaSet"}},
     {"Comgrow",           {"Comgrow T300", "Comgrow T500"}},
     {"CONSTRUCT3D",       {"Construct 1 XL", "Construct 1"}},
     {"Creality",          {"Creality CR-10 V2",           "Creality CR-10 Max",          "Creality CR-10 SE",           "Creality CR-6 SE",            "Creality CR-6 Max",
                            "Creality CR-M4",              "Creality Ender-3 V2",         "Creality Ender-3 V2 Neo",     "Creality Ender-3 S1",         "Creality Ender-3",
                            "Creality Ender-3 Pro",        "Creality Ender-3 S1 Pro",     "Creality Ender-3 S1 Plus",    "Creality Ender-3 V3 SE",      "Creality Ender-3 V3 KE",
                            "Creality Ender-3 V3",         "Creality Ender-3 V3 Plus",    "Creality Ender-5",            "Creality Ender-5 Max",        "Creality Ender-5 Plus",
                            "Creality Ender-5 Pro (2019)", "Creality Ender-5S",           "Creality Ender-5 S1",         "Creality Ender-6",            "Creality Sermoon V1",
                            "Creality K1",                 "Creality K1C",                "Creality K1 Max",             "Creality K1 SE",              "Creality K2 Plus",
                            "Creality Hi"}},
     {"DeltaMaker",        {"DeltaMaker 2",   "DeltaMaker 2T",  "DeltaMaker 2XT"}},
     {"Dremel",            {"Dremel 3D20", "Dremel 3D40", "Dremel 3D45"}},
     {"Elegoo",            {"Elegoo Centauri Carbon 2", "Elegoo Centauri Carbon",  "Elegoo Centauri",         "Elegoo Neptune",          "Elegoo Neptune X",        "Elegoo Neptune 2",
                            "Elegoo Neptune 2S",       "Elegoo Neptune 2D",       "Elegoo Neptune 3",        "Elegoo Neptune 3 Pro",    "Elegoo Neptune 3 Plus",
                            "Elegoo Neptune 3 Max",    "Elegoo Neptune 4 Pro",    "Elegoo Neptune 4",        "Elegoo Neptune 4 Max",    "Elegoo Neptune 4 Plus",
                            "Elegoo OrangeStorm Giga"}},
     {"Flashforge",        {"Flashforge Adventurer 5M",       "Flashforge Adventurer 5M Pro",   "Flashforge AD5X",                "Flashforge Adventurer 3 Series", "Flashforge Adventurer 4 Series",
                            "Flashforge Guider 3 Ultra",      "Flashforge Guider 2s", "Flashforge Artemis"}},
     {"FLSun",             {"FLSun Q5",               "FLSun QQ-S Pro",         "FLSun Super Racer (SR)", "FLSun V400",             "FLSun T1",
                            "FLSun S1"}},
     {"FlyingBear",        {"FlyingBear Reborn3", "FlyingBear S1",      "FlyingBear Ghost 6"}},
     {"Folgertech",        {"Folgertech i3",   "Folgertech FT-5", "Folgertech FT-6"}},
     {"Geeetech",          {"Geeetech Thunder",   "Geeetech Mizar M",   "Geeetech Mizar S",   "Geeetech Mizar Pro", "Geeetech Mizar Max",
                            "Geeetech Mizar",     "Geeetech A10 Pro",   "Geeetech A10 M",     "Geeetech A10 T",     "Geeetech A20",
                            "Geeetech A20 M",     "Geeetech A20 T",     "Geeetech A30 Pro",   "Geeetech A30 M",     "Geeetech A30 T",
                            "Geeetech M1"}},
     {"Ginger Additive",   {"ginger G1"}},
     {"InfiMech",          {"InfiMech TX",                       "InfiMech TX Hardened Steel Nozzle"}},
     {"Kingroon",          {"Kingroon KP3S PRO S1", "Kingroon KP3S PRO V2", "Kingroon KP3S 3.0",    "Kingroon KP3S V1",     "Kingroon KLP1"}},
     {"Lulzbot",           {"Lulzbot Taz 6",        "Lulzbot Taz 4 or 5",   "Lulzbot Taz Pro Dual", "Lulzbot Taz Pro S"}},
     {"MagicMaker",        {"MM hqs hj",   "MM hqs SF",   "MM hj SK",    "MM BoneKing", "MM slb"}},
     {"Mellow",            {"M1"}},
     {"Orca Arena Printer",{"Orca Arena X1 Carbon"}},
     {"Peopoly",           {"Peopoly Magneto X"}},
     {"Positron 3D",       {"The Positron"}},
     {"Prusa",             {"Prusa CORE One", "Prusa CORE One HF", "Prusa CORE One L", "Prusa CORE One L HF", "MK4IS", "MK4S", "MK4S HF",
                            "Prusa XL", "Prusa XL 5T", "MK3.5", "MK3S", "MINI", "MINIIS"}},
     {"Qidi",              {"Qidi X-Plus 4",  "Qidi Q1 Pro",    "Qidi X-Max 3",   "Qidi X-Plus 3",  "Qidi X-Smart 3",
                            "Qidi X-Plus",    "Qidi X-Max",     "Qidi X-CF Pro"}},
     {"Raise3D",           {"Raise3D Pro3",      "Raise3D Pro3 Plus"}},
     {"RatRig",            {"RatRig V-Core 3 200",                  "RatRig V-Core 3 300",                  "RatRig V-Core 3 400",                  "RatRig V-Core 3 500",                  "RatRig V-Minion",
                            "RatRig V-Cast",                        "RatRig V-Core 4 300",                  "RatRig V-Core 4 400",                  "RatRig V-Core 4 500",                  "RatRig V-Core 4 HYBRID 300",
                            "RatRig V-Core 4 HYBRID 400",           "RatRig V-Core 4 HYBRID 500",           "RatRig V-Core 4 IDEX 300",             "RatRig V-Core 4 IDEX 300 COPY MODE",   "RatRig V-Core 4 IDEX 300 MIRROR MODE",
                            "RatRig V-Core 4 IDEX 400",             "RatRig V-Core 4 IDEX 400 COPY MODE",   "RatRig V-Core 4 IDEX 400 MIRROR MODE", "RatRig V-Core 4 IDEX 500",             "RatRig V-Core 4 IDEX 500 COPY MODE",
                            "RatRig V-Core 4 IDEX 500 MIRROR MODE"}},
     {"re3D",              {"re3D Gigabot 4",                       "re3D Gigabot 4 XLT",                   "re3D Terabot 4",
                            "re3D GigabotX 2",                      "re3D GigabotX 2 XLT",                  "re3D TerabotX 2"}},
     {"RolohaunDesign",    {"Rook MK1 LDO"}},
     {"SecKit",            {"SecKit SK-Tank", "Seckit Go3"}},
     {"Snapmaker",         {"Snapmaker J1",                 "Snapmaker A250",               "Snapmaker A350",               "Snapmaker A250 Dual",          "Snapmaker A350 Dual",
                            "Snapmaker A250 QSKit",         "Snapmaker A350 QSKit",         "Snapmaker A250 BKit",          "Snapmaker A350 BKit",          "Snapmaker A250 QS+B Kit",
                            "Snapmaker A350 QS+B Kit",      "Snapmaker A250 Dual QSKit",    "Snapmaker A350 Dual QSKit",    "Snapmaker A250 Dual BKit",     "Snapmaker A350 Dual BKit",
                            "Snapmaker A250 Dual QS+B Kit", "Snapmaker A350 Dual QS+B Kit", "Snapmaker Artisan"}},
     {"Sovol",             {"Sovol SV01 Pro",      "Sovol SV02",          "Sovol SV05",          "Sovol SV06",          "Sovol SV06 Plus",
                            "Sovol SV06 ACE",      "Sovol SV06 Plus ACE", "Sovol SV07",          "Sovol SV07 Plus",     "Sovol SV08"}},
     {"Thinker X400",      {"Thinker X400"}},
     {"Tronxy",            {"Tronxy X5SA 400 Marlin Firmware"}},
     {"TwoTrees",          {"TwoTrees SP-5 Klipper", "TwoTrees SK1"}},
     {"UltiMaker",         {"UltiMaker 2"}},
     {"Vivedino",          {"Troodon 2.0 - RRF",     "Troodon 2.0 - Klipper"}},
     {"Volumic",           {"EXO42 Performance", "EXO65 Performance", "SH65 Performance",  "EXO42",             "EXO65",           
                            "SH65",              "VS30SC2",           "VS30SC",            "VS30ULTRA",         "VS30MK3",         
                            "VS30MK2",           "VS20MK2"}},
     {"Voron",             {"Voron 2.4 250",        "Voron 2.4 300",        "Voron 2.4 350",        "Voron Trident 250",    "Voron Trident 300",
                            "Voron Trident 350",    "Voron 0.1",            "Voron Switchwire 250"}},
     {"Voxelab",           {"Voxelab Aquila X2"}},
     {"Vzbot",             {"Vzbot 235 AWD", "Vzbot 330 AWD"}},
     {"Wanhao",            {"Wanhao D12-300"}},
     {"Z-Bolt",            {"Z-Bolt S300",      "Z-Bolt S300 Dual", "Z-Bolt S400",      "Z-Bolt S400 Dual", "Z-Bolt S600",
                            "Z-Bolt S600 Dual"}}};

Referenced by Slic3r::GUI::CreatePrinterPresetDialog::create_printer_item().

printer_thumbnails

std::map<std::string, std::string> Slic3r::GUI::printer_thumbnails = {}

static

{};

Referenced by Slic3r::GUI::Sidebar::update_printer_thumbnail().

printer_vendors

const std::vector<std::string> Slic3r::GUI::printer_vendors

static

Initial value:

= 
    {"Anker",              "Anycubic",           "Artillery",          "Bambulab",           "BIQU",
     "Blocks",             "Chuanying",          "Co Print",           "Comgrow",            "CONSTRUCT3D",
     "Creality",           "DeltaMaker",         "Dremel",             "Elegoo",             "Flashforge",
     "FLSun",              "FlyingBear",         "Folgertech",         "Geeetech",           "Ginger Additive",
     "InfiMech",           "Kingroon",           "Lulzbot",            "MagicMaker",         "Mellow",
     "Orca Arena Printer", "Peopoly",            "Positron 3D",        "Prusa",              "Qidi",
     "Raise3D",            "RatRig",             "re3D",               "RolohaunDesign",     "SecKit",             
     "Snapmaker",          "Sovol",              "Thinker X400",       "Tronxy",             "TwoTrees",           
     "UltiMaker",          "Vivedino",           "Volumic",            "Voron",              "Voxelab",            
     "Vzbot",              "Wanhao",             "Z-Bolt"}

    {"Anker",              "Anycubic",           "Artillery",          "Bambulab",           "BIQU",
     "Blocks",             "Chuanying",          "Co Print",           "Comgrow",            "CONSTRUCT3D",
     "Creality",           "DeltaMaker",         "Dremel",             "Elegoo",             "Flashforge",
     "FLSun",              "FlyingBear",         "Folgertech",         "Geeetech",           "Ginger Additive",
     "InfiMech",           "Kingroon",           "Lulzbot",            "MagicMaker",         "Mellow",
     "Orca Arena Printer", "Peopoly",            "Positron 3D",        "Prusa",              "Qidi",
     "Raise3D",            "RatRig",             "re3D",               "RolohaunDesign",     "SecKit",             
     "Snapmaker",          "Sovol",              "Thinker X400",       "Tronxy",             "TwoTrees",           
     "UltiMaker",          "Vivedino",           "Volumic",            "Voron",              "Voxelab",            
     "Vzbot",              "Wanhao",             "Z-Bolt"};

Referenced by Slic3r::GUI::CreatePrinterPresetDialog::create_printer_item().

printjob_cancel_str [1/2]

auto Slic3r::GUI::printjob_cancel_str = _u8L("Task canceled.")

static

Referenced by Slic3r::GUI::PrintJob::process(), and Slic3r::GUI::SendJob::process().

printjob_cancel_str [2/2]

auto Slic3r::GUI::printjob_cancel_str = _u8L("Task canceled.")

static

ranges_language_independent

const ImWchar Slic3r::GUI::ranges_language_independent[]

static

Initial value:

=
{
    0x0100, 0x024F, 
    0x0370, 0x03FF, 
    0x0400, 0x04FF, 
    0x1E00, 0x1EFF, 
    0,
}

{
    0x0100, 0x024F, // Latin Extended-A and Extended-B
    0x0370, 0x03FF, // Greek and Coptic
    0x0400, 0x04FF, // Cyrillic
    0x1E00, 0x1EFF, // Latin Extended Additional (Vietnamese)
    0,
};

Referenced by Slic3r::GUI::ImGuiWrapper::init_font().

RightExtruderIdx

const int Slic3r::GUI::RightExtruderIdx = 1

static

Referenced by Slic3r::GUI::ExtruderBadge::ExtruderBadge(), Slic3r::GUI::ExtruderBadge::MarkRelatedItems(), Slic3r::GUI::ExtruderBadge::SetExtruderInfo(), and Slic3r::GUI::ExtruderBadge::UnMarkRelatedItems().

s_doc_worker_busy

std::atomic<int> Slic3r::GUI::s_doc_worker_busy {0}

static

{0};

Referenced by Slic3r::GUI::DesignPanel::mcp_busy(), run_off_ui_thread(), Slic3r::GUI::DesignPanel::update_feature_highlight(), and Slic3r::GUI::DesignPanel::zoom_to_feature().

s_filament_temp_pair_warning_suppressed_for_session

std::unordered_set<std::string> Slic3r::GUI::s_filament_temp_pair_warning_suppressed_for_session

static

Referenced by Slic3r::GUI::Tab::validate_filament_temperature_pairs().

s_jump_liveview_error_codes

const std::unordered_set<std::string> Slic3r::GUI::s_jump_liveview_error_codes = { "0300-8003", "0300-8002", "0300-800A"}

static

{ "0300-8003", "0300-8002", "0300-800A"};

Referenced by Slic3r::GUI::DeviceErrorDialog::show_error_code().

s_keys_down

std::set<int> Slic3r::GUI::s_keys_down

static

Referenced by key_released(), key_repeats(), and Slic3r::GUI::GLCanvas3D::release_held_modifiers().

s_nozzle_mapping_last_request_time

int Slic3r::GUI::s_nozzle_mapping_last_request_time = 0

static

Referenced by Slic3r::GUI::SelectMachineDialog::CheckErrorSyncNozzleMappingResultV0(), Slic3r::GUI::SelectMachineDialog::CheckErrorSyncNozzleMappingResultV1(), Slic3r::GUI::SelectMachineDialog::on_flow_cali_option_changed(), Slic3r::GUI::SelectMachineDialog::on_pa_value_option_changed(), and Slic3r::GUI::SelectMachineDialog::on_selection_changed().

s_nozzle_stats_from_machine

bool Slic3r::GUI::s_nozzle_stats_from_machine = false

static

Referenced by onNozzleVolumeTypeSwitch(), seedExtruderNozzleStats(), and setNozzleStatsFromMachine().

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_rotation(), init_from_circle(), init_from_scale(), and init_from_snap_radii().

SCENE_CANVAS_NAME

const char* const Slic3r::GUI::SCENE_CANVAS_NAME = "OrcaSceneCanvas"

static

Referenced by Slic3r::GUI::OpenGLManager::create_wxglcanvas(), and Slic3r::GUI::OpenGLManager::is_scene_canvas().

SEL_SPHERE_1_ID

const int Slic3r::GUI::SEL_SPHERE_1_ID = 501

static

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

SEL_SPHERE_2_ID

const int Slic3r::GUI::SEL_SPHERE_2_ID = 502

static

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

SELECTED_1ST_COLOR

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

static

{0.25f, 0.75f, 0.75f, 1.0f};

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

SELECTED_2ND_COLOR

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

static

{0.75f, 0.25f, 0.75f, 1.0f};

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

SELECTED_COLOR

const ColorRGBA Slic3r::GUI::SELECTED_COLOR = {0.0f, 0.5f, 0.5f, 1.0f}

static

{0.0f, 0.5f, 0.5f, 1.0f};

Referenced by Slic3r::GUI::GLGizmoBrimEars::render_points().

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_print_failed_str [1/2]

auto Slic3r::GUI::send_print_failed_str = _u8L("Failed to send the print job. Please try again.")

static

Referenced by Slic3r::GUI::PrintJob::process(), and Slic3r::GUI::SendJob::process().

send_print_failed_str [2/2]

auto Slic3r::GUI::send_print_failed_str = _u8L("Failed to send the print job. Please try again.")

static

SEND_SYSTEM_INFO_DOMAIN

const std::string Slic3r::GUI::SEND_SYSTEM_INFO_DOMAIN = "bambu-lab.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().

sending_over_cloud_str [1/2]

auto Slic3r::GUI::sending_over_cloud_str = _u8L("Sending print job through cloud service")

static

sending_over_cloud_str [2/2]

auto Slic3r::GUI::sending_over_cloud_str = _u8L("Sending print job through cloud service")

static

sending_over_lan_str [1/2]

auto Slic3r::GUI::sending_over_lan_str = _u8L("Sending print job over LAN")

static

sending_over_lan_str [2/2]

auto Slic3r::GUI::sending_over_lan_str = _u8L("Sending print job over LAN")

static

sep

const wxString Slic3r::GUI::sep = "\t"

static

Referenced by Slic3r::GUI::TroubleshootDialog::AddToZip(), Slic3r::GUI::MainFrame::init_menubar_as_editor(), Slic3r::GUI::MainFrame::init_menubar_as_gcodeviewer(), Slic3r::GUI::KeyChord::parse(), Slic3r::GUI::MainFrame::shortcut_label(), and Slic3r::GUI::Sidebar::update_mixed_filament_list().

SHADOW_WIDTH

int Slic3r::GUI::SHADOW_WIDTH = 3

staticconstexpr

Referenced by Slic3r::GUI::ImageGrid::UpdateFileSystem().

SLIDER_BOTTOM_MARGIN

const float Slic3r::GUI::SLIDER_BOTTOM_MARGIN = 64.0f

static

Referenced by Slic3r::GUI::GLCanvas3D::_render_frame(), and Slic3r::GUI::GCodeViewer::sequential_view_height().

SLIDER_DEFAULT_BOTTOM_MARGIN

const float Slic3r::GUI::SLIDER_DEFAULT_BOTTOM_MARGIN = 10.0f

static

Referenced by Slic3r::GUI::GLCanvas3D::_render_frame().

SLIDER_DEFAULT_RIGHT_MARGIN

const float Slic3r::GUI::SLIDER_DEFAULT_RIGHT_MARGIN = 10.0f

static

Referenced by Slic3r::GUI::GLCanvas3D::_render_frame().

SLIDER_RIGHT_MARGIN

const float Slic3r::GUI::SLIDER_RIGHT_MARGIN = IMSlider::vertical_slider_window_width()

inlinestatic

Referenced by Slic3r::GUI::GLCanvas3D::_render_frame(), and Slic3r::GUI::GLCanvas3D::_render_gcode_overlay().

SnapRegionsCount

const unsigned int Slic3r::GUI::SnapRegionsCount = 8

Referenced by Slic3r::GUI::GLGizmoCut3D::dragging_grabber_rotation(), and init_from_snap_radii().

special_key

std::set<char> Slic3r::GUI::special_key = {'\n', '\t', '\r', '\v', '@', ';'}

static

{'\n', '\t', '\r', '\v', '@', ';'};

Referenced by remove_special_key().

spools

std::vector<std::deque<wxWindow *>**> Slic3r::GUI::spools

Referenced by Slic3r::GUI::Builder< T >::Builder(), and switch_window_pools().

spools2

std::vector<std::deque<wxWindow *>*> Slic3r::GUI::spools2

Referenced by release_window_pools(), and switch_window_pools().

STAGE_TEXT_COL

const wxColour Slic3r::GUI::STAGE_TEXT_COL = wxColour(0, 150, 136)

static

Referenced by Slic3r::GUI::PrintingTaskPanel::create_panel().

STATIC_BOX_LINE_COL

const wxColour Slic3r::GUI::STATIC_BOX_LINE_COL = wxColour(238, 238, 238)

static

Referenced by Slic3r::GUI::StatusBasePanel::create_misc_control(), Slic3r::GUI::PrintOptionsDialog::create_settings_group(), Slic3r::GUI::StatusBasePanel::create_temp_axis_group(), and Slic3r::GUI::StatusBasePanel::create_temp_control().

STATIC_LIGHT_DIR

const Vec3d Slic3r::GUI::STATIC_LIGHT_DIR = Vec3d(-0.4, -0.6, 1.0).normalized()

static

Referenced by Slic3r::GUI::GLCanvas3D::_render_shadows(), and Slic3r::GUI::GLCanvas3D::_static_light_dir_eye().

STATUS_PANEL_BG

const wxColour Slic3r::GUI::STATUS_PANEL_BG = wxColour(238, 238, 238)

static

Referenced by Slic3r::GUI::StatusBasePanel::StatusBasePanel(), Slic3r::GUI::StatusBasePanel::create_ams_group(), Slic3r::GUI::StatusBasePanel::create_filament_group(), and Slic3r::GUI::StatusBasePanel::create_temp_axis_group().

STATUS_TITLE_BG

const wxColour Slic3r::GUI::STATUS_TITLE_BG = wxColour(248, 248, 248)

static

Referenced by Slic3r::GUI::StatusBasePanel::create_machine_control_page(), Slic3r::GUI::StatusBasePanel::create_monitoring_page(), and Slic3r::GUI::PrintingTaskPanel::create_panel().

STD_REMESH_EDGE_MM

float Slic3r::GUI::STD_REMESH_EDGE_MM = 1.0f

staticconstexpr

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::apply_standard_mode_presets(), Slic3r::GUI::GLGizmoTextureDisplacement::bake_standard(), and Slic3r::GUI::GLGizmoTextureDisplacement::run_stage_debug().

STD_REMESH_SHARP_DEG

float Slic3r::GUI::STD_REMESH_SHARP_DEG = 40.f

staticconstexpr

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::apply_standard_mode_presets(), Slic3r::GUI::GLGizmoTextureDisplacement::bake_standard(), and Slic3r::GUI::GLGizmoTextureDisplacement::run_stage_debug().

STD_SUBDIV_BORDER_MM

float Slic3r::GUI::STD_SUBDIV_BORDER_MM = 0.4f

staticconstexpr

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::apply_standard_mode_presets(), Slic3r::GUI::GLGizmoTextureDisplacement::bake_standard(), and Slic3r::GUI::GLGizmoTextureDisplacement::run_stage_debug().

STD_SUBDIV_COLOR_MM

float Slic3r::GUI::STD_SUBDIV_COLOR_MM = 0.25f

staticconstexpr

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::apply_standard_mode_presets(), Slic3r::GUI::GLGizmoTextureDisplacement::bake_standard(), and Slic3r::GUI::GLGizmoTextureDisplacement::run_stage_debug().

STD_SUBDIV_DETAIL_MM

float Slic3r::GUI::STD_SUBDIV_DETAIL_MM = 0.02f

staticconstexpr

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::apply_standard_mode_presets(), Slic3r::GUI::GLGizmoTextureDisplacement::bake_standard(), and Slic3r::GUI::GLGizmoTextureDisplacement::run_stage_debug().

STD_SUBDIV_MAX_EDGE_MM

float Slic3r::GUI::STD_SUBDIV_MAX_EDGE_MM = 20.f

staticconstexpr

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::apply_standard_mode_presets(), Slic3r::GUI::GLGizmoTextureDisplacement::bake_standard(), and Slic3r::GUI::GLGizmoTextureDisplacement::run_stage_debug().

STD_SUBDIV_MIN_EDGE_MM

float Slic3r::GUI::STD_SUBDIV_MIN_EDGE_MM = 0.1f

staticconstexpr

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::apply_standard_mode_presets(), Slic3r::GUI::GLGizmoTextureDisplacement::bake_standard(), and Slic3r::GUI::GLGizmoTextureDisplacement::run_stage_debug().

SVG_VOLUME_ICONS

const constexpr std::array<std::pair<const char *, const char *>, 3> Slic3r::GUI::SVG_VOLUME_ICONS

staticconstexpr

Initial value:

{{
    {L("Add SVG part"),     "svg_part"},     
    {L("Add negative SVG"), "svg_negative"}, 
    {L("Add SVG modifier"), "svg_modifier"}, 
}}

                                                                                        {{
    {L("Add SVG part"),     "svg_part"},     // ~ModelVolumeType::MODEL_PART
    {L("Add negative SVG"), "svg_negative"}, // ~ModelVolumeType::NEGATIVE_VOLUME
    {L("Add SVG modifier"), "svg_modifier"}, // ~ModelVolumeType::PARAMETER_MODIFIER
}};

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

SWITCH_FONT

const wxFont Slic3r::GUI::SWITCH_FONT = Label::Body_10

static

task_canceled_text

wxString Slic3r::GUI::task_canceled_text = _L("Task canceled")

static

Referenced by Slic3r::GUI::SelectMachineDialog::on_send_print().

TEMP_BLANK_STR

const wxString Slic3r::GUI::TEMP_BLANK_STR = wxString("_")

static

Referenced by Slic3r::GUI::StatusBasePanel::create_temp_control(), Slic3r::GUI::StatusBasePanel::reset_temp_misc_control(), and Slic3r::GUI::StatusPanel::update_temp_ctrl().

temp_dir

wxString Slic3r::GUI::temp_dir

static

TEXT_COL

const wxColour Slic3r::GUI::TEXT_COL = wxColour(43, 52, 54)

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

TEXT_FAILED_CLR

const wxColour Slic3r::GUI::TEXT_FAILED_CLR = wxColour(255, 111, 0)

static

Referenced by Slic3r::GUI::MachineInfoPanel::show_status().

TEXT_LIGHT_FONT_COL

wxColour Slic3r::GUI::TEXT_LIGHT_FONT_COL = wxColour(107, 107, 107)

static

Referenced by Slic3r::GUI::StatusBasePanel::create_bed_control(), Slic3r::GUI::StatusBasePanel::create_extruder_control(), and Slic3r::GUI::StatusPanel::show_printing_status().

TEXT_NORMAL_CLR

const wxColour Slic3r::GUI::TEXT_NORMAL_CLR = wxColour(0, 150, 136)

static

Referenced by Slic3r::GUI::MachineInfoPanel::show_status().

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"},    
}}

                                                                                          {{
//       menu_item Name              menu_item bitmap name
        {L("Add text"),             "add_text_part"},        // ~ModelVolumeType::MODEL_PART
        {L("Add negative text"),    "add_text_negative" },   // ~ModelVolumeType::NEGATIVE_VOLUME
        {L("Add text modifier"),    "add_text_modifier"},    // ~ModelVolumeType::PARAMETER_MODIFIER
}};

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

TextDisableColor

const wxColour Slic3r::GUI::TextDisableColor = wxColour("#CECECE")

static

Referenced by Slic3r::GUI::FilamentMapBtnPanel::UpdateStatus().

TextErrorColor

const wxColour Slic3r::GUI::TextErrorColor = wxColour("#E14747")

static

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

TextNormalBlackColor [1/2]

const wxColour Slic3r::GUI::TextNormalBlackColor = wxColour("#262E30")

static

Referenced by Slic3r::GUI::FilamentMapBtnPanel::FilamentMapBtnPanel(), Slic3r::GUI::PurgeModeBtnPanel::PurgeModeBtnPanel(), and Slic3r::GUI::FilamentMapBtnPanel::UpdateStatus().

TextNormalBlackColor [2/2]

const wxColour Slic3r::GUI::TextNormalBlackColor = wxColour("#262E30")

static

TextNormalColor

const wxColour Slic3r::GUI::TextNormalColor = wxColour("#262E30")

static

Referenced by Slic3r::GUI::CapsuleButton::UpdateStatus().

TextNormalGreyColor [1/2]

const wxColour Slic3r::GUI::TextNormalGreyColor = wxColour("#6B6B6B")

static

Referenced by Slic3r::GUI::FilamentMapBtnPanel::FilamentMapBtnPanel(), Slic3r::GUI::FilamentMapManualPanel::FilamentMapManualPanel(), Slic3r::GUI::PurgeModeBtnPanel::PurgeModeBtnPanel(), and Slic3r::GUI::FilamentMapBtnPanel::UpdateStatus().

TextNormalGreyColor [2/2]

const wxColour Slic3r::GUI::TextNormalGreyColor = wxColour("#6B6B6B")

static

TextSelectColor

const wxColour Slic3r::GUI::TextSelectColor = wxColour("#262E30")

static

Referenced by Slic3r::GUI::CapsuleButton::UpdateStatus().

TIME_FORMATS

wchar_t const* Slic3r::GUI::TIME_FORMATS[] = {_T("%Y-%m-%d"), _T("%Y-%m"), _T("%Y")}

staticconstexpr

{_T("%Y-%m-%d"), _T("%Y-%m"), _T("%Y")};

Referenced by Slic3r::GUI::ImageGrid::render(), and Slic3r::GUI::ImageGrid::renderContent1().

time_out

int Slic3r::GUI::time_out = 6

constexpr

Referenced by Slic3r::GUI::FanControlPopupNew::command_control_air_duct(), Slic3r::GUI::FanControlPopupNew::on_fan_changed(), and Slic3r::GUI::PrintJob::process().

timeout_period

int Slic3r::GUI::timeout_period = 200000

constexpr

Referenced by Slic3r::GUI::SendToPrinterDialog::on_ok(), and Slic3r::GUI::SendToPrinterDialog::UploadFileProgressCallback().

timeout_to_upload_str [1/2]

auto Slic3r::GUI::timeout_to_upload_str = _u8L("Upload task timed out. Please check the network status and try again.")

static

Referenced by Slic3r::GUI::PrintJob::process(), and Slic3r::GUI::SendJob::process().

timeout_to_upload_str [2/2]

auto Slic3r::GUI::timeout_to_upload_str = _u8L("Upload task timed out. Please check the network status and try again.")

static

TIP_DELAY

double Slic3r::GUI::TIP_DELAY = 0.45

staticconstexpr

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::panel_tooltip().

TIP_DELAY_AGAIN

double Slic3r::GUI::TIP_DELAY_AGAIN = 0.10

staticconstexpr

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::panel_tooltip().

TIP_STICKY

double Slic3r::GUI::TIP_STICKY = 0.70

staticconstexpr

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::panel_tooltip().

titleWidth

int Slic3r::GUI::titleWidth = 20

constexpr

Referenced by Slic3r::GUI::OptionsGroup::activate_line(), Slic3r::GUI::OG_CustomCtrl::get_title_width(), Slic3r::GUI::OG_CustomCtrl::msw_rescale(), and Slic3r::GUI::OG_CustomCtrl::update_visibility().

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, "blank_16"      },
    {Preset::TYPE_PRINTER,      "printer"       },
}

                                                             {
    {Preset::TYPE_PRINT,        "cog"           },
    {Preset::TYPE_SLA_PRINT,    "cog"           },
    {Preset::TYPE_FILAMENT,     "spool"         },
    {Preset::TYPE_SLA_MATERIAL, "blank_16"      },
    {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 = " "

UP_LIMIT

double Slic3r::GUI::UP_LIMIT = 0.9

constexpr

Referenced by calc_angle(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoSVG::draw_face_the_camera(), Slic3r::GUI::GLGizmoEmboss::on_mouse_for_translate(), Slic3r::GUI::GLGizmoSVG::on_mouse_for_translate(), and anonymous_namespace{EmbossJob.cpp}::start_create_volume_on_surface_job().

upload_ftp_failed_str [1/2]

auto Slic3r::GUI::upload_ftp_failed_str = _u8L("Failed to upload file to ftp. Please try again.")

static

Referenced by Slic3r::GUI::PrintJob::process(), and Slic3r::GUI::SendJob::process().

upload_ftp_failed_str [2/2]

auto Slic3r::GUI::upload_ftp_failed_str = _u8L("Failed to upload file to ftp. Please try again.")

static

UPPER_PART_COLOR

const ColorRGBA Slic3r::GUI::UPPER_PART_COLOR = ColorRGBA::CYAN()

static

Referenced by Slic3r::GUI::GLGizmoCut3D::apply_color_clip_plane_colors(), Slic3r::GUI::GLGizmoCut3D::PartSelection::render(), and Slic3r::GUI::GLGizmoCut3D::render_cut_plane_input_window().

URL_CHANGELOG

const char* Slic3r::GUI::URL_CHANGELOG = "%1%"

static

URL_DEV

const char* Slic3r::GUI::URL_DEV = "%1%"

static

URL_DOWNLOAD

const char* Slic3r::GUI::URL_DOWNLOAD = "%1%"

static

VERTICAL_SLIDER_WINDOW_WIDTH

const float Slic3r::GUI::VERTICAL_SLIDER_WINDOW_WIDTH = 164.0f

static

Referenced by Slic3r::GUI::IMSlider::render(), and Slic3r::GUI::IMSlider::vertical_slider_window_width().

wait_sending_finish

wxString Slic3r::GUI::wait_sending_finish = _L("Print task sending times out.")

static

waiting_auth_str

auto Slic3r::GUI::waiting_auth_str = _u8L("Logging in")

static

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

WARNING_INFO_BG_COL

const wxColour Slic3r::GUI::WARNING_INFO_BG_COL = wxColour(255, 111, 0)

static

warning_text

const std::string Slic3r::GUI::warning_text = _u8L("Unable to perform boolean operation on selected parts")

static

Referenced by Slic3r::GUI::PartPlate::check_single_extruder_mixed_filament_risk(), Slic3r::GUI::GLGizmoMeshBoolean::on_render_input_window(), Slic3r::GUI::GLGizmoMeshBoolean::on_set_state(), Slic3r::CLI::run(), Slic3r::GUI::ColorDecomposeDialog::update_filament_limit_warning(), Slic3r::GUI::AMSDryCtrWin::update_normal_description(), and Slic3r::GUI::ImGuiWrapper::warning_text().

WarningIcon

char Slic3r::GUI::WarningIcon[] = "obj_warning"

staticconstexpr

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

WarningManifoldIcon

char Slic3r::GUI::WarningManifoldIcon[] = "obj_warning"

staticconstexpr

Referenced by Slic3r::GUI::ObjectDataViewModel::ObjectDataViewModel(), Slic3r::GUI::ObjectDataViewModel::AddVolumeChild(), and Slic3r::GUI::ObjectDataViewModel::Rescale().

wxMouseEvent

Slic3r::GUI::wxMouseEvent

Referenced by Slic3r::GUI::AMSControl::AMSControl(), Slic3r::GUI::AMSHumidity::AMSHumidity(), Slic3r::GUI::AMSRoad::AMSRoad(), Slic3r::GUI::CameraPopup::CameraPopup(), CenteredTitle::CenteredTitle(), Slic3r::GUI::CloudTaskManagerPage::CloudTaskManagerPage(), Slic3r::GUI::ConfigWizardIndex::ConfigWizardIndex(), Slic3r::GUI::ConfirmBeforeSendDialog::ConfirmBeforeSendDialog(), Slic3r::GUI::DesignCanvas::DesignCanvas(), Slic3r::GUI::DesignPanel::DesignPanel(), Slic3r::GUI::DesignRowList::DesignRowList(), Slic3r::GUI::ExtruderGroup::ExtruderGroup(), Slic3r::GUI::FilamentMapBtnPanel::FilamentMapBtnPanel(), Slic3r::GUI::FilamentMapManualPanel::FilamentMapManualPanel(), Slic3r::GUI::FilamentSelectPopup::FilamentSelectPopup(), Slic3r::GUI::anonymous_namespace{PrintHostDialogs.cpp}::FlashforgeSlotCard::FlashforgeSlotCard(), Slic3r::GUI::HMSNotifyItem::HMSNotifyItem(), Slic3r::GUI::HyperLink::HyperLink(), Slic3r::GUI::InputIpAddressDialog::InputIpAddressDialog(), Slic3r::GUI::SavePresetDialog::Item::Item(), Slic3r::GUI::LocalTaskManagerPage::LocalTaskManagerPage(), Slic3r::GUI::MultiMachineManagerPage::MultiMachineManagerPage(), Slic3r::GUI::ObjectList::ObjectList(), Slic3r::GUI::PlaterPresetComboBox::PlaterPresetComboBox(), Slic3r::GUI::PrivacyUpdateDialog::PrivacyUpdateDialog(), Slic3r::GUI::PublishSettingsDialog::PublishSettingsDialog(), Slic3r::GUI::PurgeModeBtnPanel::PurgeModeBtnPanel(), Slic3r::GUI::PurgeModeDialog::PurgeModeDialog(), Slic3r::GUI::RatioLabelPanel::RatioLabelPanel(), Slic3r::GUI::SafetyOptionsDialog::SafetyOptionsDialog(), Slic3r::GUI::SelectMachineDialog::SelectMachineDialog(), Slic3r::GUI::SendFailedConfirm::SendFailedConfirm(), Slic3r::GUI::ShortcutCaptureDialog::ShortcutCaptureDialog(), Slic3r::GUI::Sidebar::Sidebar(), StepMeshDialog::StepMeshDialog(), Slic3r::GUI::SyncAmsInfoDialog::SyncAmsInfoDialog(), Slic3r::GUI::TroubleshootDialog::TroubleshootDialog(), Slic3r::GUI::UpdatePluginDialog::UpdatePluginDialog(), Slic3r::GUI::UpdateVersionDialog::UpdateVersionDialog(), Slic3r::GUI::UVEditorPanel::UVEditorPanel(), Slic3r::GUI::UVToolButton::UVToolButton(), Slic3r::GUI::ZUserLogin::ZUserLogin(), Slic3r::GUI::GLGizmoBrimEars::~GLGizmoBrimEars(), Slic3r::GUI::GLCanvas3D::_perform_layer_editing_action(), Slic3r::GUI::AmsMapingPopup::add_ams_mapping(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::add_checkbox_label(), Slic3r::GUI::AmsMapingPopup::add_ext_ams_mapping(), Slic3r::GUI::PluginField::add_plugin_row(), Slic3r::GUI::IMEXModesCtrl::add_row(), Slic3r::GUI::AMSControl::AddAmsPreview(), Slic3r::GUI::AMSControl::AddAmsPreview(), Slic3r::GUI::AmsItem::AddCan(), Slic3r::GUI::AmsItem::AddLiteCan(), Slic3r::GUI::DesignSketchTool::arc_mouse_angle(), Slic3r::GUI::Choice::BUILD(), Slic3r::GUI::ColourPicker::BUILD(), Slic3r::GUI::TextCtrl::BUILD(), Slic3r::GUI::UnsavedChangesDialog::build(), Slic3r::GUI::TextureImportDialog::build_preview_panel(), Slic3r::GUI::GLCanvas3D::clicked_button_matches_action(), Slic3r::GUI::MixedFilamentDialog::commit_ratio_editor_from_background(), Slic3r::GUI::Tab::compatible_widget_create(), Slic3r::GUI::ProgressDialog::Create(), Slic3r::GUI::AMSMaterialsSetting::create(), Slic3r::GUI::CalibrationPresetPage::create_ams_items_sizer(), Slic3r::GUI::DiffPresetDialog::create_buttons(), Slic3r::GUI::CalibrationDialog::create_check_option(), Slic3r::GUI::PreferencesDialog::create_debug_page(), Slic3r::GUI::PreferencesDialog::create_item_language_combobox(), Slic3r::GUI::CameraPopup::create_item_radiobox(), Slic3r::GUI::AutoMixSelectPopup::create_item_row(), Slic3r::GUI::FilamentSelectPopup::create_item_row(), Slic3r::GUI::FilamentSelectPopup::create_mixed_item_row(), Slic3r::GUI::ColorDecomposeDialog::create_mode_card(), Slic3r::GUI::SendMultiMachinePage::create_page(), Slic3r::GUI::PrintingTaskPanel::create_panel(), Slic3r::GUI::Tab::create_preset_tab(), Slic3r::GUI::CreatePrinterPresetDialog::create_presets_template_item(), Slic3r::GUI::CreateFilamentPresetDialog::create_radio_item(), Slic3r::GUI::CreatePrinterPresetDialog::create_radio_item(), Slic3r::GUI::ExportConfigsDialog::create_radio_item(), Slic3r::GUI::MixedFilamentDialog::create_ratio_slider(), Slic3r::GUI::StatusBasePanel::create_settings_group(), Slic3r::GUI::MixedFilamentDialog::create_triangle_picker(), Slic3r::GUI::NetworkPluginDownloadDialog::create_update_available_ui(), Slic3r::GUI::CaliPageCaption::create_wiki(), Slic3r::GUI::FilamentPickerDialog::CreateColorGrid(), Slic3r::GUI::TextureImportDialog::dismiss_filament_popup_on_wheel(), Slic3r::GUI::DesignSketchTool::drag_cut_arrow(), Slic3r::GUI::DesignSketchTool::drag_datum_handle(), Slic3r::GUI::DesignSketchTool::drag_draft_arc(), Slic3r::GUI::DesignSketchTool::drag_extrude_arrow(), Slic3r::GUI::DesignSketchTool::drag_fillet_arrow(), Slic3r::GUI::DesignSketchTool::drag_helix_handle(), Slic3r::GUI::DesignSketchTool::drag_hole_handle(), Slic3r::GUI::DesignSketchTool::drag_move_arc(), Slic3r::GUI::DesignSketchTool::drag_pattern_handle(), Slic3r::GUI::DesignSketchTool::drag_revolve_arc(), Slic3r::GUI::DesignSketchTool::drag_rib_handle(), Slic3r::GUI::DesignSketchTool::drag_shell_arrow(), Slic3r::GUI::DesignSketchTool::drag_thread_handle(), Slic3r::GUI::anonymous_namespace{Plater.cpp}::emboss_svg(), Slic3r::GUI::StatusBasePanel::expand_filament_loading(), Slic3r::GUI::DesignSketchTool::fillet_axis_proj(), Slic3r::GUI::Newer3mfVersionDialog::get_btn_sizer(), Slic3r::GUI::ScoreDialog::get_button_sizer(), Slic3r::GUI::GLGizmosManager::gizmos_toolbar_on_mouse(), Slic3r::GUI::TexturePreviewCanvas::handle_reset_overlay_mouse(), Slic3r::GUI::DesignSketchTool::handle_solid_click(), Slic3r::GUI::DesignSketchTool::hit_test_base_pick(), Slic3r::GUI::DesignSketchTool::hit_test_cut_arrow(), Slic3r::GUI::DesignSketchTool::hit_test_datum_handle(), Slic3r::GUI::DesignSketchTool::hit_test_draft_handle(), Slic3r::GUI::DesignSketchTool::hit_test_extrude_arrow(), Slic3r::GUI::DesignSketchTool::hit_test_fillet_arrow(), Slic3r::GUI::DesignSketchTool::hit_test_helix_handle(), Slic3r::GUI::DesignSketchTool::hit_test_hole_handle(), Slic3r::GUI::DesignSketchTool::hit_test_move_arc(), Slic3r::GUI::DesignSketchTool::hit_test_move_arrow(), Slic3r::GUI::DesignSketchTool::hit_test_pattern_handle(), Slic3r::GUI::DesignSketchTool::hit_test_revolve_handle(), Slic3r::GUI::DesignSketchTool::hit_test_rib_handle(), Slic3r::GUI::DesignSketchTool::hit_test_shell_arrow(), Slic3r::GUI::DesignSketchTool::hit_test_thread_handle(), Slic3r::GUI::DesignSketchTool::hole_axis_proj(), Slic3r::GUI::DesignSketchTool::infer_at(), BBLTopbar::Init(), Slic3r::GUI::ElegooPrintHostSendDialog::init(), Slic3r::GUI::DeviceErrorDialog::init_button(), Slic3r::GUI::PrintErrorDialog::init_button(), Slic3r::GUI::GLCanvas3D::is_camera_pan(), Slic3r::GUI::GLCanvas3D::is_camera_rotate(), Slic3r::GUI::Sidebar::priv::layout_printer(), make_spin(), Slic3r::GUI::FilamentGroupPopup::MakeSmartFilamentSection(), anonymous_namespace{SurfaceDrag.cpp}::mouse_position(), Slic3r::GUI::ImageGrid::mouseDown(), Slic3r::GUI::ImageGrid::mouseEnterWindow(), Slic3r::GUI::ImageGrid::mouseLeaveWindow(), Slic3r::GUI::ImageGrid::mouseMoved(), Slic3r::GUI::ImageGrid::mouseReleased(), Slic3r::GUI::ImageGrid::mouseWheelMoved(), Slic3r::GUI::AuFolderPanel::on_add(), Slic3r::GUI::AMSControl::on_ams_setting_click(), Slic3r::GUI::AMSControl::on_ams_setting_click(), Slic3r::GUI::ModelMallDialog::on_back(), Slic3r::GUI::StatusPanel::on_camera_enter(), Slic3r::GUI::StatusPanel::on_camera_leave(), Slic3r::GUI::AMSControl::on_clibration_again_click(), Slic3r::GUI::AMSControl::on_clibration_cancel_click(), Slic3r::GUI::AMSMaterialsSetting::on_clr_picker(), Slic3r::GUI::ColorPickerPopup::on_custom_clr_picker(), Slic3r::GUI::AuFile::on_dclick(), Slic3r::GUI::Sidebar::on_enter_image_printer_bed(), Slic3r::GUI::CameraItem::on_enter_win(), Slic3r::GUI::AMSLib::on_enter_window(), Slic3r::GUI::ModelMallDialog::on_forward(), Slic3r::GUI::GradientCurveEditor::on_leave(), Slic3r::GUI::UVEditorCanvas::on_leave(), Slic3r::GUI::Sidebar::on_leave_image_printer_bed(), Slic3r::GUI::AMSLib::on_leave_window(), AuxiliaryList::on_left_dclick(), Slic3r::GUI::AMSLib::on_left_down(), Slic3r::GUI::AmsMapingPopup::on_left_down(), Slic3r::GUI::anonymous_namespace{PrintHostDialogs.cpp}::FlashforgeMaterialMapWidget::on_left_down(), Slic3r::GUI::anonymous_namespace{PrintHostDialogs.cpp}::FlashforgeSlotCard::on_left_down(), Slic3r::GUI::FanControlNew::on_left_down(), Slic3r::GUI::FanControlNewSwitchPanel::on_left_down(), Slic3r::GUI::FanControlPopupNew::on_left_down(), Slic3r::GUI::FanOperate::on_left_down(), Slic3r::GUI::GradientCurveEditor::on_left_down(), Slic3r::GUI::PrintOptionItem::on_left_down(), Slic3r::GUI::SendModeSwitchButton::on_left_down(), Slic3r::GUI::GradientCurveEditor::on_left_up(), Slic3r::GUI::CameraItem::on_level_win(), Slic3r::GUI::FanControlNew::on_mode_change(), Slic3r::GUI::FanControlPopupNew::on_mode_changed(), Slic3r::GUI::GradientCurveEditor::on_motion(), Slic3r::GUI::DesignSketchTool::on_mouse(), Slic3r::GUI::DragCanvas::on_mouse(), Slic3r::GUI::GLCanvas3D::on_mouse(), Slic3r::GUI::GLGizmoBase::on_mouse(), Slic3r::GUI::GLGizmoBrimEars::on_mouse(), Slic3r::GUI::GLGizmoCut3D::on_mouse(), Slic3r::GUI::GLGizmoEmboss::on_mouse(), Slic3r::GUI::GLGizmoFlatten::on_mouse(), Slic3r::GUI::GLGizmoMeasure::on_mouse(), Slic3r::GUI::GLGizmoMeshBoolean::on_mouse(), Slic3r::GUI::GLGizmoMove3D::on_mouse(), Slic3r::GUI::GLGizmoPainterBase::on_mouse(), Slic3r::GUI::GLGizmoRotate3D::on_mouse(), Slic3r::GUI::GLGizmoRotate::on_mouse(), Slic3r::GUI::GLGizmoScale3D::on_mouse(), Slic3r::GUI::GLGizmosManager::on_mouse(), Slic3r::GUI::GLGizmoSVG::on_mouse(), Slic3r::GUI::GLGizmoTextureDisplacement::on_mouse(), Slic3r::GUI::GLToolbar::on_mouse(), Slic3r::GUI::TexturePreviewCanvas::on_mouse(), Slic3r::GUI::UVEditorCanvas::on_mouse(), Slic3r::GUI::GLGizmoTextureDisplacement::on_mouse_adjust_texture(), Slic3r::GUI::GLGizmoEmboss::on_mouse_change_selection(), Slic3r::GUI::AuFile::on_mouse_enter(), Slic3r::GUI::MachineObjectPanel::on_mouse_enter(), Slic3r::GUI::MObjectPanel::on_mouse_enter(), Slic3r::GUI::PinCodePanel::on_mouse_enter(), Slic3r::GUI::SideToolsPanel::on_mouse_enter(), Slic3r::GUI::SliceInfoPanel::on_mouse_enter(), Slic3r::GUI::PageMaterials::on_mouse_enter_profiles(), Slic3r::GUI::GLGizmoEmboss::on_mouse_for_rotation(), Slic3r::GUI::GLGizmoSVG::on_mouse_for_rotation(), Slic3r::GUI::GLGizmoEmboss::on_mouse_for_translate(), Slic3r::GUI::GLGizmoSVG::on_mouse_for_translate(), Slic3r::GUI::DesignSketchTool::on_mouse_impl(), Slic3r::GUI::AuFile::on_mouse_leave(), Slic3r::GUI::MachineObjectPanel::on_mouse_leave(), Slic3r::GUI::MObjectPanel::on_mouse_leave(), Slic3r::GUI::PinCodePanel::on_mouse_leave(), Slic3r::GUI::SideToolsPanel::on_mouse_leave(), Slic3r::GUI::SliceInfoPanel::on_mouse_leave(), Slic3r::GUI::PageMaterials::on_mouse_leave_profiles(), Slic3r::GUI::SideToolsPanel::on_mouse_left_down(), Slic3r::GUI::AuFile::on_mouse_left_up(), Slic3r::GUI::MachineObjectPanel::on_mouse_left_up(), Slic3r::GUI::MObjectPanel::on_mouse_left_up(), Slic3r::GUI::PinCodePanel::on_mouse_left_up(), Slic3r::GUI::SideToolsPanel::on_mouse_left_up(), Slic3r::GUI::AmsRMGroup::on_mouse_move(), Slic3r::GUI::ConfigWizardIndex::on_mouse_move(), Slic3r::GUI::PageMaterials::on_mouse_move_on_profiles(), Slic3r::GUI::GLGizmoTextureDisplacement::on_mouse_seam(), on_mouse_surface_drag(), Slic3r::GUI::GLCanvas3D::on_mouse_wheel(), Slic3r::GUI::GLGizmosManager::on_mouse_wheel(), Slic3r::GUI::IMSlider::on_mouse_wheel(), Slic3r::GUI::InputIpAddressDialog::on_ok(), Slic3r::GUI::CalibrationPanel::on_printer_clicked(), Slic3r::GUI::MonitorBasePanel::on_printer_clicked(), Slic3r::GUI::MonitorPanel::on_printer_clicked(), Slic3r::GUI::ModelMallDialog::on_refresh(), Slic3r::GUI::SelectMachineDialog::on_rename_click(), Slic3r::GUI::SelectMachineDialog::on_reselect_dialog_btn_clicked(), Slic3r::GUI::GradientCurveEditor::on_right_down(), Slic3r::GUI::ConfirmBeforeSendDialog::on_show(), Slic3r::GUI::SecondaryCheckDialog::on_show(), Slic3r::GUI::MachineInfoPanel::on_show_release_note(), Slic3r::GUI::PrintingTaskPanel::on_stage_clicked(), Slic3r::GUI::CalibrationDialog::on_start_calibration(), Slic3r::GUI::MonitorBasePanel::on_status(), Slic3r::GUI::StatusPanel::on_switch_vcamera(), Slic3r::GUI::FanControlNew::on_swith_fan(), Slic3r::GUI::MonitorBasePanel::on_tasklist(), Slic3r::GUI::SliceInfoPanel::on_thumbnail_enter(), Slic3r::GUI::StatusPanel::on_thumbnail_enter(), Slic3r::GUI::SliceInfoPanel::on_thumbnail_leave(), Slic3r::GUI::StatusPanel::on_thumbnail_leave(), Slic3r::GUI::MonitorBasePanel::on_timelapse(), Slic3r::GUI::MonitorBasePanel::on_video(), Slic3r::GUI::ScoreDialog::OnBitmapClicked(), Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::OnBitmapHoverEnter(), Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::OnBitmapHoverLeave(), Slic3r::GUI::wgtDeviceNozzleRackNozzleItem::OnBtnNozzleStatus(), Slic3r::GUI::AMSrefresh::OnClick(), Slic3r::GUI::AMSPreview::OnEnterWindow(), Slic3r::GUI::AMSrefresh::OnEnterWindow(), Slic3r::GUI::CapsuleButton::OnEnterWindow(), Slic3r::GUI::DevicePickItem::OnEnterWindow(), Slic3r::GUI::FilamentGroupPopup::OnEnterWindow(), Slic3r::GUI::FilamentMapBtnPanel::OnEnterWindow(), Slic3r::GUI::MultiMachineItem::OnEnterWindow(), Slic3r::GUI::MultiTaskItem::OnEnterWindow(), Slic3r::GUI::PurgeModeBtnPanel::OnEnterWindow(), Slic3r::GUI::SendDeviceItem::OnEnterWindow(), Slic3r::GUI::wgtDeviceNozzleRackNozzleItem::OnItemSelected(), Slic3r::GUI::OG_CustomCtrl::OnLeaveWin(), Slic3r::GUI::WikiLabel::OnLeaveWin(), Slic3r::GUI::AMSPreview::OnLeaveWindow(), Slic3r::GUI::AMSrefresh::OnLeaveWindow(), Slic3r::GUI::CapsuleButton::OnLeaveWindow(), Slic3r::GUI::DevicePickItem::OnLeaveWindow(), Slic3r::GUI::FilamentGroupPopup::OnLeaveWindow(), Slic3r::GUI::FilamentMapBtnPanel::OnLeaveWindow(), Slic3r::GUI::MultiMachineItem::OnLeaveWindow(), Slic3r::GUI::MultiTaskItem::OnLeaveWindow(), Slic3r::GUI::PurgeModeBtnPanel::OnLeaveWindow(), Slic3r::GUI::SendDeviceItem::OnLeaveWindow(), Slic3r::GUI::ColorPanel::OnLeftDown(), Slic3r::GUI::DevicePickItem::OnLeftDown(), Slic3r::GUI::MultiMachineItem::OnLeftDown(), Slic3r::GUI::MultiTaskItem::OnLeftDown(), Slic3r::GUI::OG_CustomCtrl::OnLeftDown(), Slic3r::GUI::SendDeviceItem::OnLeftDown(), Slic3r::GUI::WikiLabel::OnLeftDown(), Slic3r::GUI::CameraPopup::OnLeftUp(), Slic3r::GUI::ColorPanel::OnLeftUp(), Slic3r::GUI::SelectMachinePopup::OnLeftUp(), Slic3r::GUI::SelectMObjectPopup::OnLeftUp(), Slic3r::GUI::OG_CustomCtrl::OnMotion(), Slic3r::GUI::WikiLabel::OnMotion(), Slic3r::GUI::CameraPopup::OnMouse(), Slic3r::GUI::SliceInfoPopup::OnMouse(), BBLTopbar::OnMouseLeftDClock(), BBLTopbar::OnMouseLeftDown(), Slic3r::GUI::FilamentPickerDialog::OnMouseLeftDown(), Slic3r::GUI::SkipPartCanvas::OnMouseLeftDown(), BBLTopbar::OnMouseLeftUp(), Slic3r::GUI::FilamentPickerDialog::OnMouseLeftUp(), Slic3r::GUI::SkipPartCanvas::OnMouseLeftUp(), BBLTopbar::OnMouseMotion(), Slic3r::GUI::SkipPartCanvas::OnMouseMotion(), Slic3r::GUI::FilamentPickerDialog::OnMouseMove(), Slic3r::GUI::SkipPartCanvas::OnMouseRightDown(), Slic3r::GUI::SkipPartCanvas::OnMouseRightUp(), Slic3r::GUI::SkipPartCanvas::OnMouseWheel(), Slic3r::GUI::DevicePickItem::OnMove(), Slic3r::GUI::MultiMachineItem::OnMove(), Slic3r::GUI::MultiTaskItem::OnMove(), Slic3r::GUI::SendDeviceItem::OnMove(), Slic3r::GUI::SendMultiMachinePage::OnSelectRadio(), Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::OnStatusIconClick(), Slic3r::GUI::PrinterPartsDialog::OnWikiClicked(), Slic3r::GUI::ExtrusionCalibration::open_bitmap(), Slic3r::GUI::Sidebar::operator=(), Slic3r::GUI::AmsHumidityTipPopup::ProcessLeftDown(), Slic3r::GUI::AmsIntroducePopup::ProcessLeftDown(), Slic3r::GUI::AmsMapingPopup::ProcessLeftDown(), Slic3r::GUI::AmsMapingTipPopup::ProcessLeftDown(), Slic3r::GUI::AmsTutorialPopup::ProcessLeftDown(), Slic3r::GUI::ColorPickerPopup::ProcessLeftDown(), Slic3r::GUI::SelectMachinePopup::ProcessLeftDown(), Slic3r::GUI::SelectMObjectPopup::ProcessLeftDown(), Slic3r::GUI::SliceInfoPopup::ProcessLeftDown(), Slic3r::GUI::ImGuiWrapper::read_glsl_version(), Slic3r::GUI::DesignPanel::rebuild_constraint_list(), Slic3r::GUI::TextureImportDialog::rebuild_mapping_rows(), Slic3r::GUI::MixedFilamentDialog::rebuild_recommendation_items(), Slic3r::GUI::StatusPanel::refresh_thumbnail_webrequest(), Slic3r::GUI::SelectMachineDialog::reset_and_sync_ams_list(), Slic3r::GUI::SyncAmsInfoDialog::reset_and_sync_ams_list(), Slic3r::GUI::DesignSketchTool::screen_to_plane(), Slic3r::GUI::DesignSketchTool::screen_tol(), Slic3r::GUI::SelectMachineDialog::set_default_from_sdcard(), Slic3r::GUI::DesignCanvas::set_on_context_menu(), Slic3r::GUI::ogStaticText::SetPathEnd(), Slic3r::GUI::MsgDialog::show_dsa_button(), Slic3r::GUI::PublishSettingsDialog::show_menu(), Slic3r::GUI::SelectMachineDialog::show_timelapse_folder_popup(), Slic3r::GUI::DesignSketchTool::snap_chain_start(), Slic3r::GUI::DesignSketchTool::snap_vertex(), Slic3r::GUI::DesignSketchTool::start_cut_drag(), Slic3r::GUI::DesignSketchTool::start_fillet_drag(), Slic3r::GUI::DesignSketchTool::start_hole_drag(), Slic3r::GUI::DesignSketchTool::start_shell_drag(), Slic3r::GUI::DesignSketchTool::start_thread_drag(), Slic3r::GUI::SendMultiMachinePage::sync_ams_list(), Slic3r::GUI::UnsavedChangesDialog::update(), Slic3r::GUI::DesignSketchTool::update_hover(), Slic3r::GUI::Sidebar::update_mixed_filament_list(), Slic3r::GUI::ColorDecomposeDialog::update_mode_card_content(), Slic3r::GUI::ImGuiWrapper::update_mouse_data(), Slic3r::GUI::DesignSketchTool::update_solid_hover(), Slic3r::GUI::ConfirmBeforeSendDialog::update_text(), Slic3r::GUI::GUI_App::UpdateDarkUI(), Slic3r::GUI::PrinterMsgPanel::UpdateInfos(), Slic3r::GUI::AMSControl::UpdatePassRoad(), Slic3r::GUI::GLGizmoBase::use_grabbers(), wxBEGIN_EVENT_TABLE(), and wxDECLARE_EVENT().

zoom_bd

StateColor Slic3r::GUI::zoom_bd(std::pair< wxColour, int >(wxColour(144, 144, 144), StateColor::Disabled), std::pair< wxColour, int >(wxColour(38, 46, 48), StateColor::Enabled)) ( std::pair< wxColour, int > wxColour(144, 144, 144), StateColor::Disabled, std::pair< wxColour, int > wxColour(38, 46, 48), StateColor::Enabled )

static

zoom_bg

StateColor Slic3r::GUI::zoom_bg(std::pair< wxColour, int >(wxColour(255, 255, 255), StateColor::Disabled), std::pair< wxColour, int >(wxColour(206, 206, 206), StateColor::Pressed), std::pair< wxColour, int >(wxColour(238, 238, 238), StateColor::Hovered), std::pair< wxColour, int >(wxColour(255, 255, 255), StateColor::Enabled), std::pair< wxColour, int >(wxColour(255, 255, 255), StateColor::Normal)) ( std::pair< wxColour, int > wxColour(255, 255, 255), StateColor::Disabled, std::pair< wxColour, int > wxColour(206, 206, 206), StateColor::Pressed, std::pair< wxColour, int > wxColour(238, 238, 238), StateColor::Hovered, std::pair< wxColour, int > wxColour(255, 255, 255), StateColor::Enabled, std::pair< wxColour, int > wxColour(255, 255, 255), StateColor::Normal )

static

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

zoom_text

StateColor Slic3r::GUI::zoom_text(std::pair< wxColour, int >(wxColour(144, 144, 144), StateColor::Disabled), std::pair< wxColour, int >(wxColour(38, 46, 48), StateColor::Enabled)) ( std::pair< wxColour, int > wxColour(144, 144, 144), StateColor::Disabled, std::pair< wxColour, int > wxColour(38, 46, 48), StateColor::Enabled )

static