using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Windows.Forms;
using System.Xml.Serialization;
using QC.GlobalVariableManager;
using QC.QsprShared.Dialogs;
using QC.QsprShared.GlobalData;
using QC.QsprShared.Trace;
using QC.QTMInterface;
using QsprMiscShared.Config;

namespace QC.QsprShared.Config;

public class WorkspaceConfig
{
	public struct SerialFont
	{
		public string FontFamily;

		public GraphicsUnit GraphicsUnit;

		public float Size;

		public FontStyle Style;

		public SerialFont(Font f)
		{
			FontFamily = f.FontFamily.Name;
			GraphicsUnit = f.Unit;
			Size = f.Size;
			Style = f.Style;
		}

		public Font ToFont()
		{
			return new Font(FontFamily, Size, Style, GraphicsUnit);
		}
	}

	public enum SearchOptions
	{
		TestName,
		RealName,
		BranchOnError,
		BreakPoint,
		BookKeepingTest,
		ParameterName,
		RetryCount,
		Loop,
		StopOnError,
		PreCondition,
		PostCondition,
		TestErrorCode,
		Comments,
		Registry
	}

	private string alwaysOpenFile = "";

	private bool openPreviousFile = true;

	private bool autoSyncTree;

	private bool syncDescriptions;

	private int recentFileListSize = 3;

	private ArrayList recentFileList = new ArrayList();

	private bool suppressWarnings;

	private bool verifyDllVersion;

	private bool doubleClickRunsTest;

	private bool minimizeAtStartup;

	private bool askBeforeStoppingTree;

	private string iconSize = "Small Icons";

	private string iconType = "Office 2003";

	private string debugWindowSaveLocation = "";

	private string testResultsSaveLocation = "";

	private bool saveAllDebugWindows = true;

	private bool showDebugMessages = true;

	private bool saveDebugOnlyOnFail;

	private bool saveInSubFolders;

	private bool showToolTips = true;

	private SerialFont font = new SerialFont(new Font("Microsoft Sans Serif", 10f));

	private string lastUsedSerialNumber = "";

	private ArrayList tempList = new ArrayList();

	private bool simulationMode;

	private ArrayList pluginDetails = new ArrayList();

	private bool enableTracing;

	private bool enableSound = true;

	private bool enableHiveTracing;

	private string startUpTTDPlugin = "Test Tree";

	private TraceLevel debugTraceLevel = TraceLevel.Verbose;

	private bool seperateTraceLevelWindows;

	private string debugWindowUpdateOption = "Auto Update";

	private bool autoScrollDebugWindows = true;

	private string testResultMessageProcessingOption = "Auto Update";

	private bool allowOperatorRunUnregisteredTrees;

	private bool allowOperatorAbortTestRun = true;

	private string customStartupEvents = "";

	private string schedulerID;

	private BailOutLogicSelection bailOutLogic;

	private double bailOutLogicFixedNumber;

	private double bailOutLogicFixedPercentage;

	private double bailOutLogicFixedNumberConsective;

	private double bailOutLogicFixedPercentageConsective;

	private bool skipTCOnOpenIR;

	private bool skipTCOnOpenSetupIssues;

	private bool skipTCOnOpenAutomationIssues;

	private string skipTCOnIssuesAPIBase = "http://qlap:8777/api/TestCases/GetOpenIssues";

	private int numberOfDaysToLookUpIssues = 30;

	private string listOfSUITELoop;

	private bool resetGlobalVariables = true;

	private bool suppressSerialNumberDialog;

	private bool createDebugWindowsOnLoading;

	private string listofDebugWinNames = "";

	private bool suppressResultsDialog;

	private bool showFailedtests;

	private bool clearSerialNumber;

	private string customLinkAppName;

	private string customLinkAppArgs;

	private string customAppToolTip = "Custom Tool. Option is set in Workspaceconfig";

	private bool useDllSearch;

	private List<string> dllPaths = new List<string>();

	private bool suppressSpashScreen;

	private int maxDisplayDebugCharacters = 1800000;

	private bool refreshCurrSettings = true;

	private bool showTimeStamp;

	private bool showDateStamp;

	private bool autoResizeDebugWindows;

	private bool enableSUITEOutParam;

	private bool enableSuiteGV;

	private List<SuiteParamGV> suiteParamGVs = new List<SuiteParamGV>();

