Esempio n. 1
0
 public virtual void EnumElements(EnumElementHandler Handler,
                                  ElementType Type,
                                  EnumFlag Flag,
                                  string NameOfElement,
                                  object Param)
 {
 }
Esempio n. 2
0
 static void PrintAllMissesDay(EnumFlag e)
 {
     foreach (var v in Enum.GetNames(typeof(EnumFlag)))
     {
         if (Enum.TryParse <EnumFlag>(v, out EnumFlag result) != e.HasFlag(result))
         {
             Console.WriteLine(result);
         }
     }
 }
Esempio n. 3
0
        public void EnumElements(EnumElementHandler Handler,
                                 ElementType Type,
                                 EnumFlag Flag,
                                 string NameOfElement,
                                 object Param)
        {
            Debug.Assert(null != m_iHostService);

            m_iHostService.EnumElements(Handler, Type, Flag, NameOfElement, Param);
        }
Esempio n. 4
0
 static bool ThisDayExist(EnumFlag myEnum, EnumFlag day)
 {
     if (myEnum.HasFlag(day))
     {
         return(true);
     }
     else
     {
         return(false);
     }
 }
Esempio n. 5
0
        static void Main(string[] args)
        {
            EnumFlag days = new EnumFlag();

            days = EnumFlag.Sunday | EnumFlag.Wednesday;
            Console.WriteLine(days);

            ThisDayExist(days, EnumFlag.Wednesday);
            ThisDayExist(days, EnumFlag.Friday);
            PrintAllMissesDay(days);
            days = AddDay(days, EnumFlag.Monday);
            days = RemoveDay(days, EnumFlag.Wednesday);
            PrintAllMissesDay(days);
        }
Esempio n. 6
0
        public void SetFlagSumTest()
        {
            var enumFlag = new EnumFlag <TestFlag>();

            enumFlag.SetFlagSum(5);
            Assert.IsFalse(enumFlag.Test(TestFlag.None));
            Assert.IsTrue(enumFlag.Test(TestFlag.Value1));
            Assert.IsFalse(enumFlag.Test(TestFlag.Value2));
            Assert.IsTrue(enumFlag.Test(TestFlag.Value3));
            Assert.IsFalse(enumFlag.Test(TestFlag.Value4));
            Assert.IsFalse(enumFlag.Test(TestFlag.Value5));

            enumFlag.SetFlagSum(7);
            Assert.IsFalse(enumFlag.Test(TestFlag.None));
            Assert.IsTrue(enumFlag.Test(TestFlag.Value1));
            Assert.IsTrue(enumFlag.Test(TestFlag.Value2));
            Assert.IsTrue(enumFlag.Test(TestFlag.Value3));
            Assert.IsFalse(enumFlag.Test(TestFlag.Value4));
            Assert.IsFalse(enumFlag.Test(TestFlag.Value5));

            enumFlag.Accept(TestFlag.Value5);
            Assert.AreEqual(23, enumFlag.ToBitMask());
        }
Esempio n. 7
0
 static EnumFlag RemoveDay(EnumFlag myEnum, EnumFlag day)
 {
     return(myEnum &= ~day);
 }
Esempio n. 8
0
 static EnumFlag AddDay(EnumFlag myEnum, EnumFlag day)
 {
     return(myEnum | day);
 }
Esempio n. 9
0
        public void EnumElement(EnumElementHandler Handler,
                                ElementType Type,
                                EnumFlag Flag,
                                string NameOfElement,
                                object Param)
        {
            Debug.Assert(null != Handler);

            //name
            Regex reg = null;

            if (!string.IsNullOrEmpty(NameOfElement))
            {
                reg = new Regex(NameOfElement, RegexOptions.IgnoreCase);
            }

            bool continueEnum = true;

            foreach (var ele in m_dicScreenElements)
            {
                if ((ElementType.Button == Type) &&
                    !(ele.Value is HtmlScreenButtonElement))
                {
                    continue;
                }

                if ((ElementType.Input == Type) &&
                    !(ele.Value is HtmlScreenInputElement))
                {
                    continue;
                }

                if (EnumFlag.OnlyEnable == Flag &&
                    !(ele.Value.IsEnable))
                {
                    continue;
                }

                if (EnumFlag.OnlyVisible == Flag &&
                    !(ele.Value.IsVisible))
                {
                    continue;
                }

                if (EnumFlag.VisibleAndEnable == Flag &&
                    !(ele.Value.IsVisible && ele.Value.IsEnable))
                {
                    continue;
                }

                if (EnumFlag.VisibleOrEnable == Flag &&
                    (!ele.Value.IsEnable && !ele.Value.IsVisible))
                {
                    continue;
                }

                if (null != reg)
                {
                    Match m = reg.Match(ele.Value.HostedElement.Id);
                    if (!m.Success)
                    {
                        continue;
                    }
                }

                continueEnum = Handler.Invoke(ele.Value.HostedElement.Id, ele.Value.Key, Param);
                if (!continueEnum)
                {
                    break;
                }
            }
        }