Example #1
0
        public void AddComposition()
        {
            using (ITimeline timeline = new DefaultTimeline())
            {
                IGroup       group       = timeline.AddAudioGroup();
                IComposition composition = group.AddComposition();
                Assert.AreSame(group, composition.Container);
                Assert.AreSame(group, composition.Group);

                bool firedBefore = false;
                bool firedAfter  = false;

                composition.BeforeCompositionAdded += new EventHandler(delegate
                {
                    firedBefore = true;
                });

                composition.AfterCompositionAdded += new EventHandler <AfterCompositionAddedEventArgs>(delegate
                {
                    firedAfter = true;
                });

                IComposition childComposition = composition.AddComposition();
                Assert.AreSame(composition, childComposition.Container);
                Assert.AreSame(group, childComposition.Group);
                Assert.AreEqual(1, composition.Compositions.Count);
                Assert.IsTrue(firedBefore);
                Assert.IsTrue(firedAfter);
            }
        }
        /// <summary>
        /// Adds the <paramref name="composition"/> to the <see cref="Compositions"/>.
        /// </summary>
        /// <param name="type">The <see cref="Type"/> that is satisfied by the <paramref name="composition"/>.</param>
        /// <param name="composition">The <see cref="IComposition"/> to add.</param>
        /// <exception cref="CompositionException">
        /// There is already a <see cref="IComposition"/> for the specified <paramref name="type"/> that is not the
        /// default and cannot be superseded by specified <paramref name="composition"/>.
        /// </exception>
        public void AddComposition(Type type, IComposition composition)
        {
            if (type == null)
            {
                throw new ArgumentNullException(nameof(type));
            }
            if (composition == null)
            {
                throw new ArgumentNullException(nameof(composition));
            }

            if (_compositions.TryGetValue(type, out IComposition existing))
            {
#pragma warning disable SA1119 // Statement must not use unnecessary parenthesis
                if (!(existing is ConstructorComposition constructorComposition) || !constructorComposition.IsDefault)
#pragma warning restore SA1119 // Statement must not use unnecessary parenthesis
                {
                    string message =
                        $"There is already a composition for '{type}', are there multiple registrations. " +
                        $"The Existing composition is '{existing.GetType()}', the new composition is " +
                        $"'{composition.GetType()}'.";
                    throw new CompositionException(message);
                }
            }

            _compositions[type] = composition;
        }
Example #3
0
 public Percent PercentageFrom(IComposition composition)
 {
     return composition.PercentageFor<Gas>()
     .Plus(composition.PercentageFor<Oil>())
     .Plus(composition.PercentageFor<NGL>())
     .Plus(composition.PercentageFor<Condensate>());
 }
Example #4
0
        public void AddTransition()
        {
            using (ITimeline timeline = new DefaultTimeline())
            {
                IGroup       group       = timeline.AddVideoGroup(24, 100, 100);
                IComposition composition = group.AddComposition();

                bool firedBefore = false;
                bool firedAfter  = false;

                composition.BeforeTransitionAdded += new EventHandler(delegate
                {
                    firedBefore = true;
                });

                composition.AfterTransitionAdded += new EventHandler <AfterTransitionAddedEventArgs>(delegate
                {
                    firedAfter = true;
                });

                ITransition transition =
                    composition.AddTransition("test", 0, 2, StandardTransitions.CreateFade(), false);
                Assert.AreEqual(1, composition.Transitions.Count);
                Assert.AreEqual("test", transition.Name);
                Assert.AreEqual(0, transition.Offset);
                Assert.AreEqual(2, transition.Duration);
                Assert.IsTrue(firedBefore);
                Assert.IsTrue(firedAfter);
            }
        }
Example #5
0
        public void AddEffect()
        {
            using (ITimeline timeline = new DefaultTimeline())
            {
                IGroup       group       = timeline.AddVideoGroup(24, 100, 100);
                IComposition composition = group.AddComposition();

                bool firedBefore = false;
                bool firedAfter  = false;

                composition.BeforeEffectAdded += new EventHandler(delegate
                {
                    firedBefore = true;
                });

                composition.AfterEffectAdded += new EventHandler <AfterEffectAddedEventArgs>(delegate
                {
                    firedAfter = true;
                });

                IEffect effect = composition.AddEffect("test", -1, 1, 2, StandardEffects.CreateBlurEffect(2, 2, 10));
                Assert.AreEqual("test", effect.Name);
                Assert.AreEqual(1, effect.Offset);
                Assert.AreEqual(2, effect.Duration);
                Assert.AreEqual(1, composition.Effects.Count);
                Assert.IsTrue(firedBefore);
                Assert.IsTrue(firedAfter);
            }
        }