	private string searchString;

	private SearchOptions currentSearchOptions;

	private bool searchCaseMatch;

	private double treeItemMargin;

	private sbyte m_NodeDetailsChoice = 31;

	private bool sendAllInputConditions = true;

	private bool warnXmlForDbMissing = true;

	[DefaultValue(0)]
	public double BailOutLogicFixedNumber
	{
		get
		{
			return bailOutLogicFixedNumber;
		}
		set
		{
			bailOutLogicFixedNumber = value;
		}
	}

	[DefaultValue(0)]
	public double BailOutLogicFixedPercentage
	{
		get
		{
			return bailOutLogicFixedPercentage;
		}
		set
		{
			bailOutLogicFixedPercentage = value;
		}
	}

	[DefaultValue(0)]
	public double BailOutLogicFixedNumberConsective
	{
		get
		{
			return bailOutLogicFixedNumberConsective;
		}
		set
		{
			bailOutLogicFixedNumberConsective = value;
		}
	}

	[DefaultValue(0)]
	public double BailOutLogicFixedPercentageConsective
	{
		get
		{
			return bailOutLogicFixedPercentageConsective;
		}
		set
		{
			bailOutLogicFixedPercentageConsective = value;
		}
	}

	[DefaultValue(BailOutLogicSelection.None)]
	public BailOutLogicSelection BailOutLogic
	{
		get
		{
			return bailOutLogic;
		}
		set
		{
			bailOutLogic = value;
		}
	}

	[DefaultValue(false)]
	public bool SkipTCOnOpenIR
	{
		get
		{
			return skipTCOnOpenIR;
		}
		set
		{
			skipTCOnOpenIR = value;
		}
	}

	[DefaultValue(false)]
	public bool SkipTCOnOpenSetupIssues
	{
		get
		{
			return skipTCOnOpenSetupIssues;
		}
		set
		{
			skipTCOnOpenSetupIssues = value;
		}
	}

	[DefaultValue(false)]
	public bool SkipTCOnOpenAutomationIssues
	{
		get
		{
			return skipTCOnOpenAutomationIssues;
		}
		set
		{
			skipTCOnOpenAutomationIssues = value;
		}
	}

	[DefaultValue("http://qlap:8777/api/TestCases/GetOpenIssues")]
	public string SkipTCOnIssuesAPIBase
	{
		get
		{
			return skipTCOnIssuesAPIBase;
		}
		set
		{
			skipTCOnIssuesAPIBase = value;
		}
	}

	[DefaultValue(30)]
	public int NumberOfDaysToLookUpIssues
	{
		get
		{
			return numberOfDaysToLookUpIssues;
		}
		set
		{
			numberOfDaysToLookUpIssues = value;
		}
	}

	public string ListOfSUITELoop
	{
		get
		{
			return listOfSUITELoop;
		}
		set
		{
			listOfSUITELoop = value;
		}
	}

	[DefaultValue(true)]
	public bool ResetGlobalVariables
	{
		get
		{
			return resetGlobalVariables;
		}
		set
		{
			resetGlobalVariables = value;
		}
	}

	[DefaultValue(false)]
	public bool SuppressSerialNumberDialog
	{
		get
		{
			return suppressSerialNumberDialog;
		}
		set
		{
			suppressSerialNumberDialog = value;
		}
	}

	[DefaultValue(false)]
	public bool CreateDebugWindowsOnLoading
	{
		get
		{
			return createDebugWindowsOnLoading;
		}
		set
		{
			createDebugWindowsOnLoading = value;
		}
	}

	[DefaultValue("")]
	public string ListofDebugWinNames
	{
		get
		{
			return listofDebugWinNames;
		}
		set
		{
			listofDebugWinNames = value;
		}
	}

	[DefaultValue(false)]
	public bool SuppressResultsDialog
	{
		get
		{
			return suppressResultsDialog;
		}
		set
		{
			suppressResultsDialog = value;
		}
	}

	[DefaultValue(false)]
	public bool ShowFailedTests
	{
		get
		{
			return showFailedtests;
		}
		set
		{
			showFailedtests = value;
		}
	}

	[DefaultValue(false)]
	public bool ClearSerialNumber
	{
		get
		{
			return clearSerialNumber;
		}
		set
		{
			clearSerialNumber = value;
		}
	}

