mattercontrol/SlicerConfiguration/SliceSettingsWidget.cs

/*
Copyright (c) 2018, Lars Brubaker, John Lewin
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the FreeBSD Project.
*/

using System;
using System.Collections.Generic;
using System.Linq;
using MatterHackers.Agg;
using MatterHackers.Agg.UI;
using MatterHackers.Localizations;
using MatterHackers.MatterControl.CustomWidgets;
using MatterHackers.MatterControl.PartPreviewWindow;
using MatterHackers.MatterControl.PrintLibrary;
using MatterHackers.MatterControl.SetupWizard;
using MatterHackers.VectorMath;

namespace MatterHackers.MatterControl.SlicerConfiguration
{ 
	public class SliceSettingsWidget : FlowLayoutWidget
	{
		internal PresetsToolbar settingsControlBar;

		internal SettingsContext settingsContext;
		private PrinterConfig printer;
		private Color textColor;
		private SliceSettingsTabView sliceSettingsTabView;

		private ThemeConfig theme;

		public SliceSettingsWidget(PrinterConfig printer, SettingsContext settingsContext, ThemeConfig theme)
			: base (FlowDirection.TopToBottom)
		{
			this.theme = theme;
			this.printer = printer;
			this.textColor = ActiveTheme.Instance.PrimaryTextColor;
			this.BackgroundColor = ApplicationController.Instance.Theme.TabBodyBackground;

			this.settingsContext = settingsContext;

			settingsControlBar = new PresetsToolbar(printer)
			{
				HAnchor = HAnchor.Stretch,
				Padding = new BorderDouble(8, 12, 8, 8)
			};

			this.AddChild(settingsControlBar);

			this.RebuildSliceSettingsTabs();

			ApplicationController.Instance.ShowHelpChanged += ShowHelp_Changed;

			this.AnchorAll();
		}

		private void ShowHelp_Changed(object sender, EventArgs e)
		{
			this.RebuildSliceSettingsTabs();
		}

		private void RebuildSliceSettingsTabs()
		{
			// Close and remove children
			sliceSettingsTabView?.Close();

			this.AddChild(
				sliceSettingsTabView = new SliceSettingsTabView(
					settingsContext,
					printer,
					this.UserLevel,
					theme,
					isPrimarySettingsView: true,
					databaseMRUKey: UserSettingsKey.SliceSettingsWidget_CurrentTab,
					extendPopupMenu: this.ExtendOverflowMenu));
		}

		private void ExtendOverflowMenu(PopupMenu popupMenu)
		{
			popupMenu.CreateHorizontalLine();
			PopupMenu.MenuItem menuItem;

			menuItem = popupMenu.CreateMenuItem("Export".Localize());
			menuItem.Click += (s, e) =>
			{
				DialogWindow.Show<ExportSettingsPage>();
			};

			menuItem = popupMenu.CreateMenuItem("Restore Settings".Localize());
			menuItem.Click += (s, e) =>
			{
				DialogWindow.Show<PrinterProfileHistoryPage>();
			};
			menuItem.Enabled = !string.IsNullOrEmpty(AuthenticationData.Instance.ActiveSessionUsername);

			menuItem = popupMenu.CreateMenuItem("Reset to Defaults".Localize());
			menuItem.Click += (s, e) =>
			{
				UiThread.RunOnIdle(() =>
				{
					StyledMessageBox.ShowMessageBox(
						revertSettings =>
						{
							if (revertSettings)
							{
								bool onlyReloadSliceSettings = true;
								if (printer.Settings.GetValue<bool>(SettingsKey.print_leveling_required_to_print)
								&& printer.Settings.GetValue<bool>(SettingsKey.print_leveling_enabled))
								{
									onlyReloadSliceSettings = false;
								}

								printer.Settings.ClearUserOverrides();
								printer.Settings.Save();

								if (onlyReloadSliceSettings)
								{
									printer?.Bed.GCodeRenderer?.Clear3DGCode();
								}
								else
								{
									ApplicationController.Instance.ReloadAll();
								}
							}
						},
						"Resetting to default values will remove your current overrides and restore your original printer settings.\nAre you sure you want to continue?".Localize(),
						"Revert Settings".Localize(),
						StyledMessageBox.MessageType.YES_NO);
				});
			};
		}

		public string UserLevel { get; } = "Advanced";

