Beispiel #1
0
		override protected void LoadXML(XmlNode cXmlNode)
		{
            if (null == cXmlNode || _bInitialized)
				return;
			_sRestartFile = cXmlNode.AttributeValueGet("restart", false);
			XmlNode[] aNodeChilds = cXmlNode.NodesGet("process", false);
			if (null != aNodeChilds)
			{
				List<Process> aProcesses = new List<Process>();
				for (int nIndx = 0; aNodeChilds.Length > nIndx; nIndx++)
				{
					aProcesses.Add(new Process()
					{
						sName = aNodeChilds[nIndx].AttributeValueGet("name"),
						sOwner = aNodeChilds[nIndx].AttributeValueGet("owner"),
						sArguments = aNodeChilds[nIndx].AttributeValueGet("arguments", false)
					});
				}
				_aProcesses = aProcesses.ToArray();
			}
			XmlNode cXNBlender = cXmlNode.NodeGet("blender", false);
			if (null != cXNBlender)
			{
				_cBlender = new Blender() { sPath = cXNBlender.AttributeValueGet("path"), sTasks = cXNBlender.AttributeValueGet("tasks"), nQueue = (cXNBlender.AttributeValueGet("queue", false) ?? "1").ToByte() };
				if (!System.IO.File.Exists(_cBlender.sPath) || !System.IO.Directory.Exists(_cBlender.sTasks))
					throw new Exception("cannot find blender executable or tasks folder[" + _cBlender.sPath +"][" + _cBlender.sTasks + "]");
			}
		}
Beispiel #2
0
                static public Text Parse(XmlNode cXmlNode)
                {
                    Text cRetVal = new Text();
                    XmlNode cNodeFont = cXmlNode.NodeGet("font");
                    cRetVal.cFont = new System.Drawing.Font(cNodeFont.AttributeValueGet("name"), cNodeFont.AttributeGet<int>("size"), cNodeFont.AttributeGet<System.Drawing.FontStyle>("style"));
					cRetVal.nTopOffset = cNodeFont.AttributeGet<short>("offset", false);
					if (cRetVal.nTopOffset == short.MaxValue)
						cRetVal.nTopOffset = 0;
                    cXmlNode = cNodeFont.NodeGet("color");
                    cRetVal.stColor = System.Drawing.Color.FromArgb(cXmlNode.AttributeGet<byte>("alpha"), cXmlNode.AttributeGet<byte>("red"), cXmlNode.AttributeGet<byte>("green"), cXmlNode.AttributeGet<byte>("blue"));
                    if (null != (cXmlNode = cNodeFont.NodeGet("border", false)))
                    {
                        cRetVal.nBorderWidth = cXmlNode.AttributeValueGet("width").ToFloat();
                        cXmlNode = cXmlNode.NodeGet("color");
                        cRetVal.stColorBorder = System.Drawing.Color.FromArgb(cXmlNode.AttributeGet<byte>("alpha"), cXmlNode.AttributeGet<byte>("red"), cXmlNode.AttributeGet<byte>("green"), cXmlNode.AttributeGet<byte>("blue"));
                    }
                    return cRetVal;
                }
Beispiel #3
0
			override protected void LoadXML(XmlNode cXmlNode)
			{
                if (null == cXmlNode || _bInitialized)
					return;

				XmlNode cNodeChild = cXmlNode.NodeGet("database", false);
				if(null == cNodeChild)
					cNodeChild = cXmlNode.NodeGet("common/database", false);
				if (null == cNodeChild)
					return;
				if (null != cNodeChild.Attributes["server"])
				{
					_cDBCredentials = new DB.Credentials();
					_cDBCredentials.sServer = cNodeChild.AttributeValueGet("server");
					_cDBCredentials.nPort = cNodeChild.AttributeGet<int>("port");
					_cDBCredentials.sDatabase = cNodeChild.AttributeValueGet("name");
					_cDBCredentials.sUser = cNodeChild.AttributeValueGet("user");
					_cDBCredentials.sPassword = cNodeChild.AttributeValueGet("password");
					_cDBCredentials.nTimeout = cNodeChild.AttributeGet<int>("timeout");
				}
				if (null != cNodeChild.Attributes["bytea"])
					_eByteaOutput = cNodeChild.AttributeGet<ByteaOutput>("bytea");
			}