	public string CustomLinkAppName
	{
		get
		{
			return customLinkAppName;
		}
		set
		{
			customLinkAppName = value;
		}
	}

	public string CustomLinkAppArgs
	{
		get
		{
			return customLinkAppArgs;
		}
		set
		{
			customLinkAppArgs = value;
		}
	}

	[DefaultValue("Custom Tool. Option is set in Workspaceconfig")]
	public string CustomAppToolTip
	{
		get
		{
			return customAppToolTip;
		}
		set
		{
			customAppToolTip = value;
		}
	}

	[DefaultValue(false)]
	public bool UseDllSearch
	{
		get
		{
			return useDllSearch;
		}
		set
		{
			useDllSearch = value;
		}
	}

	public List<string> DLLPaths
	{
		get
		{
			return dllPaths;
		}
		set
		{
			dllPaths = value;
		}
	}

	[DefaultValue("")]
	public string AlwaysOpenFile
	{
		get
		{
			return alwaysOpenFile;
		}
		set
		{
			alwaysOpenFile = value;
		}
	}

	[DefaultValue(true)]
	public bool OpenPreviousFile
	{
		get
		{
			return openPreviousFile;
		}
		set
		{
			openPreviousFile = value;
		}
	}

	[DefaultValue(false)]
	public bool AutoSyncTree
	{
		get
		{
			return autoSyncTree;
		}
		set
		{
			autoSyncTree = value;
		}
	}

	[DefaultValue(false)]
	public bool SyncDescriptions
	{
		get
		{
			return syncDescriptions;
		}
		set
		{
			syncDescriptions = value;
		}
	}

	[DefaultValue(3)]
	public int RecentFileListSize
	{
		get
		{
			return recentFileListSize;
		}
		set
		{
			recentFileListSize = value;
		}
	}

	[XmlElement(Type = typeof(string))]
	public ArrayList RecentFileList
	{
		get
		{
			return recentFileList;
		}
		set
		{
			recentFileList = value;
		}
	}

	[XmlElement(Type = typeof(PluginInfo))]
	public ArrayList PluginDetails
	{
		get
		{
			return pluginDetails;
		}
		set
		{
			pluginDetails = value;
		}
	}

	[DefaultValue(false)]
	public bool SuppressWarnings
	{
		get
		{
			return suppressWarnings;
		}
		set
		{
			suppressWarnings = value;
			AppMessageDialog.SuppressWarnings = value;
		}
	}

	[DefaultValue(false)]
	public bool SuppressSpashScreen
	{
		get
		{
			return suppressSpashScreen;
		}
		set
		{
			suppressSpashScreen = value;
		}
	}

	[DefaultValue(false)]
	public bool VerifyDllVersion
	{
		get
		{
			return verifyDllVersion;
		}
		set
		{
			verifyDllVersion = value;
		}
	}

	[DefaultValue(false)]
	public bool DoubleClickRunsTest
	{
		get
		{
			return doubleClickRunsTest;
		}
		set
		{
			doubleClickRunsTest = value;
		}
	}

	[DefaultValue(false)]
	public bool MinimizeAtStartup
	{
		get
		{
			return minimizeAtStartup;
		}
		set
		{
			minimizeAtStartup = value;
		}
	}

	[DefaultValue(false)]
	public bool AskBeforeStoppingTree
	{
		get
		{
			return askBeforeStoppingTree;
		}
		set
		{
			askBeforeStoppingTree = value;
		}
	}

	[DefaultValue(true)]
	public bool SaveAllDebugWindows
	{
		get
		{
			return saveAllDebugWindows;
		}
		set
		{
			saveAllDebugWindows = value;
		}
	}

	[DefaultValue(1800000)]
	public int MaxDisplayDebugCharacters
	{
		get
		{
			return maxDisplayDebugCharacters;
		}
		set
		{
			maxDisplayDebugCharacters = value;
		}
	}

	[DefaultValue(true)]
	public bool RefreshCurrSettings
	{
		get
		{
			return refreshCurrSettings;
		}
		set
		{
			refreshCurrSettings = value;
		}
	}

	[DefaultValue(false)]
	public bool ShowTimeStamp
	{
		get
		{
			return showTimeStamp;
		}
		set
		{
			showTimeStamp = value;
		}
	}