		// TODO: This should just proxy to settingsControlBar.Visible. Having local state and pushing values on event listeners seems off
		private bool showControlBar = true;
		public bool ShowControlBar
		{
			get { return showControlBar; }
			set
			{
				settingsControlBar.Visible = value;
				showControlBar = value;
			}
		}

		public override void OnClosed(ClosedEventArgs e)
		{
			ApplicationController.Instance.ShowHelpChanged -= ShowHelp_Changed;
			base.OnClosed(e);
		}
	}

	public class SliceSettingsTabView : SimpleTabs
	{
		private int tabIndexForItem = 0;
		private Dictionary<string, UIField> allUiFields = new Dictionary<string, UIField>();
		private ThemeConfig theme;
		private PrinterConfig printer;
		private SettingsContext settingsContext;
		private bool isPrimarySettingsView;
		private bool showSubGroupHeadings = false;

		private SearchInputBox searchPanel;
		private int groupPanelCount = 0;
		private List<(GuiWidget widget, SliceSettingData settingData)> settingsRows;
		private TextWidget filteredItemsHeading;
		private EventHandler unregisterEvents;
		private Action<PopupMenu> externalExtendMenu;

		public SliceSettingsTabView(SettingsContext settingsContext, PrinterConfig printer, string UserLevel, ThemeConfig theme, bool isPrimarySettingsView, string databaseMRUKey, Action<PopupMenu> extendPopupMenu = null)
			: base (theme)
		{
			this.VAnchor = VAnchor.Stretch;
			this.HAnchor = HAnchor.Stretch;
			this.externalExtendMenu = extendPopupMenu;

			var overflowBar = this.TabBar as OverflowBar;
			overflowBar.ExtendOverflowMenu = this.ExtendOverflowMenu;

			var overflowButton = this.TabBar.RightAnchorItem;
			overflowButton.Name = "Slice Settings Overflow Menu";

			this.TabBar.Padding = this.TabBar.Margin.Clone(right: theme.ToolbarPadding.Right);

			searchPanel = new SearchInputBox()
			{
				Visible = false,
				BackgroundColor = theme.ActiveTabBarBackground,
				MinimumSize = new Vector2(0, this.TabBar.Height)
			};

			searchPanel.searchInput.Margin = new BorderDouble(3, 0);
			searchPanel.searchInput.ActualTextEditWidget.EnterPressed += (s, e) =>
			{
				var filter = searchPanel.searchInput.Text.Trim();

				foreach (var item in this.settingsRows)
				{
					var metaData = item.settingData;

					// Show matching items
					item.widget.Visible = metaData.SlicerConfigName.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0
						|| metaData.HelpText.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0;
				}

				this.ShowFilteredView();
			};
			searchPanel.ResetButton.Click += (s, e) =>
			{
				searchPanel.Visible = false;
				searchPanel.searchInput.Text = "";

				this.ClearFilter();
			};

			// Add heading for My Settings view
			searchPanel.AddChild(filteredItemsHeading = new TextWidget("My Modified Settings", pointSize: theme.DefaultFontSize, textColor: theme.Colors.PrimaryTextColor)
			{
				Margin = new BorderDouble(left: 10),
				HAnchor = HAnchor.Left,
				VAnchor = VAnchor.Center,
				Visible = false
			}, 0);

			this.AddChild(searchPanel, 0);

			var scrollable = new ScrollableWidget(true)
			{
				HAnchor = HAnchor.Stretch,
				VAnchor = VAnchor.Stretch,
			};
			scrollable.ScrollArea.HAnchor = HAnchor.Stretch;
			//scrollable.ScrollArea.VAnchor = VAnchor.Fit;

			var tabContainer = new FlowLayoutWidget(FlowDirection.TopToBottom)
			{
				VAnchor = VAnchor.Fit,
				HAnchor = HAnchor.Stretch,
				//DebugShowBounds = true,
				//MinimumSize = new Vector2(200, 200)
			};

			scrollable.AddChild(tabContainer);

			this.AddChild(scrollable);

			// Force TopToBottom flowlayout contained in scrollable as AddChild target
			this.TabContainer = tabContainer;

			this.theme = theme;
			this.printer = printer;
			this.settingsContext = settingsContext;
			this.isPrimarySettingsView = isPrimarySettingsView;

			this.TabBar.BackgroundColor = theme.ActiveTabBarBackground;

			tabIndexForItem = 0;

			var userLevel = SettingsOrganizer.Instance.UserLevels[UserLevel];

			this.settingsRows = new List<(GuiWidget, SliceSettingData)>();

			allUiFields = new Dictionary<string, UIField>();

			// Loop over categories creating a tab for each
			foreach (var category in userLevel.Categories)
			{
				if (category.Name == "Printer"
					&& (settingsContext.ViewFilter == NamedSettingsLayers.Material || settingsContext.ViewFilter == NamedSettingsLayers.Quality))
				{
					continue;
				}

				var categoryPanel = new FlowLayoutWidget(FlowDirection.TopToBottom)
				{
					VAnchor = VAnchor.Fit,
					HAnchor = HAnchor.Stretch,
				};

				// Loop over all groups in this tab and add their content
				bool first = true;

				foreach (var group in category.Groups)
				{
					if (group.Name == "Connection")
					{
						categoryPanel.AddChild(
							this.CreateOemProfileInfoRow());
					}

					var groupContent = this.CreateGroupContent(group);

					if (groupContent.Descendants<SliceSettingsRow>().Any())
					{
						categoryPanel.AddChild(groupContent);
						if(groupContent is SectionWidget sectionWidget)
						{
							sectionWidget.Checkbox.Checked = first;
							first = false;
						}
					}
				}

				if (categoryPanel.Descendants<SliceSettingsRow>().Any())
				{
					this.AddTab(
						new ToolTab(
							category.Name.Localize(),
							this,
							categoryPanel,
							theme,
							hasClose: false,
							pointSize: theme.DefaultFontSize)
						{
							Name = category.Name + " Tab",
							InactiveTabColor = Color.Transparent,
							ActiveTabColor = theme.ActiveTabColor
						});
				}
			}

			this.TabBar.AddChild(new HorizontalSpacer());

			var searchButton = ApplicationController.Instance.Theme.CreateSearchButton();
			searchButton.Click += (s, e) =>
			{
				filteredItemsHeading.Visible = false;
				searchPanel.searchInput.Visible = true;

				searchPanel.Visible = true;
				searchPanel.searchInput.Focus();
				this.TabBar.Visible = false;
			};

			this.TabBar.AddChild(searchButton);

			searchButton.VAnchor = VAnchor.Center;

			searchButton.VAnchorChanged += (s, e) => Console.WriteLine();

			// Restore the last selected tab
			if (int.TryParse(UserSettings.Instance.get(databaseMRUKey), out int tabIndex)
				&& tabIndex >= 0
				&& tabIndex < this.TabCount - 1)
			{
				this.SelectedTabIndex = tabIndex;
			}
			else
			{
				this.SelectedTabIndex = 0;
			}

			// Store the last selected tab on change
			this.ActiveTabChanged += (s, e) =>
			{
				if (settingsContext.IsPrimarySettingsView)
				{
					UserSettings.Instance.set(databaseMRUKey, this.SelectedTabIndex.ToString());
				}
			};

			ActiveSliceSettings.SettingChanged.RegisterEvent(
				(s, e) =>
				{
					if (e is StringEventArgs stringEvent)
					{
						string settingsKey = stringEvent.Data;
						if (this.allUiFields.TryGetValue(settingsKey, out UIField uifield))
						{
							string currentValue = settingsContext.GetValue(settingsKey);
							if (uifield.Value != currentValue
								|| settingsKey == "com_port")
							{
								uifield.SetValue(
									currentValue,
									userInitiated: false);
							}
						}
					}
				},
				ref unregisterEvents);
		}