Beispiel #4
0
		override public void LoadXML(XmlNode cXmlNode)
		{
			if (null == cXmlNode)
				return;
            base.LoadXML(cXmlNode);
            if((sFile = cXmlNode.AttributeValueGet("file", false)).IsNullOrEmpty())
			    throw new Exception("указано некорректное значение атрибута file плагина [TPL:" + cXmlNode.BaseURI + "]"); //TODO LANG
            if((sClass = cXmlNode.AttributeValueGet("class", false)).IsNullOrEmpty())
                throw new Exception("указано некорректное значение атрибута class плагина [TPL:" + cXmlNode.BaseURI + "]"); //TODO LANG
            if (null != (cXmlNode = cXmlNode.NodeGet("data", false)))
                sData = cXmlNode.OuterXml;
        }
Beispiel #5
0
            override protected void LoadXML(XmlNode cXmlNode)
            {
                if (null == cXmlNode)
                    return;
                try
                {
                    _eLevel = cXmlNode.AttributeGet<Level>("level");
                }
                catch
                {
                    _eLevel = Level.notice;
                }
                XmlNode cXmlNodeChild = cXmlNode.NodeGet("file", false);
                if (null != cXmlNodeChild)
                {
                    _cFile = new File();
                    _cFile.sPath = cXmlNodeChild.AttributeValueGet("path", false);
                    if (null != _cFile.sPath && !SIO.Path.IsPathRooted(_cFile.sPath))
                        _cFile.sPath = SIO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, _cFile.sPath);
                    _cFile.sFilename = cXmlNodeChild.AttributeValueGet("name", false);
                    _cFile.bDate = cXmlNodeChild.AttributeGet<bool>("date", false);
                    _cFile.bPID = cXmlNodeChild.AttributeGet<bool>("pid", false);
                }

                cXmlNodeChild = cXmlNode.NodeGet("mail", false);
                _ahMailTargets = null;
                List<Regex> aExcludes = new List<Regex>();
                if (null != cXmlNodeChild)
                {
                    if (null == (_sMailSubjectPrefix = cXmlNodeChild.AttributeValueGet("subject", false)))
                        throw new Exception("не указан префикс темы сообщения электронной почты [" + cXmlNodeChild.Name + "][subject]"); //TODO LANG
                    _sMailSubjectPrefix = "[" + _sMailSubjectPrefix + "]";
                    if (null == (_sMailSource = cXmlNodeChild.AttributeValueGet("source", false)))
                        throw new Exception("не указан адрес отправителя сообщения электронной почты [" + cXmlNodeChild.Name + "][source]"); //TODO LANG
                    if (null == (_sMailServer = cXmlNodeChild.AttributeValueGet("server", false)))
                        throw new Exception("не указан сервер электронной почты [" + cXmlNodeChild.Name + "][server]"); //TODO LANG
                    if (null == (_sMailPassword = cXmlNodeChild.AttributeValueGet("password", false)))
                        throw new Exception("не указан пароль сервера электронной почты [" + cXmlNodeChild.Name + "][password]"); //TODO LANG

                    XmlNode[] aXmlNodes = cXmlNodeChild.NodesGet("targets/target", false);
                    if (null == aXmlNodes)
                        throw new Exception("не указаны адресаты электронной почты [" + cXmlNodeChild.Name + "][targets]"); //TODO LANG
                    _ahMailTargets = new Dictionary<Level, string>();
                    Level eLevel;
                    foreach (XmlNode cNode in aXmlNodes)
                    {
                        if (null != cNode.Attributes["level"])
                        {
                            try
                            {
                                eLevel = cNode.AttributeGet<Level>("level");
                            }
                            catch
                            {
                                throw new Exception("указан некорректный уровень для списка адресатов [" + cNode.Name + "]"); //TODO LANG
                            }
                            if (_ahMailTargets.ContainsKey(eLevel))
                                throw new Exception("указано несколько списков адресатов [" + eLevel + "][" + cNode.Name + "]"); //TODO LANG
                            _ahMailTargets.Add(eLevel, cNode.InnerText);
                        }
                    }

                    if (null != (aXmlNodes = cXmlNodeChild.NodesGet("excludes/pattern", false)))
                    {
                        foreach (XmlNode cNode in aXmlNodes)
                        {
                            if (!cNode.InnerXml.IsNullOrEmpty())
                                aExcludes.Add(new Regex(cNode.InnerXml, RegexOptions.IgnoreCase | RegexOptions.Singleline));
                        }
                    }

                }
                _aExcludes = aExcludes.ToArray();
            }