	[DefaultValue(false)]
	public bool ShowDateStamp
	{
		get
		{
			return showDateStamp;
		}
		set
		{
			showDateStamp = value;
		}
	}

	[DefaultValue(false)]
	public bool AutoResizeDebugWindows
	{
		get
		{
			return autoResizeDebugWindows;
		}
		set
		{
			autoResizeDebugWindows = value;
		}
	}

	[DefaultValue(true)]
	public bool ShowDebugMessages
	{
		get
		{
			return showDebugMessages;
		}
		set
		{
			showDebugMessages = value;
		}
	}

	[DefaultValue(true)]
	public bool ShowToolTips
	{
		get
		{
			return showToolTips;
		}
		set
		{
			showToolTips = value;
		}
	}

	[DefaultValue("Small Icons")]
	public string IconSize
	{
		get
		{
			return iconSize;
		}
		set
		{
			iconSize = value;
		}
	}

	[DefaultValue("Office 2003")]
	public string IconType
	{
		get
		{
			return iconType;
		}
		set
		{
		}
	}

	[DefaultValue(false)]
	public bool EnableTracing
	{
		get
		{
			return enableTracing;
		}
		set
		{
			if (!value)
			{
				TraceMessage.EndXMLLogging();
			}
			enableTracing = value;
			TraceMessage.EnableTracing = value;
		}
	}

	[DefaultValue(true)]
	public bool EnableSound
	{
		get
		{
			return enableSound;
		}
		set
		{
			enableSound = value;
		}
	}

	[DefaultValue(false)]
	public bool EnableHiveTracing
	{
		get
		{
			return enableHiveTracing;
		}
		set
		{
			enableHiveTracing = value;
		}
	}

	public string DebugWindowSaveLocation
	{
		get
		{
			return debugWindowSaveLocation;
		}
		set
		{
			if (value.Trim() != "")
			{
				debugWindowSaveLocation = value;
			}
		}
	}

	[DefaultValue(false)]
	public bool SaveDebugOnlyOnFail
	{
		get
		{
			return saveDebugOnlyOnFail;
		}
		set
		{
			saveDebugOnlyOnFail = value;
		}
	}

	[DefaultValue(false)]
	public bool SaveInSubFolders
	{
		get
		{
			return saveInSubFolders;
		}
		set
		{
			saveInSubFolders = value;
		}
	}

	public string TestResultsSaveLocation
	{
		get
		{
			return testResultsSaveLocation;
		}
		set
		{
			if (value.Trim() != "")
			{
				testResultsSaveLocation = value;
			}
		}
	}

	public SerialFont sFont
	{
		get
		{
			return font;
		}
		set
		{
			font = value;
		}
	}

	[DefaultValue("")]
	public string LastUsedSerialNumber
	{
		get
		{
			return lastUsedSerialNumber;
		}
		set
		{
			lastUsedSerialNumber = value;
		}
	}

	[DefaultValue("Test Tree")]
	public string StartUpTTDPlugin
	{
		get
		{
			return startUpTTDPlugin;
		}
		set
		{
			startUpTTDPlugin = value;
		}
	}

	[DefaultValue(TraceLevel.Verbose)]
	public TraceLevel DebugTraceLevel
	{
		get
		{
			return debugTraceLevel;
		}
		set
		{
			debugTraceLevel = value;
		}
	}

	[DefaultValue(false)]
	public bool SeperateTraceLevelWindows
	{
		get
		{
			return seperateTraceLevelWindows;
		}
		set
		{
			seperateTraceLevelWindows = value;
		}
	}

	[DefaultValue("Auto Update")]
	public string DebugWindowUpdateOption
	{
		get
		{
			return debugWindowUpdateOption;
		}
		set
		{
			debugWindowUpdateOption = value;
		}
	}

	[DefaultValue(true)]
	public bool AutoScrollDebugWindows
	{
		get
		{
			return autoScrollDebugWindows;
		}
		set
		{
			autoScrollDebugWindows = value;
		}
	}

	[DefaultValue("Auto Update")]
	public string TestResultMessageProcessingOption
	{
		get
		{
			return testResultMessageProcessingOption;
		}
		set
		{
			testResultMessageProcessingOption = value;
		}
	}

	[DefaultValue(false)]
	public bool EnableSUITEOutParam
	{
		get
		{
			return enableSUITEOutParam;
		}
		set
		{
			if (enableSUITEOutParam != value)
			{
				enableSUITEOutParam = value;
			}
		}
	}