		private void ExtendOverflowMenu(PopupMenu popupMenu)
		{
			popupMenu.CreateMenuItem("View Just My Settings".Localize()).Click += (s, e) =>
			{
				this.FilterToOverrides();
			};

			popupMenu.CreateHorizontalLine();

			popupMenu.CreateBoolMenuItem(
				"Show Help".Localize(),
				() => ApplicationController.Instance.ShowHelpControls,
				(value) => ApplicationController.Instance.ShowHelpControls = value);

			externalExtendMenu?.Invoke(popupMenu);
		}

		public Dictionary<string, UIField> UIFields => allUiFields;

		public FlowLayoutWidget CreateGroupContent(SettingsOrganizer.Group group)
		{
			var groupPanel = new FlowLayoutWidget(FlowDirection.TopToBottom)
			{
				VAnchor = VAnchor.Fit,
				HAnchor = HAnchor.Stretch,
				Padding = new BorderDouble(6, 4, 6, 0),
				Name = "GroupPanel" + groupPanelCount++
			};

			var sectionWidget = new SectionWidget(group.Name, groupPanel, theme).ApplyBoxStyle();
			
			foreach (var subGroup in group.SubGroups)
			{
				var subGroupPanel = this.AddSettingRowsForSubgroup(subGroup);
				if (subGroupPanel != null)
				{
					if (showSubGroupHeadings)
					{
						var headingColor = theme.Colors.PrimaryTextColor.AdjustLightness(ActiveTheme.Instance.IsDarkTheme ? 0.5 : 2.8).ToColor();

						// Section heading
						groupPanel.AddChild(new TextWidget("  " + subGroup.Name.Localize(), textColor: headingColor, pointSize: theme.FontSize10)
						{
							Margin = new BorderDouble(left: 8, top: 6, bottom: 4),
						});
					}

					groupPanel.AddChild(subGroupPanel);
				}
			}

			return sectionWidget;
		}