Beispiel #6
0
                    static public Data Yandex(XmlNode cXmlNode)
                    {
                        Data cRetVal = null;
                        if (null != cXmlNode)
                        {
                            cRetVal = new Data();
                            string sCode = cXmlNode.NodeGet("weather_condition").AttributeValueGet("code").ToLower();
							#region condition
							switch (sCode)
							{
                                case "cloudy-thunderstorms-with-wet-snow":
									cRetVal.eType = Type.Clouds | Type.RainHeavy; //weather_icn_bkn_+ra_d_pal_c
									break;
                                case "cloudy":
                                case "thin-high-clouds":
									cRetVal.eType = Type.Clouds; //weather_icn_bkn_d_pal_c
									break;
								case "cloudy-and-showers":
                                case "cloudy-and-wet-snow-showers":
                                case "cloudy-and-rain":
                                case "cloudy-thunderstorms-with-rain":
                                case "cloudy-and-light-rain":
                                case "cloudy-and-light-wet-snow":
                                case "cloudy-thunderstorms-with-snow":
									cRetVal.eType = Type.Clouds | Type.Rain; //weather_icn_bkn_-ra_d_pal_c
									break;
								case "cloudy-and-snow":
									cRetVal.eType = Type.Clouds | Type.SnowMore; //weather_icn_bkn_sn_d_pal_c
									break;
								case "cloudy-and-snow-showers":
                                case "cloudy-and-wet-snow":
                                case "cloudy-and-light-snow":
									cRetVal.eType = Type.Clouds | Type.Snow; //weather_icn_bkn_-sn_d_pal_c
									break;
								case "intermittent-heavy-drizzle":
                                case "intermittent-heavy-rain":
                                case "rain-showers":
                                case "violent-rain-showers":
                                case "continuous-heavy-rain":
                                case "moderate-to-heavy-rain-showers":
                                case "light-rain-showers":
                                case "funnel-clouds-within-sight":
                                case "squalls-within-sight-but-no-precipitation-falling-at-station":
									cRetVal.eType = Type.CloudsHeavy | Type.RainHeavy; //weather_icn_ovc_+ra_pal_c
									break;
								case "heavy-drifting-snow-above-eye-level":
									cRetVal.eType = Type.CloudsHeavy | Type.SnowHeavy; //weather_icn_ovc_+sn_pal_c
									break;
								case "freezing-rain":
                                case "hail-showers":
                                case "heavy-thunderstorm-with-hail":
                                case "moderate-to-heavy-freezing-drizzle":
                                case "moderate-to-heavy-hail-showers":
                                case "moderate-to-heavy-freezing-rain":
                                case "light-snow-ice-pellet-showers":
                                case "light-hail-showers":
                                case "light-freezing-rain":
                                case "light-snow-showers":
                                case "snow-grains":
									cRetVal.eType = Type.CloudsHeavy | Type.Hail; //weather_icn_ovc_gr_pal_c
									break;
								case "visibility-reduced-by-smoke":
                                case "mist":
                                case "clouds-dissolving":
                                case "mostly-clear":
                                case "state-of-sky-unchanged":
                                case "mostly-clear-slight-possibility-of-rain":
                                case "mostly-clear-slight-possibility-of-snow":
                                case "mostly-clear-slight-possibility-of-wet-snow":
                                case "overcast":
                                case "clouds-developing":
                                case "partly-cloudy":
                                case "widespread-dust-in-suspension-not-raised-by-wind":
                                case "dust-or-sand-raised-by-wind":
                                case "dust-or-sand-storm-within-sight-but-not-at-station":
                                case "slight-to-moderate-duststorm-decreasing-in-intensity":
                                case "slight-to-moderate-duststorm-increasing-in-intensity":
                                case "slight-to-moderate-duststorm-no-change":
                                case "well-developed-dust-or-sand-whirls":
                                case "severe-duststorm-decreasing-in-intensity":
                                case "severe-duststorm-increasing-in-intensity":
                                case "severe-duststorm-no-change":
									cRetVal.eType = Type.CloudsHeavy; //weather_icn_ovc_pal_c
									break;
								case "patches-of-fog":
                                case "continuous-shallow-fog":
                                case "fog":
                                case "fog-at-a-distance":
								case "fog-sky-visible-becoming-thicker":
								case "fog-sky-visible-no-change":
								case "fog-sky-visible-thinning":
								case "patches-of-shallow-fog":
								case "fog-depositing-rime-sky-visible":
									cRetVal.eType = Type.Fog; //weather_icn_ovc_fg_pal_c
									break;
								case "fog-sky-not-visible-becoming-thicker":
								case "fog-sky-not-visible-no-change":
								case "fog-sky-not-visible-thinning":
								case "fog-depositing-rime-sky-not-visible":
									cRetVal.eType = Type.FogMore; //weather_icn_ovc_+fg_pal_c
									break;
								case "intermittent-moderate-rain":
                                case "intermittent-moderate-drizzle":
                                case "intermittent-light-drizzle":
                                case "intermittent-light-rain":
                                case "continuous-moderate-rain":
                                case "rain":
                                case "continuous-moderate-drizzle":
                                case "overcast-and-showers":
                                case "overcast-and-rain":
                                case "overcast-and-light-rain":
                                case "distant-precipitation-but-not-falling-at-station":
                                case "nearby-precipitation-but-not-falling-at-station":
                                case "precipitation-within-sight-but-not-hitting-ground":
                                case "partly-cloudy-and-showers":
                                case "partly-cloudy-and-rain":
                                case "partly-cloudy-and-light-rain":
                                case "continuous-light-drizzle":
                                case "light-drizzle-and-rain":
                                case "continuous-light-rain":
									cRetVal.eType = Type.CloudsHeavy | Type.Rain; //weather_icn_ovc_-ra_pal_c
									break;
								case "intermittent-heavy-snow":
                                case "overcast-and-snow-showers":
                                case "heavy-drifting-snow-below-eye-level":
                                case "continuous-heavy-snow":
									cRetVal.eType = Type.CloudsHeavy | Type.SnowMore; //weather_icn_ovc_sn_pal_c
									break;
								case "intermittent-light-snow":
									cRetVal.eType = Type.CloudsHeavy | Type.Snow; //weather_icn_ovc_-sn_pal_c
									break;
								case "intermittent-moderate-snow":
                                case "slight-to-moderate-drifting-snow-above-eye-level":
                                case "overcast-and-light-snow":
                                case "overcast-and-snow":
                                case "snow-crystals":
                                case "partly-cloudy-and-snow-showers":
                                case "partly-cloudy-and-light-snow":
                                case "partly-cloudy-and-snow":
                                case "slight-to-moderate-drifting-snow-below-eye-level":
                                case "cold-snap":
                                case "abrupt-cold-snap":
                                case "continuous-heavy-drizzle":
                                case "light-freezing-drizzle":
                                case "continuous-light-snow":
                                case "continuous-moderate-snow":
                                case "snow":
									cRetVal.eType = Type.CloudsHeavy | Type.Snow; //weather_icn_ovc_-sn_pal_c
									break;
								case "light-to-moderate-thunderstorm":
                                case "thunderstorm-but-no-precipitation-falling-at-station":
                                case "thunderstorms":
                                case "light-to-moderate-thunderstorm-with-hail":
                                case "heavy-thunderstorm-with-duststorm":
                                case "overcast-thunderstorms-with-rain":
                                case "heavy-thunderstorm":
                                case "thunderstorm-in-past-hour-currently-only-moderate-to-heavy-snow-or-rain-snow-mix":
                                case "thunderstorm-in-past-hour-currently-only-moderate-to-heavy-rain":
                                case "thunderstorm-in-past-hour-currently-only-light-rain":
									cRetVal.eType = Type.CloudsHeavy | Type.Thunderstorm | Type.Rain; //weather_icn_ovc_ts_ra_pal_c
									break;
								case "lightning-visible-no-thunder-heard":
									cRetVal.eType = Type.Lighting; //weather_icn_lt_pal_c
									break;
								case "rain-and-snow":
                                case "ice-pellets":
                                case "diamond-dust":
                                case "moderate-to-heavy-snow-ice-pellet-showers":
                                case "snow-showers":
                                case "mostly-clear-possible-thunderstorms-with-wet-snow":
                                case "mostly-clear-possible-thunderstorms-with-rain":
                                case "mostly-clear-possible-thunderstorms-with-snow":
                                case "drizzle":
                                case "overcast-and-wet-snow-showers":
                                case "overcast-and-wet-snow":
                                case "overcast-thunderstorms-with-wet-snow":
                                case "overcast-and-light-wet-snow":
                                case "overcast-thunderstorms-with-snow":
                                case "partly-cloudy-possible-thunderstorms-with-wet-snow":
                                case "partly-cloudy-possible-thunderstorms-with-rain":
                                case "partly-cloudy-possible-thunderstorms-with-snow":
                                case "partly-cloudy-and-wet-snow-showers":
                                case "partly-cloudy-and-wet-snow":
                                case "partly-cloudy-and-light-wet-snow":
                                case "moderate-to-heavy-drizzle-and-rain":
                                case "moderate-to-heavy-rain-and-snow":
                                case "moderate-to-heavy-rain-and-snow-showers":
                                case "moderate-to-heavy-snow-showers":
                                case "light-rain-and-snow":
                                case "thunderstorm-in-past-hour-currently-only-light-snow-or-rain-snow-mix":
                                case "light-rain-and-snow-showers":
									cRetVal.eType = Type.CloudsHeavy | Type.Thunderstorm | Type.Rain | Type.Snow; //weather_icn_ovc_ts_ra_sn_pal_c
									break;
								case "haze":
									cRetVal.eType = Type.Haze; //weather_icn_mst_pal_c
									break;
								default:
								case "abrupt-warming":
								case "clear":
								case "clear-skies":
									cRetVal.eType = Type.Clear; //weather_icn_skc_d_pal_c
									break;
							}
							#endregion condition
							cRetVal.sDetails = cXmlNode.NodeGet("weather_type").InnerText;
                            XmlNode cXN = cXmlNode.NodeGet("temperature-data", false);
                            if (null != cXN)
                            {
                                cXN = cXN.NodeGet("avg");
                                cRetVal.nColor = ("0x" + cXN.AttributeValueGet("bgcolor")).ToUInt32();
                            }
                            else
                            {
                                cXN = cXmlNode.NodeGet("temperature");
                                cRetVal.nColor = ("0x" + cXN.AttributeValueGet("color")).ToUInt32();
                            }
                            cRetVal.nTemperature = cXN.InnerText.ToShort();
                        }
                        return cRetVal;
                    }
