public static void GetExtrudersUsed(List <bool> extrudersUsed, IEnumerable <IObject3D> printableItems, PrinterSettings settings, bool checkForMeshFile)
{
extrudersUsed.Clear();
if (!printableItems.Any())
{
return;
}
int extruderCount = settings.GetValue <int>(SettingsKey.extruder_count);
// Make sure we only consider 1 extruder if in spiral vase mode
if (settings.GetValue <bool>(SettingsKey.spiral_vase) &&
extrudersUsed.Count(used => used == true) > 1)
{
extruderCount = 1;
}
for (int extruderIndex = 0; extruderIndex < extruderCount; extruderIndex++)
{
extrudersUsed.Add(false);
}
// If we have support enabled and are using an extruder other than 0 for it
if (printableItems.Any(i => i.WorldOutputType() == PrintOutputTypes.Support))
{
if (settings.GetValue <int>(SettingsKey.support_material_extruder) != 0)
{
int supportExtruder = Math.Max(0, Math.Min(extruderCount - 1, settings.GetValue <int>(SettingsKey.support_material_extruder)));
extrudersUsed[supportExtruder] = true;
}
if (settings.GetValue <int>(SettingsKey.support_material_interface_extruder) != 0)
{
int supportExtruder = Math.Max(0, Math.Min(extruderCount - 1, settings.GetValue <int>(SettingsKey.support_material_interface_extruder)));
extrudersUsed[supportExtruder] = true;
}
}
// If we have raft enabled and are using an extruder other than 0 for it
if (settings.GetValue <bool>(SettingsKey.create_raft))
{
if (settings.GetValue <int>(SettingsKey.raft_extruder) != 0)
{
int raftExtruder = Math.Max(0, Math.Min(extruderCount - 1, settings.GetValue <int>(SettingsKey.raft_extruder) - 1));
extrudersUsed[raftExtruder] = true;
}
}
for (int extruderIndex = 0; extruderIndex < extruderCount; extruderIndex++)
{
IEnumerable <IObject3D> itemsThisExtruder = GetItemsForExtruder(printableItems, extruderCount, extruderIndex, checkForMeshFile);
extrudersUsed[extruderIndex] |= itemsThisExtruder.Any();
}
}
public void Merge(PrinterSettingsLayer destinationLayer, PrinterSettings settingsToImport, List <PrinterSettingsLayer> rawSourceFilter, bool setLayerName)
{
HashSet <string> skipKeys = new HashSet <string>
{
"layer_id",
};
if (!setLayerName)
{
skipKeys.Add(SettingsKey.layer_name);
}
var destinationFilter = new List <PrinterSettingsLayer>
{
OemLayer,
BaseLayer,
destinationLayer,
}.Where(layer => layer != null);
var sourceFilter = rawSourceFilter.Where(layer => layer != null);
foreach (var keyName in PrinterSettings.KnownSettings)
{
if (settingsToImport.Contains(keyName))
{
// Compare the value to import to the layer cascade value and only set if different
string currentValue = this.GetValue(keyName, destinationFilter).Trim();
string importValue = settingsToImport.GetValue(keyName, sourceFilter).Trim();
if (!string.IsNullOrEmpty(importValue) &&
currentValue != keyName &&
!skipKeys.Contains(keyName))
{
destinationLayer[keyName] = importValue;
}
}
}
if (setLayerName)
{
destinationLayer[SettingsKey.layer_name] = settingsToImport.GetValue(SettingsKey.layer_name, sourceFilter);
}
this.Save();
ApplicationController.Instance.ReloadAdvancedControlsPanel();
}
public static void RefreshActiveInstance(PrinterSettings updatedProfile)
{
bool themeChanged = activeInstance.GetValue(SettingsKey.active_theme_name) != updatedProfile.GetValue(SettingsKey.active_theme_name);
activeInstance = updatedProfile;
ActiveSliceSettings.SettingChanged.CallEvents(null, new StringEventArgs(SettingsKey.printer_name));
if (themeChanged)
{
UiThread.RunOnIdle(() => SwitchToPrinterTheme(true));
}
else
{
UiThread.RunOnIdle(ApplicationController.Instance.ReloadAdvancedControlsPanel);
}
}
/// <summary>
/// Loads the specified PrinterProfile, performing recovery options if required
/// </summary>
/// <param name="profileID">The profile ID to load</param>
/// <param name="useActiveInstance">Return the in memory instance if already loaded. Alternatively, reload from disk</param>
/// <returns></returns>
public static async Task <PrinterSettings> LoadProfileAsync(string profileID, bool useActiveInstance = true)
{
var activePrinter = ApplicationController.Instance.ActivePrinter;
if (useActiveInstance && activePrinter.Settings.ID == profileID)
{
return(activePrinter.Settings);
}
// Only load profiles by ID that are defined in the profiles document
var printerInfo = Instance[profileID];
if (printerInfo == null)
{
return(null);
}
// Attempt to load from disk, pull from the web or fall back using recovery logic
PrinterSettings printerSettings = Instance.LoadWithoutRecovery(profileID);
if (printerSettings != null)
{
// Make sure we have the name set
if (printerSettings.GetValue(SettingsKey.printer_name) == "")
{
// This can happen when a profile is pushed to a user account from the web.
printerSettings.SetValue(SettingsKey.printer_name, printerInfo.Name);
}
return(printerSettings);
}
else if (ApplicationController.GetPrinterProfileAsync != null)
{
// Attempt to load from MCWS if missing on disk
printerSettings = await ApplicationController.GetPrinterProfileAsync(printerInfo, null);
if (printerSettings != null)
{
// If successful, persist downloaded profile and return
printerSettings.Save();
return(printerSettings);
}
}
// Otherwise attempt to recover to a working profile
return(await PrinterSettings.RecoverProfile(printerInfo));
}
public double ExtruderTargetTemperature(int extruderIndex)
{
if (extruderIndex == 0)
{
return(printerSettings.GetValue <double>(SettingsKey.temperature));
}
else
{
// Check if there is a material override for this extruder
// Otherwise, use the SettingsLayers that is bound to this extruder
if (extruderIndex < printerSettings.GetValue <int>(SettingsKey.extruder_count))
{
return(printerSettings.GetValue <double>($"{SettingsKey.temperature}{extruderIndex}"));
}
// else return the normal settings cascade
return(printerSettings.GetValue <double>(SettingsKey.temperature));
}
}
internal static bool ImportFromExisting(string settingsFilePath)
{
if (string.IsNullOrEmpty(settingsFilePath) || !File.Exists(settingsFilePath))
{
return(false);
}
string fileName = Path.GetFileNameWithoutExtension(settingsFilePath);
var existingPrinterNames = Instance.ActiveProfiles.Select(p => p.Name);
var printerInfo = new PrinterInfo
{
Name = agg_basics.GetNonCollidingName(existingPrinterNames, fileName),
ID = Guid.NewGuid().ToString(),
Make = "Other",
Model = "Other",
};
bool importSuccessful = false;
string importType = Path.GetExtension(settingsFilePath).ToLower();
switch (importType)
{
case ProfileManager.ProfileExtension:
// Add the Settings as a profile before performing any actions on it to ensure file paths resolve
{
Instance.Profiles.Add(printerInfo);
var printerSettings = PrinterSettings.LoadFile(settingsFilePath);
printerSettings.ID = printerInfo.ID;
printerSettings.ClearValue(SettingsKey.device_token);
printerInfo.DeviceToken = "";
// TODO: Resolve name conflicts
printerSettings.Helpers.SetName(printerInfo.Name);
if (printerSettings.OemLayer.ContainsKey(SettingsKey.make))
{
printerInfo.Make = printerSettings.OemLayer[SettingsKey.make];
}
if (printerSettings.OemLayer.ContainsKey(SettingsKey.model))
{
printerInfo.Model = printerSettings.OemLayer[SettingsKey.model] ?? "Other";
}
printerSettings.Save();
importSuccessful = true;
}
break;
case ".ini":
//Scope variables
{
var settingsToImport = PrinterSettingsLayer.LoadFromIni(settingsFilePath);
var printerSettings = new PrinterSettings()
{
ID = printerInfo.ID,
};
bool containsValidSetting = false;
printerSettings.OemLayer = new PrinterSettingsLayer();
printerSettings.OemLayer[SettingsKey.make] = "Other";
printerSettings.OemLayer[SettingsKey.model] = "Other";
foreach (var item in settingsToImport)
{
if (printerSettings.Contains(item.Key))
{
containsValidSetting = true;
string currentValue = printerSettings.GetValue(item.Key).Trim();
// Compare the value to import to the layer cascade value and only set if different
if (currentValue != item.Value)
{
printerSettings.OemLayer[item.Key] = item.Value;
}
}
}
if (containsValidSetting)
{
printerSettings.UserLayer[SettingsKey.printer_name] = printerInfo.Name;
printerSettings.ClearValue(SettingsKey.device_token);
printerInfo.DeviceToken = "";
printerInfo.Make = printerSettings.OemLayer[SettingsKey.make] ?? "Other";
printerInfo.Model = printerSettings.OemLayer[SettingsKey.model] ?? "Other";
Instance.Profiles.Add(printerInfo);
printerSettings.Helpers.SetName(printerInfo.Name);
printerSettings.Save();
importSuccessful = true;
}
}
break;
}
return(importSuccessful);
}
internal static void AcquireNewProfile(string make, string model, string printerName)
{
string guid = Guid.NewGuid().ToString();
OemProfile oemProfile = LoadHttpOemProfile(make, model);
var layeredProfile = new PrinterSettings()
{
ID = guid,
// TODO: This should really be set by the system that generates the source documents
DocumentVersion = PrinterSettings.LatestVersion,
OemLayer = oemProfile.OemLayer
};
layeredProfile.UserLayer[SettingsKey.printer_name.ToString()] = printerName;
// Import named macros as defined in the following printers: (Airwolf Axiom, HD, HD-R, HD2x, HDL, HDx, Me3D Me2, Robo R1[+])
var classicDefaultMacros = layeredProfile.GetValue("default_macros");
if (!string.IsNullOrEmpty(classicDefaultMacros))
{
var namedMacros = new Dictionary <string, string>();
namedMacros["Lights On"] = "M42 P6 S255";
namedMacros["Lights Off"] = "M42 P6 S0";
namedMacros["Offset 0.8"] = "M565 Z0.8;\nM500";
namedMacros["Offset 0.9"] = "M565 Z0.9;\nM500";
namedMacros["Offset 1"] = "M565 Z1;\nM500";
namedMacros["Offset 1.1"] = "M565 Z1.1;\nM500";
namedMacros["Offset 1.2"] = "M565 Z1.2;\nM500";
namedMacros["Z Offset"] = "G1 Z10;\nG28;\nG29;\nG1 Z10;\nG1 X5 Y5 F4000;\nM117;";
foreach (string namedMacro in classicDefaultMacros.Split(','))
{
string gcode;
if (namedMacros.TryGetValue(namedMacro.Trim(), out gcode))
{
layeredProfile.Macros.Add(new GCodeMacro()
{
Name = namedMacro.Trim(),
GCode = gcode
});
}
}
}
// Copy OemProfile presets into user layers
foreach (var materialPreset in oemProfile.MaterialLayers)
{
layeredProfile.MaterialLayers.Add(materialPreset);
}
foreach (var qualityPreset in oemProfile.QualityLayers)
{
layeredProfile.QualityLayers.Add(qualityPreset);
}
layeredProfile.Save();
Instance.Profiles.Add(new PrinterInfo
{
Name = printerName,
ID = guid
});
UserSettings.Instance.set("ActiveProfileID", guid);
ActiveSliceSettings.Instance = new SettingsProfile(layeredProfile);
}
public string ExtruderTemperature(int extruderIndex)
{
if (extruderIndex >= printerSettings.MaterialSettingsKeys.Count)
{
// MaterialSettingsKeys is empty or lacks a value for the given extruder index
//
// If extruder index zero was requested, return the layer cascade temperature value, otherwise null
return((extruderIndex == 0) ? printerSettings.GetValue("temperature") : null);
}
string materialKey = printerSettings.MaterialSettingsKeys[extruderIndex];
if (extruderIndex == 0 && (string.IsNullOrEmpty(materialKey) || printerSettings.UserLayer.ContainsKey("temperature")))
{
// In the case where a user override exists or MaterialSettingsKeys is populated with multiple extruder
// positions but position 0 is empty and thus unassigned, use layer cascade to resolve temp
return(printerSettings.GetValue("temperature"));
}
// Otherwise, use the SettingsLayers that is bound to this extruder
PrinterSettingsLayer layer = printerSettings.GetMaterialLayer(materialKey);
string result = "0";
layer?.TryGetValue("temperature", out result);
return(result);
}
public double ExtruderTemperature(int extruderIndex)
{
if (extruderIndex == 0)
{
return(printerSettings.GetValue <double>(SettingsKey.temperature));
}
else
{
// Check if there is a material override for this extruder
// Otherwise, use the SettingsLayers that is bound to this extruder
if (extruderIndex < printerSettings.MaterialSettingsKeys.Count)
{
string materialKey = printerSettings.MaterialSettingsKeys[extruderIndex];
PrinterSettingsLayer layer = printerSettings.GetMaterialLayer(materialKey);
if (layer != null)
{
string result = "0";
if (layer.TryGetValue(SettingsKey.temperature, out result))
{
double value = 0;
if (double.TryParse(result, out value))
{
return(value);
}
}
}
}
// else return the normal settings cascade
return(printerSettings.GetValue <double>(SettingsKey.temperature));
}
}
///<summary>
///Returns the first matching value discovered while enumerating the settings layers
///</summary>
public string GetValue(string sliceSetting, IEnumerable <PrinterSettingsLayer> layerCascade = null)
{
return(layeredProfile.GetValue(sliceSetting, layerCascade));
}