Example #6
0
        public List <IBaseDuck> CreatList()
        {
            Random           rnd        = new Random();
            List <IBaseDuck> _baseDucks = new List <IBaseDuck>();

            for (int i = 0; i < 6; i++)
            {
                IBaseDuck duck = null;

                if (rnd.Next(0, 10) % 2 == 0)
                {
                    IFly         F = ReturnFly(rnd.Next(0, 2));
                    IQuick       Q = ReturnQuick(rnd.Next(0, 2));
                    IComposition C = ReturnComposition(rnd.Next(0, 3));

                    duck = new Duck(F, Q, C);
                }
                else
                {
                    Turkey turkey;

                    IKudah       K = ReturnKudah(rnd.Next(0, 10) % 2);
                    IFly2        F = ReturnFly2(rnd.Next(0, 10) % 2);
                    IComposition C = ReturnComposition(rnd.Next(0, 3));

                    turkey = new Turkey(F, K, C);

                    duck = new CreateDuck(turkey);
                }

                _baseDucks.Add(duck);
            }

            return(_baseDucks);
        }
Example #7
0
        public void TrackAddEffectBubblesToComposition()
        {
            int beforeCount = 0;
            int afterCount  = 0;

            using (ITimeline timeline = new DefaultTimeline())
            {
                IGroup       group       = timeline.AddVideoGroup(24, 100, 100);
                IComposition composition = group.AddComposition();

                composition.BeforeEffectAdded += new EventHandler(delegate
                {
                    beforeCount++;
                });

                composition.AfterEffectAdded += new EventHandler <AfterEffectAddedEventArgs>(delegate
                {
                    afterCount++;
                });

                ITrack track = composition.AddTrack();
                track.AddEffect("test", -1, 1, 2, StandardEffects.CreateBlurEffect(2, 2, 10));

                Assert.AreEqual(1, beforeCount);
                Assert.AreEqual(1, afterCount);
            }
        }
Example #8
0
        public IComposition AddComposition(string name, int priority)
        {
            OnAddingComposition();

            IComposition composition =
                TimelineBuilder.AddCompositionToCollection(this, _desTimeline, _timelineComposition, _compositions, name,
                                                           priority);

            composition.AddingEffect    += child_BeforeEffectAdded;
            composition.AddedEffect     += child_AfterEffectAdded;
            composition.AddedClip       += child_AfterClipAdded;
            composition.AddingClip      += child_BeforeClipAdded;
            composition.AddedTransition +=
                child_AfterTransitionAdded;
            composition.AddingTransition  += child_BeforeTransitionAdded;
            composition.AddingTrack       += child_BeforeTrackAdded;
            composition.AddedTrack        += child_AfterTrackAdded;
            composition.AddingComposition += child_BeforeCompositionAdded;
            composition.AddedComposition  +=
                child_AfterCompositionAdded;

            OnAddedComposition(composition);

            return(composition);
        }
Example #9
0
        public void AddEffectSetsApropriateContainer()
        {
            using (ITimeline timeline = new DefaultTimeline())
            {
                EffectDefinition def = StandardEffects.CreateDefaultBlur();

                IGroup  group       = timeline.AddVideoGroup(24, 100, 100);
                IEffect groupEffect = group.AddEffect(0, 10, def);
                Assert.AreSame(group, groupEffect.Group);
                Assert.AreSame(group, groupEffect.Container);

                ITrack  track       = group.AddTrack();
                IEffect trackEffect = track.AddEffect(0, 10, def);
                Assert.AreSame(group, trackEffect.Group);
                Assert.AreSame(track, trackEffect.Container);

                IComposition composition       = group.AddComposition();
                IEffect      compositionEffect = composition.AddEffect(0, 10, def);
                Assert.AreSame(group, compositionEffect.Group);
                Assert.AreSame(composition, compositionEffect.Container);

                IClip   clip       = track.AddClip("..\\..\\image1.jpg", GroupMediaType.Image, InsertPosition.Absolute, 0, 0, 10);
                IEffect clipEffect = clip.AddEffect(0, 10, def);
                Assert.AreSame(group, clip.Group);
                Assert.AreSame(clip, clipEffect.Container);
            }
        }