	[DefaultValue(false)]
	public bool EnableSuiteGV
	{
		get
		{
			return enableSuiteGV;
		}
		set
		{
			if (enableSuiteGV != value)
			{
				enableSuiteGV = value;
			}
		}
	}

	public List<SuiteParamGV> SuiteParamGVs
	{
		get
		{
			return suiteParamGVs;
		}
		set
		{
			suiteParamGVs = value;
		}
	}

	[DefaultValue(false)]
	public bool AllowOperatorRunUnregisteredTrees
	{
		get
		{
			return allowOperatorRunUnregisteredTrees;
		}
		set
		{
			allowOperatorRunUnregisteredTrees = value;
		}
	}

	[DefaultValue(true)]
	public bool AllowOperatorAbortTestRun
	{
		get
		{
			return allowOperatorAbortTestRun;
		}
		set
		{
			allowOperatorAbortTestRun = value;
		}
	}

	[DefaultValue("")]
	public string CustomStartupEvents
	{
		get
		{
			return customStartupEvents;
		}
		set
		{
			customStartupEvents = value;
		}
	}

	[DefaultValue("")]
	public string SearchString
	{
		get
		{
			if (QTMGlobalVariable.GetGlobalVariable("QSPR_SEARCH", out var gvValue))
			{
				return gvValue;
			}
			return searchString;
		}
		set
		{
			searchString = value;
			try
			{
				QTMGlobalVariable.SetGlobalVariable("QSPR_SEARCH", searchString);
			}
			catch
			{
			}
		}
	}

	[DefaultValue(SearchOptions.TestName)]
	public SearchOptions CurrentSearchOptions
	{
		get
		{
			return currentSearchOptions;
		}
		set
		{
			currentSearchOptions = value;
		}
	}

	[DefaultValue(false)]
	public bool SearchCaseMatch
	{
		get
		{
			return searchCaseMatch;
		}
		set
		{
			searchCaseMatch = value;
		}
	}

	[XmlIgnore]
	public Font Font
	{
		get
		{
			return sFont.ToFont();
		}
		set
		{
			font = new SerialFont(value);
		}
	}

	[DefaultValue(0)]
	public double TreeItemMargin
	{
		get
		{
			return treeItemMargin;
		}
		set
		{
			treeItemMargin = value;
		}
	}

	[DefaultValue(31)]
	public sbyte NodeDetailsChoice
	{
		get
		{
			return m_NodeDetailsChoice;
		}
		set
		{
			m_NodeDetailsChoice = value;
		}
	}

	[DefaultValue(false)]
	public bool ShowSingleStepTestCaseSteps { get; set; }

	[DefaultValue(true)]
	public bool SendAllInputConditions
	{
		get
		{
			return sendAllInputConditions;
		}
		set
		{
			sendAllInputConditions = value;
		}
	}

	[DefaultValue(true)]
	public bool WarnXmlForDbMissing
	{
		get
		{
			return warnXmlForDbMissing;
		}
		set
		{
			warnXmlForDbMissing = value;
		}
	}

	public void SetSchedulerID(string id)
	{
		schedulerID = id;
	}

	public WorkspaceConfig()
	{
		Directory.CreateDirectory(Path.Combine(Path.GetDirectoryName(Application.ExecutablePath), QTMData.FeatureConfigInfo.LogDirectory));
		Directory.CreateDirectory(Path.Combine(Path.GetDirectoryName(Application.ExecutablePath), QTMData.FeatureConfigInfo.ConfigDirectory));
		debugWindowSaveLocation = Path.Combine(Path.GetDirectoryName(Application.ExecutablePath), QTMData.FeatureConfigInfo.LogDirectory);
		testResultsSaveLocation = Path.Combine(Path.GetDirectoryName(Application.ExecutablePath), QTMData.FeatureConfigInfo.LogDirectory);
	}