		private GuiWidget AddSettingRowsForSubgroup(SettingsOrganizer.SubGroup subGroup)
		{
			var topToBottomSettings = new FlowLayoutWidget(FlowDirection.TopToBottom)
			{
				HAnchor = HAnchor.Stretch,
			};

			topToBottomSettings.AddChild(new HorizontalLine(20));

			HorizontalLine lastLine = null;

			foreach (SliceSettingData settingData in subGroup.Settings)
			{
				// Note: tab sections may disappear if / when they are empty, as controlled by:
				// settingShouldBeShown / addedSettingToSubGroup / needToAddSubGroup
				bool settingShouldBeShown = CheckIfShouldBeShown(settingData, settingsContext);

				if (EngineMappingsMatterSlice.Instance.MapContains(settingData.SlicerConfigName)
					&& settingShouldBeShown)
				{
					var settingsRow = CreateItemRow(settingData);

					this.settingsRows.Add((settingsRow, settingData));

					topToBottomSettings.AddChild(settingsRow);

					topToBottomSettings.AddChild(lastLine = new HorizontalLine(20)
					{
						Margin = 0
					});

					if (ApplicationController.Instance.ShowHelpControls)
					{
						topToBottomSettings.AddChild(AddInHelpText(topToBottomSettings, settingData));
					}
				}
			}

			lastLine?.Close();

			return (topToBottomSettings.Children.Count == 1) ? null : topToBottomSettings;
		}

		private static bool CheckIfShouldBeShown(SliceSettingData settingData, SettingsContext settingsContext)
		{
			bool settingShouldBeShown = settingsContext.ParseShowString(settingData.ShowIfSet);
			if (settingsContext.ViewFilter == NamedSettingsLayers.Material || settingsContext.ViewFilter == NamedSettingsLayers.Quality)
			{
				if (!settingData.ShowAsOverride)
				{
					settingShouldBeShown = false;
				}
			}

			return settingShouldBeShown;
		}

		private static GuiWidget AddInHelpText(FlowLayoutWidget topToBottomSettings, SliceSettingData settingData)
		{
			double textRegionWidth = 380 * GuiWidget.DeviceScale;
			double helpPointSize = 10;

			var allText = new FlowLayoutWidget(FlowDirection.TopToBottom)
			{
				HAnchor = HAnchor.Stretch,
				Margin = new BorderDouble(0),
				Padding = new BorderDouble(5),
			};

			allText.AddChild(
				new WrappedTextWidget(settingData.HelpText, pointSize: helpPointSize, textColor: Color.White)
				{
					Width = textRegionWidth,
					Margin = new BorderDouble(5, 0, 0, 0)
				});

			allText.MinimumSize = new Vector2(0, allText.MinimumSize.Y);
			return allText;
		}