Example #10
0
 protected void OnAfterCompositionAdded(IComposition composition)
 {
     if (_afterCompositionAdded != null)
     {
         _afterCompositionAdded(this, new AfterCompositionAddedEventArgs(composition, this));
     }
 }
Example #11
0
        public IComposition AddComposition(string name, int priority)
        {
            OnBeforeCompositionAdded();

            IComposition composition =
                TimelineUtils.AddCompositionToCollection(this, _desTimeline, _timelineComposition, _compositions, name,
                                                         priority);

            composition.BeforeEffectAdded    += new EventHandler(child_BeforeEffectAdded);
            composition.AfterEffectAdded     += new EventHandler <AfterEffectAddedEventArgs>(child_AfterEffectAdded);
            composition.AfterClipAdded       += new EventHandler <AfterClipAddedEventArgs>(child_AfterClipAdded);
            composition.BeforeClipAdded      += new EventHandler(child_BeforeClipAdded);
            composition.AfterTransitionAdded +=
                new EventHandler <AfterTransitionAddedEventArgs>(child_AfterTransitionAdded);
            composition.BeforeTransitionAdded  += new EventHandler(child_BeforeTransitionAdded);
            composition.BeforeTrackAdded       += new EventHandler(child_BeforeTrackAdded);
            composition.AfterTrackAdded        += new EventHandler <AfterTrackAddedEventArgs>(child_AfterTrackAdded);
            composition.BeforeCompositionAdded += new EventHandler(child_BeforeCompositionAdded);
            composition.AfterCompositionAdded  +=
                new EventHandler <AfterCompositionAddedEventArgs>(child_AfterCompositionAdded);

            OnAfterCompositionAdded(composition);

            return(composition);
        }
Example #12
0
        public void AddTrack()
        {
            using (ITimeline timeline = new DefaultTimeline())
            {
                IGroup       group       = timeline.AddAudioGroup();
                IComposition composition = group.AddComposition();

                bool firedBefore = false;
                bool firedAfter  = false;

                composition.BeforeTrackAdded += new EventHandler(delegate
                {
                    firedBefore = true;
                });

                composition.AfterTrackAdded += new EventHandler <AfterTrackAddedEventArgs>(delegate
                {
                    firedAfter = true;
                });

                ITrack track = composition.AddTrack();
                Assert.AreEqual(1, composition.Tracks.Count);
                Assert.IsTrue(firedBefore);
                Assert.IsTrue(firedAfter);
            }
        }
Example #13
0
 /// <summary>
 /// ダイアリセット
 /// </summary>
 public void DiagramReset()
 {
     useComposition.Release(useCompositionNum);
     useComposition    = null;
     useCompositionNum = 0;
     runningPerDay     = 0;
 }
Example #14
0
 public Slider(IComposition parent, SliderOrientation orientation, float value = 0f, float leftValue = 0f, float rightValue = 10f)
     : base(parent)
 {
     Orientation = orientation;
     LeftValue   = leftValue;
     RightValue  = rightValue;
     Value       = value;
 }
Example #15
0
 public Control(IComposition parent)
 {
     this.Parent = parent;
     if (null != parent)
     {
         Parent.AddChild(this);
     }
 }
        /// <summary>
        /// Initializes a new instance of the <see cref="SingletonComposition"/> class.
        /// </summary>
        /// <param name="inner">The <see cref="Inner"/> <see cref="IComposition"/>.</param>
        public SingletonComposition(IComposition inner)
        {
            if (inner == null)
            {
                throw new ArgumentNullException(nameof(inner));
            }

            Inner = inner;
        }