	public WSpaceConfig ExportToStruct()
	{
		WSpaceConfig result = default(WSpaceConfig);
		result.alwaysOpenFile = AlwaysOpenFile;
		result.debugWindowSaveLocation = DebugWindowSaveLocation;
		result.Font = Font;
		result.TreeItemMargin = TreeItemMargin;
		result.iconSize = IconSize;
		result.iconType = IconType;
		result.openPreviousFile = OpenPreviousFile;
		result.autoSyncTree = AutoSyncTree;
		result.recentFileList = RecentFileList;
		result.recentFileListSize = RecentFileListSize;
		result.suppressWarnings = SuppressWarnings;
		result.suppressSplashScreen = SuppressSpashScreen;
		result.verifyDllVersion = VerifyDllVersion;
		result.doubleClickRunsTest = DoubleClickRunsTest;
		result.minimizeAtStartup = MinimizeAtStartup;
		result.askBeforeStoppingTree = AskBeforeStoppingTree;
		result.testResultsSaveLocation = TestResultsSaveLocation;
		result.SaveAllDebugWindows = SaveAllDebugWindows;
		result.ShowToolTips = ShowToolTips;
		result.TracingEnabled = EnableTracing;
		result.CustomLinkAppName = customLinkAppName;
		result.CustomLinkArgs = CustomLinkAppArgs;
		result.CustomToolTip = CustomAppToolTip;
		result.ShowFailedTests = ShowFailedTests;
		result.SaveDebugOnlyOnFail = SaveDebugOnlyOnFail;
		result.SaveInSubFolders = SaveInSubFolders;
		result.SuppressResultsDialog = SuppressResultsDialog;
		result.NodeDetailsChoice = NodeDetailsChoice;
		result.AllowOperatorRunUnregisteredTrees = AllowOperatorRunUnregisteredTrees;
		result.AllowOperatorAbortTestRun = AllowOperatorAbortTestRun;
		result.CustomStartupEvents = CustomStartupEvents;
		return result;
	}

	public bool GetLoadStatus(string filename, bool temporaryDomain)
	{
		string[] array = filename.Split('\\');
		string text = array[array.Length - 1];
		text = text.Substring(0, text.Length - 4);
		if (!temporaryDomain)
		{
			if (GlobalStatus.AutomationMode && text.ToUpper() == "QSPRAUTOMATIONPLUGIN")
			{
				return true;
			}
			if (!GlobalStatus.AutomationMode && text.ToUpper() == "QSPRAUTOMATIONPLUGIN")
			{
				return false;
			}
		}
		foreach (PluginInfo pluginDetail in pluginDetails)
		{
			if (pluginDetail.Name == text)
			{
				return pluginDetail.Load;
			}
		}
		return true;
	}

	public void CopyDataLoggingConfig(WorkspaceConfig wConfig)
	{
		TraceMessage.Write(ToString(), "WorkspaceConfig.CopyDataLoggingConfig()", TraceMessageType.Trace);
		try
		{
			TestResultsSaveLocation = wConfig.TestResultsSaveLocation;
			TestResultMessageProcessingOption = wConfig.TestResultMessageProcessingOption;
			DebugWindowSaveLocation = wConfig.DebugWindowSaveLocation;
			SaveAllDebugWindows = wConfig.SaveAllDebugWindows;
			MaxDisplayDebugCharacters = wConfig.MaxDisplayDebugCharacters;
			ShowDebugMessages = wConfig.ShowDebugMessages;
			DebugTraceLevel = wConfig.DebugTraceLevel;
			SeperateTraceLevelWindows = wConfig.SeperateTraceLevelWindows;
			DebugWindowUpdateOption = wConfig.DebugWindowUpdateOption;
			AutoScrollDebugWindows = wConfig.AutoScrollDebugWindows;
			SuppressSerialNumberDialog = wConfig.SuppressSerialNumberDialog;
			SuppressResultsDialog = wConfig.SuppressResultsDialog;
			ClearSerialNumber = wConfig.ClearSerialNumber;
			CustomAppToolTip = wConfig.CustomAppToolTip;
			CustomLinkAppArgs = wConfig.CustomLinkAppArgs;
			CustomLinkAppName = wConfig.CustomLinkAppName;
			ShowFailedTests = wConfig.ShowFailedTests;
			NodeDetailsChoice = wConfig.NodeDetailsChoice;
			EnableSuiteGV = wConfig.EnableSuiteGV;
			SuiteParamGVs = wConfig.SuiteParamGVs;
		}
		catch (Exception ex)
		{
			TraceMessage.Write(ToString(), "WorkspaceConfig.CopyDataLoggingConfig(), exception: " + ex.Message, TraceMessageType.Exception);
		}
	}
}