Beispiel #7
0
			override protected void LoadXML(XmlNode cXmlNode)
			{
                if (null == cXmlNode || _bInitialized)
					return;
                _nCUDAVersion = cXmlNode.NodeGet("cuda").AttributeGet<byte>("version");
			}
Beispiel #8
0
		override protected void LoadXML(XmlNode cXmlNode)
		{
			(new Logger()).WriteWarning("________________load XML   begin");

			if (null == cXmlNode)
				return;
			XmlNode cXmlNodeChild;
			XmlNode[] aXmlNodeChilds;
            XmlNode cXmlNodeClient = cXmlNode.NodeGet("clients/scr", false);
			if (null != cXmlNodeClient)
			{
				#region presets
				aXmlNodeChilds = cXmlNodeClient.NodesGet("presets/preset");
				_cClientSCR = new Clients.SCR();
				List<Clients.SCR.Preset> aPresets = new List<Clients.SCR.Preset>();
				Clients.SCR.Preset cPreset;
				foreach (XmlNode cXmlNodePreset in aXmlNodeChilds)
				{
					cPreset = new Clients.SCR.Preset();
                    cPreset.sName = cXmlNodePreset.AttributeValueGet("name");
                    cPreset.nID = cXmlNodePreset.AttributeIDGet("id");
                    cPreset.sFolder = cXmlNodePreset.AttributeValueGet("folder");
                    cPreset.sChannel = cXmlNodePreset.AttributeValueGet("channel");
                    cPreset.sCaption = cXmlNodePreset.AttributeValueGet("caption");
					if (0 < aPresets.Count(o => (cPreset.nID == o.nID || cPreset.sName == o.sName) && cPreset.sChannel == o.sChannel))
						throw new Exception("пресет указан повторно [channel:" + cPreset.sChannel + "][id:" + cPreset.nID + "][name:" + cPreset.sName + "][" + cXmlNodePreset.Name + "][" + cXmlNodeClient.Name + "]"); //TODO LANG
					aPresets.Add(cPreset);
				}
				_cClientSCR.aPresets = aPresets.ToArray();
				#endregion
				#region plaques
				aXmlNodeChilds = cXmlNodeClient.NodesGet("plaques/plaque");
				List<Clients.SCR.Plaque> aPlaques = new List<Clients.SCR.Plaque>();
				Clients.SCR.Plaque cPlaque;
				foreach (XmlNode cXmlNodePreset in aXmlNodeChilds)
				{
					cPlaque = new Clients.SCR.Plaque();
					cPlaque.nPresetID = cXmlNodePreset.AttributeGet<int>("id_preset", false);
					cPlaque.bOpened = cXmlNodePreset.AttributeGet<bool>("opened", false);
					cPlaque.nHeight = cXmlNodePreset.AttributeGet<ushort>("height", false);
					aPlaques.Add(cPlaque);
				}
				_cClientSCR.aPlaques = aPlaques.ToArray();
				#endregion
				#region templates
				XmlNode cXmlNodeTemplates = cXmlNodeClient.NodeGet("templates");
                if (null != (cXmlNodeChild = cXmlNodeTemplates.NodeGet("masks", false)))
				{
                    _cClientSCR.sTemplateChannelMask = cXmlNodeChild.AttributeValueGet("channel", false) ?? "";
                    _cClientSCR.sTemplatePresetMask = cXmlNodeChild.AttributeValueGet("preset", false) ?? "";
				}
                aXmlNodeChilds = cXmlNodeTemplates.NodesGet("template");
				List<Clients.SCR.Template> aTemplates = new List<Clients.SCR.Template>();
				Clients.SCR.Template cTemplate = null;

				foreach (XmlNode cXmlNodeTemplate in aXmlNodeChilds)
				{
					cTemplate = new Clients.SCR.Template();
                    cTemplate.eBind = cXmlNodeTemplate.AttributeGet<Clients.SCR.Template.Bind>("bind");
					if (0 < aTemplates.Count(o => o.eBind == cTemplate.eBind))
						throw new Exception("шаблон с указанной привязкой уже был добавлен [" + cTemplate.eBind + "][" + cXmlNodeTemplate.Name + "][" + cXmlNodeClient.Name + "]"); //TODO LANG
                    cTemplate.sFile = cXmlNodeTemplate.AttributeValueGet("file");
                    if (null != (cXmlNodeChild = cXmlNodeTemplate.NodeGet("scale_video", false)))
					{
						short x, y;
						ushort w, h;
						string sAspect;
                        x = cXmlNodeChild.AttributeGet<short>("x", false);
                        y = cXmlNodeChild.AttributeGet<short>("y", false);
                        w = cXmlNodeChild.AttributeGet<ushort>("width", false);
                        h = cXmlNodeChild.AttributeGet<ushort>("height", false);
                        sAspect = cXmlNodeChild.AttributeValueGet("pixel_aspect_ratio", false);
						if (0 == w || 0 == h)
							cTemplate.stScaleVideo = Area.stEmpty;
						else
							cTemplate.stScaleVideo = new Area(x, y, w, h);
						if (null != sAspect)
						cTemplate.nPixelAspectRatio = float.Parse(sAspect.Replace('.', ','));
					}
                    if (null != (cXmlNodeChild = cXmlNodeTemplate.NodeGet("offsets", false)))
                        cTemplate.aOffsets = GetOffsets(cXmlNodeChild.NodesGet("offset"));
                    if (null != (cXmlNodeChild = cXmlNodeTemplate.NodeGet("conflicts", false)))
                        cTemplate.aConflicts = GetConflicts(cXmlNodeChild.NodesGet("conflict"));
                    if (null != (cXmlNodeChild = cXmlNodeTemplate.NodeGet("preset_parameters", false)))
                        cTemplate.aParameters = GetParameters(cXmlNodeChild.NodesGet("parameters"));
					if (null != (cXmlNodeChild = cXmlNodeTemplate.NodeGet("player_parameters", false)))
						cTemplate.aParameters = GetPlayerParameters(cXmlNodeChild.NodesGet("parameters"));
					aTemplates.Add(cTemplate);
				}
				_cClientSCR.aTemplates = aTemplates.ToArray();
				#endregion
                XmlNode cXmlNodeAutomation = cXmlNodeClient.NodeGet("automation", false);
                sClipStartStopAutomationFile = cXmlNodeAutomation.AttributeValueGet("file", false);
                nFrameDuration_ms = cXmlNodeAutomation.AttributeGet<int>("frame_ms", false);
                nStopOffset = cXmlNodeAutomation.AttributeGet<int>("stop_offset", false);
                XmlNode cXmlNodeOthers = cXmlNodeClient.NodeGet("others", false);
                nQueuesCompensation = cXmlNodeOthers.AttributeGet<int>("queues_compensation", false);
                sPlayerLogFolder = cXmlNodeOthers.AttributeValueGet("player_log", false);
			}
		}