Example #17
0
        public void RemoveEvents()
        {
            int count = 0;

            EventHandler increment = delegate { count++; };
            EventHandler <AddedCompositionEventArgs> incrementForAfterCompositionAdded =
                delegate { count++; };
            EventHandler <AddedEffectEventArgs> incrementForAfterEffectAdded =
                delegate { count++; };
            EventHandler <AddedTrackEventArgs> incrementForAfterTrackAdded =
                delegate { count++; };
            EventHandler <AddedTransitionEventArgs> incrementForAfterTransitionAdded =
                delegate { count++; };
            EventHandler <AddedClipEventArgs> incrementForAfterClipAdded =
                delegate { count++; };

            using (ITimeline timeline = new DefaultTimeline())
            {
                IComposition composition = timeline.AddAudioGroup().AddComposition();
                composition.AddedComposition  += incrementForAfterCompositionAdded;
                composition.AddedEffect       += incrementForAfterEffectAdded;
                composition.AddedTrack        += incrementForAfterTrackAdded;
                composition.AddedTransition   += incrementForAfterTransitionAdded;
                composition.AddedClip         += incrementForAfterClipAdded;
                composition.AddingComposition += increment;
                composition.AddingEffect      += increment;
                composition.AddingTrack       += increment;
                composition.AddingTransition  += increment;
                composition.AddingClip        += increment;

                composition.AddComposition();
                composition.AddEffect(0, 2, StandardEffects.CreateDefaultBlur());
                composition.AddTrack().AddClip("testinput.mp3", GroupMediaType.Audio, InsertPosition.Absolute, 0, 0, 1);
                composition.AddTransition(0, 2, StandardTransitions.CreateFade());

                Assert.AreEqual(10, count);
                count = 0;

                composition.AddedComposition  -= incrementForAfterCompositionAdded;
                composition.AddedEffect       -= incrementForAfterEffectAdded;
                composition.AddedTrack        -= incrementForAfterTrackAdded;
                composition.AddedTransition   -= incrementForAfterTransitionAdded;
                composition.AddedClip         -= incrementForAfterClipAdded;
                composition.AddingComposition -= increment;
                composition.AddingEffect      -= increment;
                composition.AddingTrack       -= increment;
                composition.AddingTransition  -= increment;
                composition.AddingClip        -= increment;

                composition.AddComposition();
                composition.AddEffect(0, 2, StandardEffects.CreateDefaultBlur());
                composition.AddTrack();
                composition.AddTransition(2, 2, StandardTransitions.CreateFade());

                Assert.AreEqual(0, count);
            }
        }
        /// <summary>
        /// Adds the <paramref name="composition"/> to the <see cref="Compositions"/>.
        /// </summary>
        /// <param name="composition">The <see cref="IComposition"/> to add.</param>
        /// <exception cref="CompositionException">
        /// There is already a <see cref="IComposition"/> for the specified
        /// <paramref name="composition"/>.<see cref="IComposition.Type"/> that is not the
        /// default and cannot be superseded by specified <paramref name="composition"/>.
        /// </exception>
        public void AddComposition(IComposition composition)
        {
            if (composition == null)
            {
                throw new ArgumentNullException(nameof(composition));
            }

            AddComposition(composition.Type, composition);
        }
Example #19
0
        /// <summary>
        /// Initializes a new instance of the <see cref="SimpleParameterExpression"/> class.
        /// </summary>
        /// <param name="composition">The <see cref="Composition"/> used to satisfy the parameter expression.</param>
        public SimpleParameterExpression(IComposition composition)
        {
            if (composition == null)
            {
                throw new ArgumentNullException(nameof(composition));
            }

            Composition = composition;
        }
Example #20
0
 public void AddCompositionWithName()
 {
     using (ITimeline timeline = new DefaultTimeline())
     {
         IGroup       group       = timeline.AddAudioGroup();
         IComposition composition = group.AddComposition("named", -1);
         Assert.AreEqual("named", composition.Name);
     }
 }
Example #21
0
        /// <summary>
        /// 系統運行本数算出
        /// </summary>
        /// <param name="newComposition">編成</param>
        /// <param name="useCompositionNum">投入編成数</param>
        /// <param name="lineDiagramPairs">路線と適したダイアの組</param>
        /// <returns></returns>
        private int CalcRunningPerDay(IComposition newComposition, int useCompositionNum, ImmutableDictionary <Line, DiagramType> lineDiagramPairs)
        {
            int requireMinutes = route.Select(line => line.CalcRequieredMinutes(newComposition, lineDiagramPairs[line])).Sum();

            if (requireMinutes == 0)
            {
                return(0);
            }
            return(540 * useCompositionNum / requireMinutes);
        }
Example #22
0
 /// <summary>
 /// 投入していた編成の解放
 /// </summary>
 private void ReleaseComposition()
 {
     if (useComposition == null)
     {
         return;
     }
     useComposition.Release(useCompositionNum);
     useComposition    = null;
     useCompositionNum = 0;
     runningPerDay     = 0;
 }