		// Creates an information row showing the base OEM profile and its create_date value
		public GuiWidget CreateOemProfileInfoRow()
		{
			var dataArea = new FlowLayoutWidget(FlowDirection.TopToBottom)
			{
				HAnchor = HAnchor.Stretch,
			};

			if (isPrimarySettingsView)
			{
				// OEM_LAYER_DATE:
				string lastUpdateTime = "March 1, 2016";
				if (ActiveSliceSettings.Instance?.OemLayer != null)
				{
					string fromCreatedDate = ActiveSliceSettings.Instance.OemLayer.ValueOrDefault(SettingsKey.created_date);
					try
					{
						if (!string.IsNullOrEmpty(fromCreatedDate))
						{
							DateTime time = Convert.ToDateTime(fromCreatedDate).ToLocalTime();
							lastUpdateTime = time.ToString("MMMM d, yyyy h:mm tt");
						}
					}
					catch
					{
					}
				}

				var row = new FlowLayoutWidget()
				{
					BackgroundColor = ActiveTheme.Instance.TertiaryBackgroundColor,
					Padding = new BorderDouble(5),
					Margin = new BorderDouble(3, 20, 3, 0),
					HAnchor = HAnchor.Stretch,
				};

				string make = settingsContext.GetValue(SettingsKey.make);
				string model = settingsContext.GetValue(SettingsKey.model);

				string title = $"{make} {model}";
				if (title == "Other Other")
				{
					title = "Custom Profile".Localize();
				}

				row.AddChild(new TextWidget(title, pointSize: 9)
				{
					Margin = new BorderDouble(0, 4, 10, 4),
					TextColor = ActiveTheme.Instance.PrimaryTextColor,
				});

				row.AddChild(new HorizontalSpacer());

				row.AddChild(new TextWidget(lastUpdateTime, pointSize: 9)
				{
					Margin = new BorderDouble(0, 4, 10, 4),
					TextColor = ActiveTheme.Instance.PrimaryTextColor,
				});

				dataArea.AddChild(row);
			}

			return dataArea;
		}

		internal GuiWidget CreateItemRow(SliceSettingData settingData)
		{
			return CreateItemRow(settingData, settingsContext, printer, theme.Colors.PrimaryTextColor, theme, ref tabIndexForItem, allUiFields);
		}

