public Figure()
 {
     PrepareBasePriorityTable();
     Lines = new List<LineSegment>();
     ForlornStartNodes = new List<Vector2>();
     SwitchPoints = new SerializableDictionary<Vector2, SwitchPoint>();
 }

        //private readonly SerializableDictionary<char, int> _ukrainianLetterCount;

        //private int _textLength;

        public FrequencyAnalysis()
        {
            LatinTable = new SerializableDictionary<char, double>();
            //_latinLetterCount = new SerializableDictionary<char, int>();
            UkrainianTable = new SerializableDictionary<char, double>();
            //_ukrainianLetterCount = new SerializableDictionary<char, int>();
        }

        private string GetDefaultAspectFromVersion9(SerializableDictionary<string, string> serializableDictionary, List<string> aspects, string defaultAspect) {
            if (serializableDictionary.ContainsKey("Schema")) {
                return GetAspectFromXml(aspects, defaultAspect);
            }

            return defaultAspect;
        }

        public bool IsExist(int id)
        {
            if (Items == null)
                Items = new SerializableDictionary<int, int>();

            return Items.ContainsKey(id);
        }

        public void JobFailPackageThrowsException()
        {
            ExecutablePackage ep = new ExecutablePackage("mock.xml", null, "TestJobManager.dll", "TestJobManager.MockJobRunner", new SerializableDictionary<string, string>(), new SerializableDictionary<string, string>());
            List<ExecutablePackage> eps = new List<ExecutablePackage>();
            eps.Add(ep);

            SerializableDictionary<string, string> properties = new SerializableDictionary<string, string>();
            properties["Mock_ReportSuccess"] = "true";
            properties["Mock_StringToLog"] = "Mock Logged String";
            properties["Mock_ThrowException"] = "Expected Exception";

            List<FileInfo> filesToCopy = new List<FileInfo>();
            filesToCopy.Add(new FileInfo(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestJobManager.dll")));
            JobStatus js = RunJob(filesToCopy, eps, properties, null);

            mock.VerifyEventOccured(MockEventType.UpdateStatus, "Loading external test DLL: TestJobManager.dll , TestJobManager.MockJobRunner", false);
            mock.VerifyEventOccured(MockEventType.UpdateStatus, "Executing Execute() method on external DLL", false);
            mock.VerifyEventOccured(MockEventType.UpdateStatus, properties["Mock_ThrowException"], true);
            mock.VerifyEventOccured(MockEventType.UpdateStatus, properties["Mock_StringToLog"], false);

            Assert.That(js.Result.Completed, Is.False);
            Assert.That(js.Result.Success, Is.False);
            Assert.That(js.Result.ExecutionResults.Count, Is.EqualTo(1));
            Assert.That(js.Result.Errors, Is.Not.Empty);

            VerifyStringInList(js.Result.Errors, "System.Exception: " + properties["Mock_ThrowException"]);

            VerifyLogContainsString(js.Result.Logs, properties["Mock_StringToLog"]);
            VerifyLogContainsString(js.Result.Logs, properties["Mock_ThrowException"]);
        }

 public static void Serialize(SerializableDictionary<int, CarInfo> carInfo, string fileName)
 {
     var textWriter = new StreamWriter(fileName);
     var serializer = new XmlSerializer(typeof(SerializableDictionary<int, CarInfo>));
     serializer.Serialize(textWriter, carInfo);
     textWriter.Close();
 }

        private void crystalButton_FanCountSetting_Click(object sender, EventArgs e)
        {
            SettingCommInfo commInfo = new SettingCommInfo();
            commInfo.SameCount = (byte)numericUpDown_MCSameFanCount.Value;
            commInfo.TypeStr = CommonUI.GetCustomMessage(HsLangTable,"HwFanName","风扇");
            commInfo.IconImage = Nova.Monitoring.UI.MonitorFromDisplay.Properties.Resources.Fan;
            commInfo.MaxCount = (byte)(MaxFanCount);
            if (_vm.FanInfo.AllFanCountDif == null || _vm.FanInfo.AllFanCountDif.Count == 0)
            {
                SerializableDictionary<string, byte> moinfos = new SerializableDictionary<string, byte>();
                SetCount(MonitorAllConfig.Instance().AllCommPortLedDisplayDic[_vm.SN],
                    _vm.SN.Replace("-",""), commInfo.SameCount, out moinfos);
                _vm.FanInfo.AllFanCountDif = moinfos;
            }

            Frm_FanPowerAdvanceSetting setFanCntFrm = new Frm_FanPowerAdvanceSetting(
                MonitorAllConfig.Instance().AllCommPortLedDisplayDic[_vm.SN],
                string.IsNullOrEmpty(MonitorAllConfig.Instance().CurrentScreenName) ? _sn10 : MonitorAllConfig.Instance().CurrentScreenName,
                _vm.SN.Replace("-", ""), _vm.FanInfo.AllFanCountDif, commInfo);
            setFanCntFrm.StartPosition = FormStartPosition.CenterParent;
            //setFanCntFrm.UpdateFont(Frm_MonitorStatusDisplay.CurrentFont);
            setFanCntFrm.UpdateLanguage(CommonUI.LanguageName);
            if (setFanCntFrm.ShowDialog() == DialogResult.OK)
            {
                _vm.FanInfo.AllFanCountDif = setFanCntFrm.CurAllSettingDic;
            }
        }

    public SerializableDictionary<string, int> calc_discovery_chance (bool _accurate, float _extra_factor)
    {
    	// Get the default settings for this base type.
    	SerializableDictionary<string, int> detect_chance_copy = new SerializableDictionary<string, int> (this.detect_chance);
  
        // Adjust by the current suspicion levels ...
        foreach(string group in this.detect_chance.Keys)
		{
			int suspicion = G.pl.groups[group].suspicion;
			detect_chance_copy[group] *= 10000 + suspicion;
			detect_chance_copy[group] /= 10000;
		}

		// ... and further adjust based on technology ...
        foreach (string	group in this.detect_chance.Keys)
		{
			int discover_bonus = G.pl.groups[group].discover_bonus;
            detect_chance_copy[group] *= discover_bonus;
            detect_chance_copy[group] /= 10000;
		}

        // ... and the given factor.
        foreach(string group in this.detect_chance.Keys)
            detect_chance_copy[group] = (int)(detect_chance_copy[group] * _extra_factor);

        // Lastly, if we're told to be inaccurate, adjust the values to their
        // nearest percent.
        if (!_accurate)
            foreach(string group in this.detect_chance.Keys	)
                detect_chance_copy[group] = G.nearest_percent(detect_chance_copy[group]);

        return detect_chance_copy;
	}

 public AccountInfo()
 {
     ConnectPort = 5222;
     AutoConnect = true;
     ProxyType = ProxyType.System;
     Properties = new SerializableDictionary<string, string>();
 }

        public void loadClick(DateTime time)
        {
            // 储存到文件，比如20130203.xml
            string fileName = this.logFile;
            string today = time.ToString("yyyyMMdd");
            SerializableDictionary fileDatas = new SerializableDictionary();

            using (FileStream stream = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.Read))
            {
                stream.Lock(0, stream.Length);
                XmlSerializer serializer = new XmlSerializer(typeof(SerializableDictionary));
                if (stream.Length != 0)
                {
                    fileDatas = (SerializableDictionary)serializer.Deserialize(stream);
                    if (!fileDatas.ContainsKey(today))
                    {
                        fileDatas[today] = new MouseState();
                    }
                }
                else
                {
                    fileDatas = new SerializableDictionary();
                    fileDatas[today] = new MouseState();
                }
                this.leftClickCount = fileDatas[today].leftClickCount;
                this.rightClickCount = fileDatas[today].rightClickCount;
                this.middleClickCount = fileDatas[today].middleClickCount;
            }
        }

        public static SerializableDictionary<string, SerializableDictionary<string, double>> GenerateWeights(List<string> states, SIMDIST weightFlag)
        {
            SerializableDictionary<string, SerializableDictionary<string, double>> weights = new SerializableDictionary<string, SerializableDictionary<string, double>>();
            if (weightFlag == SIMDIST.SIMILARITY)
            {
                foreach (var item in states)
                {
                    weights.Add(item, new SerializableDictionary<string, double>());
                    weights[item].Add(item, 1.0);
                }
            }
            else
                foreach (var item in states)
                {
                    weights.Add(item, new SerializableDictionary<string, double>());
                    foreach (var item1 in states)
                    {
                        if (item != item1)                                                    
                            weights[item].Add(item1, 1.0);                        
                    }
                }


            return weights;
        }

 string GetDefaultAspectFromVersion9(SerializableDictionary<string, string> serializableDictionary, List<string> aspects, string defaultAspect) {
     if (serializableDictionary.ContainsKey("Schema")){
         var helper = new DictionaryHelper();
         defaultAspect = helper.GetAspectFromXml(aspects, defaultAspect);
     }
     return defaultAspect;
 }

        public override object ConvertFromStorageType(object value)
        {
            var masterModel = ModelDifferenceModule.MasterModel;
            var layer = masterModel.CreatorInstance.CreateModelApplication();
            
            if (!(string.IsNullOrEmpty(value as string)))
            {
                masterModel.AddLayerBeforeLast(layer);
                var serializableDictionary = new SerializableDictionary<string, string>();
                var xmlReader = XmlReader.Create(new StringReader((string)value), new XmlReaderSettings { ConformanceLevel = ConformanceLevel.Auto });
                serializableDictionary.ReadXml(xmlReader);
                var aspects = serializableDictionary["aspects"].Split(',').ToList();
                var defaultAspect = serializableDictionary["DefaultAspect"];
                defaultAspect = GetDefaultAspectFromVersion9(serializableDictionary, aspects, defaultAspect);

                if (!string.IsNullOrEmpty(defaultAspect))
                    new ModelXmlReader().ReadFromString(layer, String.Empty, defaultAspect);

                foreach (var aspect in aspects.Where(aspect => !string.IsNullOrEmpty(aspect) && !string.IsNullOrEmpty(serializableDictionary[aspect]))){
                    new ModelXmlReader().ReadFromString(layer, aspect, serializableDictionary[aspect]);
                }

            }

            return layer;
        }

        public override object ConvertToStorageType(object value)
        {
            var model = value as ModelApplicationBase;
            if (model != null)
            {
                var writer = new ModelXmlWriter();
                var serializableDictionary = new SerializableDictionary<string, string>();
                serializableDictionary["aspects"] = string.Empty;
                for (int i = 0; i < model.AspectCount; ++i)
                {
                    var aspect = model.GetAspect(i);
                    if (string.IsNullOrEmpty(aspect) || aspect == CaptionHelper.DefaultLanguage){
                        serializableDictionary["DefaultAspect"] = writer.WriteToString(model, i);
                    }
                    else{
                        serializableDictionary["aspects"] += aspect + ",";
                        serializableDictionary[aspect] = writer.WriteToString(model, i);
                    }
                }

                serializableDictionary["aspects"] = serializableDictionary["aspects"].TrimEnd(',');

                var stringWriter = new StringWriter();
                serializableDictionary.WriteXml(new XmlTextWriter(stringWriter));
                return stringWriter.GetStringBuilder().ToString();
            }

            return null;
        }

        public PortableConfig(string filename = "filehatchery.ini")
        {
            filepath = Util.getExecutablePath() + "\\" + filename;
            XmlSerializer ser = new XmlSerializer(typeof(SerializableDictionary<string, string>));
            if (File.Exists(filepath))
            {
                try
                {
                    stream = File.Open(filepath, FileMode.Open);
                    Dict = ser.Deserialize(stream) as SerializableDictionary<string, string>;
                }
                catch
                {
                }
            }
            else
            {
                stream = File.Open(filepath, FileMode.CreateNew);
            }
            if (Dict == null)
                Dict = new SerializableDictionary<string, string>();

            ser = null;
            stream.Flush();
            stream.Close();
            stream.Dispose();
            stream = null;
        }

 public UserSettings(string dir)
 {
     filePath = Path.Combine(dir, FileName);
     Load(dir);
     if (_settings == null)
         _settings = new SerializableDictionary<string, string>();
 }

        /// <summary>
        /// Loads the settings from XML
        /// </summary>
        public static void Load()
        {
            _rand = new Random();

            // TODO: Real path
            if (File.Exists(Environment.CurrentDirectory + "\\list.xml"))
            {
                XmlSerializer s = new XmlSerializer(typeof(SerializableDictionary<string, List<string>>));
                TextReader r = new StreamReader(Environment.CurrentDirectory + "\\list.xml");

                try
                {
                    _messagesStore = (SerializableDictionary<string, List<string>>)s.Deserialize(r);
                    r.Close();
                }
                catch (Exception ex)
                {
                    // TODO: Let's tell the user about it or something
                    throw;
                }
            }
            else
            {
                _messagesStore = new SerializableDictionary<string, List<string>>();
            }
        }

 public XmlCache()
 {
     try
     {
         // ensure directory exists in userdata
         DirectoryInfo folder = new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\" + FOLDER_NAME);
         if (!folder.Exists)
         {
             folder.Create();
         }
         FileInfo cacheFile = new FileInfo(XmlFullFilePath);
         if (cacheFile.Exists)
         {
             try
             {
                 XmlSerializer ser = new XmlSerializer(typeof(SerializableDictionary<long, string>));
                 using (FileStream fs = File.Open(
                     XmlFullFilePath,
                     FileMode.Open,
                     FileAccess.Read,
                     FileShare.Read))
                 {
                     _tvdbShowTitles = (SerializableDictionary<long, string>) ser.Deserialize(fs);
                 }
             }
             catch (Exception ex)
             {
                 throw new Exception("Could Not Serialize object to " + XmlFullFilePath, ex);
             }
         }
     }
     catch
     {
     }
 }

 public Frm_FanPowerAdvanceSetting(List<ILEDDisplayInfo> oneLedInfos,string sn,string commPort,
                                   SerializableDictionary<string, byte> curAllSettingDic, 
                                   SettingCommInfo commInfo)
 {
     InitializeComponent();
     _oneLedInfos = oneLedInfos;
     _sn = sn;
     _commPort = commPort;
     _curConfigDic = new SerializableDictionary<string, byte>();
     if (curAllSettingDic != null)
     {
         foreach(string addr in curAllSettingDic.Keys)
         {
             _curConfigDic.Add(addr, curAllSettingDic[addr]);
         }
     }
     try
     {
         _commonInfo = (SettingCommInfo)commInfo.Clone();
     }
     catch
     {
         _commonInfo = new SettingCommInfo();
     }
 }

        public frmUserCatalog()
        {
            InitializeComponent();
            m_DirectionSort.Add("Name", false);
            m_DirectionSort.Add("Catalog", false);
            m_DirectionSort.Add("RA", false);
            m_DirectionSort.Add("DEC", false);
            m_DirectionSort.Add("Visible", false);
            m_GeminiDirectionSort.Add("Name", false);
            m_GeminiDirectionSort.Add("Catalog", false);
            m_GeminiDirectionSort.Add("RA", false);
            m_GeminiDirectionSort.Add("DEC", false);
            m_GeminiDirectionSort.Add("Visible", false);

            m_GeminiObjects = new SerializableDictionary<string, CatalogObject>();
            CList.Add("Name", o => o.Name);
            CList.Add("Catalog", o => o.Catalog);
            CList.Add("RA", o => o.RA);
            CList.Add("DEC", o => o.DEC);
            CList.Add("Visible", o => o.Visible);

            m_GeminiCatalogs.Add("messier", "1");
            m_GeminiCatalogs.Add("ngc", "2");
            m_GeminiCatalogs.Add("ic", "3");
            m_GeminiCatalogs.Add("sharpless hii regions", "4");
            m_GeminiCatalogs.Add("sao catalog", "7");
            m_GeminiCatalogs.Add("lynds dark nebulae", ":");  
            m_GeminiCatalogs.Add("lynds bright nebulae", ";");


            gvAllObjects.RowHeadersVisible = false;
            gvGeminiCatalog.RowHeadersVisible = false;
            dtDateTime.Checked = false;
            numHorizon.Value = (decimal)GeminiHardware.Instance.HorizonAltitude;
        }