Example #23
0
        public IContainerBuilder RegisterModule(IComposition composition = null)
        {
            if (composition == null)
            {
                composition = new Composition();
            }

            composition.Load(this.m_services);

            return(this);
        }
Example #24
0
        public static IEnumerator <V> GetEnumerator <T, U, V>(IEnumerable <T> e, IComposition <T, U, V> composition)
        {
            if (ReferenceEquals(composition.First, IdentityTransform <T> .Instance))
            {
                switch (composition.Second)
                {
                case SelectImpl <T, V> select: return(GetEnumerator(e, select.Selector));

                case WhereImpl <T> where: return((IEnumerator <V>)GetEnumerator(e, where.Predicate));
                }
            }

            return(new ConsumableEnumerableEnumerator <T, V>(e, composition.Composed));
        }
Example #25
0
        /// <summary>
        /// 指定された編成を受け入れ可能か検証
        /// </summary>
        /// <param name="composition">設定したい編成</param>
        /// <param name="gameInfo">ゲーム情報</param>
        public void ValidateCompositionAcceptable(IComposition composition, GameInfo gameInfo)
        {
            if (composition is null)
            {
                throw new ArgumentNullException(nameof(composition));
            }

            if (gameInfo is null)
            {
                throw new ArgumentNullException(nameof(gameInfo));
            }

            route.ForEach(line => line.ValidateCompositionAcceptable(composition, gameInfo));
        }
        /// <summary>
        /// Accepts the <see cref="PropertyDependencyRegistration"/> to visit.
        /// </summary>
        /// <param name="registration">The <see cref="PropertyDependencyRegistration"/> to visit.</param>
        public void Accept(PropertyDependencyRegistration registration)
        {
            if (registration == null)
            {
                throw new ArgumentNullException(nameof(registration));
            }

            // Visit the inner registration which will add a composition.
            _manager.Visit(registration.Inner);

            // Get the original composition, removing it to allow it to be replaced.
            IComposition inner = _container.RemoveComposition(registration.ImplementationType);

            (string property, Type type)[] propertiesToInject =
Example #27
0
        public Dictionary <Line, int> PredicateJosharitsu(IComposition composition, int runningPerDay)
        {
            //予測前にこの系統の設定を一時的に書き換えて予測して戻す
            var currentComp          = this.useComposition;
            var currentRunningPerday = this.runningPerDay;

            useComposition     = composition;
            this.runningPerDay = runningPerDay;
            Dictionary <Line, int> joshaDict = route.ToDictionary(line => line, line => line.Josharitsu);

            this.useComposition = currentComp;
            this.runningPerDay  = currentRunningPerday;

            return(joshaDict);
        }
Example #28
0
        /// <summary>
        /// 乗車可能数計算
        /// </summary>
        /// <param name="composition">編成</param>
        /// <param name="honsuu">運行本数</param>
        /// <returns></returns>
        public static int CalcMaximumCapacity(IComposition composition, int honsuu)
        {
            if (composition is null)
            {
                return(0);
            }

            int sectionCapacity = composition.PassengerCapacity * honsuu;

            //標準軌は多めに乗れる設定
            if (composition.Type == RailTypeEnum.Iron && composition.Gauge == CarGaugeEnum.Regular)
            {
                return(sectionCapacity * 4);
            }
            return(sectionCapacity * 3);
        }
Example #29
0
        /// <summary>
        /// 不足している編成数を計算
        /// </summary>
        /// <param name="newComposition">設定したい編成</param>
        /// <param name="runningPerDay">運行本数</param>
        /// <param name="lineDiagramPairs">路線と適したダイアの組</param>
        /// <returns></returns>
        public int CalcMissingCompositions(IComposition newComposition, int runningPerDay, ImmutableDictionary <Line, DiagramType> lineDiagramPairs)
        {
            int newUseCompNum = CalcUseCompositionNum(newComposition, runningPerDay, lineDiagramPairs);

            if (useComposition == newComposition)
            {
                //現行運用分を引き継いで使用パターン
                int missing = newUseCompNum - useCompositionNum - newComposition.HeldUnits;
                return(missing > 0 ? missing : 0);
            }
            else
            {
                //編成変更パターン
                return(newUseCompNum - newComposition.HeldUnits);
            }
        }
Example #30
0
 public void CompositionPriorities()
 {
     using (ITimeline timeline = new DefaultTimeline())
     {
         IGroup       group  = timeline.AddAudioGroup();
         IComposition first  = group.AddComposition("first", -1);
         IComposition second = group.AddComposition("second", 0);
         IComposition third  = group.AddComposition("third", 1);
         IComposition fourth = group.AddComposition("fourth", -1);
         IComposition fifth  = group.AddComposition("fifth", 2);
         Assert.AreEqual(3, first.Priority);
         Assert.AreEqual(0, second.Priority);
         Assert.AreEqual(1, third.Priority);
         Assert.AreEqual(4, fourth.Priority);
         Assert.AreEqual(2, fifth.Priority);
     }
 }
Example #31
0
        /// <summary>
        /// 運行本数から必要な編成数を割り出す
        /// </summary>
        /// <param name="newComposition"></param>
        /// <param name="runningPerDay"></param>
        /// <param name="lineDiagramPairs">路線と適したダイアの組</param>
        /// <returns></returns>
        public int CalcUseCompositionNum(IComposition newComposition, int runningPerDay, ImmutableDictionary <Line, DiagramType> lineDiagramPairs)
        {
            if (newComposition is null)
            {
                return(0);
            }

            //投入編成数を徐々に増やしていき、その投入編成数で引数の運行本数が最初に超えた投入編成数を必要な編成数とする
            for (int tempCompositionNum = 0; tempCompositionNum < int.MaxValue; tempCompositionNum++)
            {
                int tempRunningPerDay = CalcRunningPerDay(newComposition, tempCompositionNum, lineDiagramPairs);
                if (tempRunningPerDay >= runningPerDay)
                {
                    return(tempCompositionNum);
                }
            }
            return(0);
        }
        public IdentifiableItemBase(IIdentifiable itemInstance, IComposition composition)
        {
            Contract.Requires(itemInstance != null, "itemInstance != null");
            Contract.Requires(composition != null, "composition != null");

            _composition = composition;

            _guid = Guid.NewGuid().ToString();

            _cachedInstanceId = itemInstance.Id;
            _cachedInstanceDescribes = new Describes(itemInstance);

            _cachedCaptionEdited = false;
            _cachedDescriptionEdited = false;

            _itemInstance = itemInstance;

            _xConstructor = Constructor(itemInstance);
            _xConnectivity = Connectivity(itemInstance);

            if (itemInstance is IBaseLinkableComponentProposed)
                _platforms = ((IBaseLinkableComponentProposed)itemInstance).SupportedPlatforms;
            else if (itemInstance is IBaseExchangeItemProposed)
                _platforms = ((IBaseExchangeItemProposed)itemInstance).SupportedPlatforms;
            else
                _platforms = composition.Platforms;

            if (itemInstance is IBaseLinkableComponent)
                _interface = IdentifiableItemType.IBaseLinkableComponent;
            else if (itemInstance is IBaseAdaptedOutput)
                _interface = IdentifiableItemType.IBaseAdaptedOutput;
            else if (itemInstance is IBaseOutput)
                _interface = IdentifiableItemType.IBaseOutput;
            else if (itemInstance is IBaseInput)
                _interface = IdentifiableItemType.IBaseInput;
            else if (itemInstance is IAdaptedOutputFactory)
                _interface = IdentifiableItemType.IAdaptedOutputFactory;
            else
                _interface = IdentifiableItemType.Unknown;
        }
 public bool TestEquivalence(IComposition composition)
 {
     throw new NotImplementedException();
 }
 public IFuzzySet Composition(IFuzzySet other, IComposition composition)
 {
     return composition.Calculate(this, other);
 }
 public bool TestTransitive(IComposition composition)
 {
     throw new NotImplementedException();
 }
Example #36
0
 protected void OnAddedComposition(IComposition composition)
 {
     if (_afterCompositionAdded != null)
     {
         _afterCompositionAdded(this, new AddedCompositionEventArgs(composition, this));
     }
 }
Example #37
0
 public Percent PercentageFrom(IComposition composition)
 {
     return composition.PercentageFor<Condensate>();
 }
Example #38
0
 public Percent PercentageFrom(IComposition composition)
 {
     return composition.PercentageFor<Oil>();
 }
 public static void SetEffect(UIElement element, IComposition value)
 {
     element.SetValue(EffectProperty, value);
 }