		public static GuiWidget CreateItemRow(SliceSettingData settingData, SettingsContext settingsContext, PrinterConfig printer, Color textColor, ThemeConfig theme, ref int tabIndexForItem, Dictionary<string, UIField> fieldCache = null)
		{
			string sliceSettingValue = settingsContext.GetValue(settingData.SlicerConfigName);

			UIField uiField = null;

			bool useDefaultSavePattern = true;
			bool placeFieldInDedicatedRow = false;

			var settingsRow = new SliceSettingsRow(printer, settingsContext, settingData, textColor)
			{
				Padding = new BorderDouble(left: 6),
				HAnchor = HAnchor.Stretch,
				VAnchor = VAnchor.Fit
			};

			if (!PrinterSettings.KnownSettings.Contains(settingData.SlicerConfigName))
			{
				// the setting we think we are adding is not in the known settings it may have been deprecated
				TextWidget settingName = new TextWidget(String.Format("Setting '{0}' not found in known settings", settingData.SlicerConfigName));
				settingName.TextColor = textColor;
				settingsRow.NameArea.AddChild(settingName);
				settingsRow.NameArea.BackgroundColor = Color.Red;
			}
			else
			{
				settingsRow.NameArea.AddChild(
					CreateSettingsLabel(settingData.PresentationName.Localize(), settingData.HelpText, textColor));

				switch (settingData.DataEditType)
				{
					case SliceSettingData.DataEditTypes.INT:

						var intField = new IntField();
						uiField = intField;

						if (settingData.SlicerConfigName == "extruder_count")
						{
							intField.MaxValue = 4;
							intField.MinValue = 0;
						}

						break;

					case SliceSettingData.DataEditTypes.DOUBLE:
					case SliceSettingData.DataEditTypes.OFFSET:
						uiField = new DoubleField();
						break;

					case SliceSettingData.DataEditTypes.POSITIVE_DOUBLE:
						if (settingData.SetSettingsOnChange.Count > 0)
						{
							uiField = new BoundDoubleField(settingsContext, settingData);
						}
						else
						{
							uiField = new PositiveDoubleField();
						};
						break;

					case SliceSettingData.DataEditTypes.DOUBLE_OR_PERCENT:
						uiField = new DoubleOrPercentField();
						break;

					case SliceSettingData.DataEditTypes.INT_OR_MM:
						uiField = new IntOrMmField();
						break;

					case SliceSettingData.DataEditTypes.CHECK_BOX:
						uiField = new ToggleboxField(textColor);
						useDefaultSavePattern = false;
						uiField.ValueChanged += (s, e) =>
						{
							if (e.UserInitiated)
							{
								// Linked settings should be updated in all cases (user clicked checkbox, user clicked clear)
								foreach (var setSettingsData in settingData.SetSettingsOnChange)
								{
									string targetValue;

									if (uiField.Content is CheckBox checkbox)
									{
										if (setSettingsData.TryGetValue(checkbox.Checked ? "OnValue" : "OffValue", out targetValue))
										{
											settingsContext.SetValue(setSettingsData["TargetSetting"], targetValue);
										}
									}
								}

								// Store actual field value
								settingsContext.SetValue(settingData.SlicerConfigName, uiField.Value);
							}
						};
						break;

					case SliceSettingData.DataEditTypes.STRING:
					case SliceSettingData.DataEditTypes.WIDE_STRING:
						uiField = new TextField();
						break;

					case SliceSettingData.DataEditTypes.MULTI_LINE_TEXT:
						uiField = new MultilineStringField();
						placeFieldInDedicatedRow = true;
						break;

					case SliceSettingData.DataEditTypes.COM_PORT:
						useDefaultSavePattern = false;

						sliceSettingValue = printer.Settings.Helpers.ComPort();

						uiField = new ComPortField(printer, theme);
						uiField.ValueChanged += (s, e) =>
						{
							if (e.UserInitiated)
							{
								printer.Settings.Helpers.SetComPort(uiField.Value);
							}
						};

						break;

					case SliceSettingData.DataEditTypes.LIST:
						uiField = new ListField()
						{
							ListItems = settingData.ListValues.Split(',').ToList()
						};
						break;

					case SliceSettingData.DataEditTypes.HARDWARE_PRESENT:
						uiField = new ToggleboxField(textColor);
						break;

					case SliceSettingData.DataEditTypes.VECTOR2:
						uiField = new Vector2Field();
						break;

					case SliceSettingData.DataEditTypes.OFFSET2:
						placeFieldInDedicatedRow = true;
						uiField = new ExtruderOffsetField(settingsContext, settingData.SlicerConfigName, textColor);
						break;
#if !__ANDROID__
					case SliceSettingData.DataEditTypes.IP_LIST:
						uiField = new IpAddessField(printer);
						break;
#endif

					default:
						// Missing Setting
						settingsRow.AddContent(new TextWidget(String.Format("Missing the setting for '{0}'.", settingData.DataEditType.ToString()))
						{
							TextColor = textColor,
							BackgroundColor = Color.Red
						});
						break;
				}
			}

			if (uiField != null)
			{
				if (fieldCache != null)
				{
					fieldCache[settingData.SlicerConfigName] = uiField;
				}

				uiField.HelpText = settingData.HelpText;

				uiField.Name = $"{settingData.PresentationName} Field";
				uiField.Initialize(tabIndexForItem++);

				if (settingData.DataEditType == SliceSettingData.DataEditTypes.WIDE_STRING)
				{
					uiField.Content.HAnchor = HAnchor.Stretch;
					placeFieldInDedicatedRow = true;
				}

				uiField.SetValue(sliceSettingValue, userInitiated: false);

				uiField.ValueChanged += (s, e) =>
				{
					if (useDefaultSavePattern
						&& e.UserInitiated)
					{
						settingsContext.SetValue(settingData.SlicerConfigName, uiField.Value);
					}

					settingsRow.UpdateStyle();
				};

				// After initializing the field, wrap with dropmenu if applicable
				if (settingData.QuickMenuSettings.Count > 0 
					&& settingData.SlicerConfigName == "baud_rate")
				{
					var dropMenu = new DropMenuWrappedField(uiField, settingData, textColor);
					dropMenu.Initialize(tabIndexForItem);

					settingsRow.AddContent(dropMenu.Content);
				}
				else
				{
					if (!placeFieldInDedicatedRow)
					{
						settingsRow.AddContent(uiField.Content);
					}
				}
			}

			// Invoke the UpdateStyle implementation
			settingsRow.UpdateStyle();

			bool settingEnabled = settingsContext.ParseShowString(settingData.EnableIfSet);
			if (settingEnabled
				|| settingsContext.ViewFilter == NamedSettingsLayers.Material
				|| settingsContext.ViewFilter == NamedSettingsLayers.Quality)
			{
				if (placeFieldInDedicatedRow)
				{
					var column = new FlowLayoutWidget(FlowDirection.TopToBottom)
					{
						Name = "column",
						HAnchor = HAnchor.Stretch,
						VAnchor = VAnchor.Fit
					};
					column.AddChild(settingsRow);

					var row = new FlowLayoutWidget()
					{
						Name = "row",
						VAnchor = VAnchor.Fit,
						HAnchor = HAnchor.Stretch,
						MinimumSize = new Vector2(0, 28),
						BackgroundColor = settingsRow.BackgroundColor,
						Border = settingsRow.Border,
						Padding = settingsRow.Padding,
						Margin = settingsRow.Margin,
					};
					column.AddChild(row);

					var contentWrapper = new GuiWidget
					{
						Name = "contentWrapper",
						HAnchor = HAnchor.Stretch,
						VAnchor = VAnchor.Fit,
						Padding = new BorderDouble(right: 16, bottom: 10),
					};
					contentWrapper.AddChild(uiField.Content);

					row.AddChild(contentWrapper);

					settingsRow.StyleChanged += (s, e) =>
					{
						row.BackgroundColor = settingsRow.BackgroundColor;
						row.BorderColor = settingsRow.HighlightColor;
					};

					return column;
				}
				else
				{
					return settingsRow;
				}
			}
			else
			{
				settingsRow.Enabled = false;
				return settingsRow;
			}
		}

