Пример #1
0
        private void edSurname_KeyDown(object sender, KeyEventArgs e)
        {
            TextBox tb = (sender as TextBox);

            if (tb != null && e.KeyCode == Keys.Down && e.Control)
            {
                tb.Text = SysUtils.NormalizeName(tb.Text);
            }
        }
Пример #2
0
        public LangRecord(int code, string sign, string name, string fileName)
        {
            Code     = code;
            Sign     = sign;
            Name     = name;
            FileName = fileName;

            string engLangName = SysUtils.NormalizeName(Path.GetFileNameWithoutExtension(fileName));

            LangID = GEDCOMLanguageEnum.Instance.GetEnumValue(engLangName);
        }
Пример #3
0
        private void edNameX_KeyDown(object sender, KeyEventArgs e)
        {
            TextBox tb = (sender as TextBox);

            if (tb != null && e.Key == Keys.Down && e.Control)
            {
                tb.Text = SysUtils.NormalizeName(tb.Text);
            }
            else if (e.KeyChar == '/')
            {
                e.Handled = true;
            }
        }
Пример #4
0
        private void ParseSimple()
        {
            string tmp = EditName.Text.ToLower();

            string[] tokens = tmp.Split(' ');
            if (tokens.Length < 3)
            {
                ShowError(fLangMan.LS(FLS.LSID_NameInvalid));
                return;
            }

            string fam = SysUtils.NormalizeName(tokens[0]);
            string nam = SysUtils.NormalizeName(tokens[1]);
            string pat = SysUtils.NormalizeName(tokens[2]);

            GEDCOMIndividualRecord iRec = fBase.Context.CreatePersonEx(nam, pat, fam, fSimpleTempSex, false);

            if (CheckBirth.Checked)
            {
                fBase.Context.CreateEventEx(iRec, "BIRT", GEDCOMDate.CreateByFormattedStr(EditBirthDate.Text, true), EditBirthPlace.Text);
            }

            if (CheckDeath.Checked)
            {
                fBase.Context.CreateEventEx(iRec, "DEAT", GEDCOMDate.CreateByFormattedStr(EditDeathDate.Text, true), EditDeathPlace.Text);
            }

            if (!string.IsNullOrEmpty(MemoNote.Text))
            {
                GEDCOMNoteRecord noteRec = fBase.Context.Tree.CreateNote();
                noteRec.SetNoteText(MemoNote.Text);
                iRec.AddNote(noteRec);
            }

            fBase.NotifyRecord(iRec, RecordAction.raAdd);

            InitSimpleControls();
        }
Пример #5
0
        private PersonNameRet DefinePersonName(string str)
        {
            string f_name = "";
            string f_pat  = "";
            string f_fam  = "";
            string bd     = "";
            string dd     = "";

            string tmp = str;

            string dates = "";

            if (SpecialFormat_1)
            {
                int ob_pos = tmp.IndexOf("(*");
                if (ob_pos >= 0)
                {
                    int cb_pos = tmp.IndexOf(")", ob_pos);
                    if (cb_pos > ob_pos)
                    {
                        dates = tmp.Substring(ob_pos + 1, cb_pos - ob_pos - 1).Trim();
                        tmp   = tmp.Remove(ob_pos, dates.Length + 2);
                    }
                }
            }

            // if not Special or SpecialNotFound, then classic
            if (string.IsNullOrEmpty(dates))
            {
                int bd_pos = tmp.IndexOf(ImportUtils.STD_BIRTH_SIGN);
                int dd_pos = tmp.IndexOf(ImportUtils.STD_DEATH_SIGN);

                int datesPos = -1;
                if (bd_pos >= 0 && (dd_pos < 0 || dd_pos > bd_pos))
                {
                    datesPos = bd_pos;
                }
                else
                {
                    datesPos = dd_pos;
                }

                if (datesPos >= 0)
                {
                    dates = tmp.Substring(datesPos, tmp.Length - datesPos);
                    tmp   = tmp.Remove(datesPos, dates.Length).Trim(); // can be blanks at end
                }
            }

            // parse dates line
            if (!string.IsNullOrEmpty(dates))
            {
                int b_pos = dates.IndexOf(ImportUtils.STD_BIRTH_SIGN);
                int d_pos = dates.IndexOf(ImportUtils.STD_DEATH_SIGN);

                if (d_pos >= 0 && d_pos > b_pos)
                {
                    dd    = dates.Substring(d_pos + 1, dates.Length - d_pos - 1);
                    dates = dates.Remove(d_pos, dd.Length + 1);
                    dates = dates.Trim();
                }

                if (b_pos >= 0)
                {
                    bd    = dates.Substring(b_pos + 1, dates.Length - b_pos - 1);
                    dates = dates.Remove(b_pos, bd.Length + 1);
                    dates = dates.Trim();
                }

                bd = RemoveDot(bd);
                dd = RemoveDot(dd);
            }

            tmp = RemoveCommaDot(tmp); // &Trim()

            string[] tokens = tmp.Split(new char[] { ' ' }, 3);

            switch (NameFormat)
            {
            case NameFormat.nfIOF:
                if (tokens.Length > 0)
                {
                    f_name = RemoveDot(tokens[0]);
                }
                if (tokens.Length > 1)
                {
                    f_pat = RemoveDot(tokens[1]);
                }
                if (tokens.Length > 2)
                {
                    f_fam = RemoveDot(tokens[2]);
                }
                break;

            case NameFormat.nfFIO:
                if (tokens.Length > 0)
                {
                    f_fam = RemoveDot(tokens[0]);
                }
                if (tokens.Length > 1)
                {
                    f_name = RemoveDot(tokens[1]);
                }
                if (tokens.Length > 2)
                {
                    f_pat = RemoveDot(tokens[2]);
                }
                break;
            }

            if (SurnamesNormalize)
            {
                f_fam = SysUtils.NormalizeName(f_fam);
            }

            return(new PersonNameRet(f_name, f_pat, f_fam, bd, dd));
        }
Пример #6
0
        public void SysUtils_Tests()
        {
            #if __MonoCS__
            Assert.IsTrue(SysUtils.IsUnix());
            Assert.AreEqual(PlatformID.Unix, SysUtils.GetPlatformID());
            Assert.IsFalse(string.IsNullOrEmpty(SysUtils.GetMonoVersion()));
            Assert.AreNotEqual(DesktopType.Windows, SysUtils.GetDesktopType());
            #else
            Assert.IsFalse(SysUtils.IsUnix());
            Assert.AreEqual(PlatformID.Win32NT, SysUtils.GetPlatformID());
            Assert.IsTrue(string.IsNullOrEmpty(SysUtils.GetMonoVersion()));
            Assert.AreEqual(DesktopType.Windows, SysUtils.GetDesktopType());
            #endif

            //

            Assert.IsTrue(SysUtils.IsUnicodeEncoding(Encoding.UTF8));
            Assert.IsFalse(SysUtils.IsUnicodeEncoding(Encoding.ASCII));

            //

            int days = SysUtils.DaysBetween(new DateTime(1990, 10, 10), new DateTime(1990, 10, 13));
            Assert.AreEqual(3, days);

            days = SysUtils.DaysBetween(new DateTime(1990, 10, 10), new DateTime(1990, 10, 02));
            Assert.AreEqual(-8, days);

            Assert.AreEqual(31, SysUtils.DaysInAMonth(1990, 5));

            //

            Assert.AreEqual(true, SysUtils.IsSetBit(3, 0));
            Assert.AreEqual(true, SysUtils.IsSetBit(3, 1));
            Assert.AreEqual(false, SysUtils.IsSetBit(3, 4));

            //

            Assert.AreEqual(495, SysUtils.Trunc(495.575));

            Assert.AreEqual(3.0f, SysUtils.SafeDiv(9.0f, 3.0f));
            Assert.AreEqual(0.0f, SysUtils.SafeDiv(9.0f, 0.0f));

            //

            Assert.Throws(typeof(ArgumentNullException), () => { SysUtils.FirstOrDefault <int>(null); });
            int N = SysUtils.FirstOrDefault(new int[] { 5, 7, 10 });
            Assert.AreEqual(5, N);

            Assert.Throws(typeof(ArgumentNullException), () => { SysUtils.LastOrDefault <int>(null); });
            N = SysUtils.LastOrDefault(new int[] { 5, 7, 10 });
            Assert.AreEqual(10, N);

            // other
            string st = "ivan";
            st = SysUtils.NormalizeName(st);
            Assert.AreEqual("Ivan", st);

            st = SysUtils.NormalizeName(null);
            Assert.AreEqual("", st);

            //
            Assert.AreEqual("", SysUtils.GetFileExtension("testfile"));
            Assert.AreEqual(".ext", SysUtils.GetFileExtension("testfile.eXt"));

            Assert.IsFalse(SysUtils.IsRemovableDrive(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData)));

            Assembly asm   = this.GetType().Assembly;
            var      attr1 = SysUtils.GetAssemblyAttribute <AssemblyTitleAttribute>(asm);
            Assert.IsNotNull(attr1);
            Assert.AreEqual("GKTests", attr1.Title);

            Assert.Throws(typeof(ArgumentNullException), () => { SysUtils.GetAssemblyAttribute <AssemblyTitleAttribute>(null); });
        }