		public static GuiWidget CreateSettingsLabel(string label, string helpText, Color textColor)
		{
			return new WrappedTextWidget(label, pointSize: 10, textColor: textColor)
			{
				VAnchor = VAnchor.Center | VAnchor.Fit,
				ToolTipText = helpText,
				Margin = new BorderDouble(0, 5, 5, 5),
			};
		}

		public void FilterToOverrides()
		{
			var defaultCascade = printer.Settings.defaultLayerCascade;

			var baseAndOem = new List<PrinterSettingsLayer>() { printer.Settings.OemLayer, printer.Settings.BaseLayer };

			foreach (var item in this.settingsRows)
			{
				var settingData = item.settingData;

				var (currentValue, layerName) = printer.Settings.GetValueAndLayerName(settingData.SlicerConfigName, defaultCascade);

				item.widget.Visible = layerName != "Oem" && layerName != "Base";

				if(layerName == "User" 
					&& currentValue == printer.Settings.GetValueAndLayerName(settingData.SlicerConfigName, baseAndOem).currentValue)
				{
					item.widget.Visible = false;
					item.widget.Visible = true;
					item.widget.Visible = false;
				}
			}

			filteredItemsHeading.Visible = true;
			searchPanel.searchInput.Visible = false;
			this.TabBar.Visible = false;
			searchPanel.Visible = true;

			this.ShowFilteredView();
		}

		List<SectionWidget> widgetsThatWereExpanded = new List<SectionWidget>();

		private void ShowFilteredView()
		{
			widgetsThatWereExpanded.Clear();
			// Show any section with visible SliceSettingsRows
			foreach (var section in this.Descendants<SectionWidget>())
			{
				// HACK: Include parent visibility in mix as complex fields that return wrapped SliceSettingsRows will be visible and their parent will be hidden
				section.Visible = section.Descendants<SliceSettingsRow>().Any(row => row.Visible && row.Parent.Visible);
				if (!section.Checkbox.Checked)
				{
					widgetsThatWereExpanded.Add(section);
					section.Checkbox.Checked = true;
				}
			}

			// Show all tab containers
			foreach (var tab in this.AllTabs)
			{
				tab.TabContent.Visible = true;
			}
		}

		public override void OnClosed(ClosedEventArgs e)
		{
			unregisterEvents?.Invoke(this, null);
			base.OnClosed(e);
		}

		public void ClearFilter()
		{
			foreach (var item in this.settingsRows)
			{
				// Show matching items
				item.widget.Visible = true;
			}

			foreach (var tab in this.AllTabs)
			{
				tab.TabContent.Visible = (tab == this.ActiveTab);
			}

			foreach (var section in this.Descendants<SectionWidget>())
			{
				// HACK: Include parent visibility in mix as complex fields that return wrapped SliceSettingsRows will be visible and their parent will be hidden
				section.Visible = section.Descendants<SliceSettingsRow>().Any(row => row.Visible && row.Parent.Visible);
			}

			foreach (var section in widgetsThatWereExpanded)
			{
				section.Checkbox.Checked = false;
			}

			this.TabBar.Visible = true;
		}
	}
}