public Node Intersect(Node other, Lineage lineage, ValueSelector <TKey, TValue, TValue, TValue> collision = null)
{
var intersection = IntersectElements(other);
var list = new List <StructTuple <int, Bucket> >();
#if ASSERTS
var hsMe = AllBuckets.Select(x => x.Key).ToHashSet(Eq);
var hsOther = other.AllBuckets.Select(x => x.Key).ToHashSet(Eq);
hsMe.IntersectWith(hsOther);
#endif
foreach (var pair in intersection)
{
var newBucket = pair.First.Bucket.Intersect(pair.Second.Bucket, lineage, collision);
if (!newBucket.IsEmpty)
{
list.Add(StructTuple.Create(pair.First.Hash, newBucket));
}
}
#if ASSERTS
var duplicates = list.Select(x => new { x, count = list.Count(y => y.First.Equals(x.First)) }).OrderByDescending(x => x.count);
list.Count.AssertEqual(x => x <= Count && x <= other.Count);
Debug_Intersect(list.SelectMany(x => x.Second.Buckets.Select(y => y.Key)).ToList(), other);
#endif
return(FromSortedList(list, 0, list.Count - 1, lineage));
}
protected IDerivedState <TResult> BindToDerivedState <TInput, TResult>(IState <TInput> state, Func <TInput, TResult> derive)
{
var derivedState = new DerivedState <TInput, TResult>(state, derive);
boundStates.Add(state, ValueSelector.Create(derive));
return(derivedState);
}
public LayerBase()
{
Effects = new ObservableCollection<EffectBase>();
Effects.CollectionChanged += updateEffectLayer;
Visible = true;
VisibleFor = new ValueSelector<BoolWithPassthrough>(BoolWithPassthrough.Yes);
}
/// <summary>Initializes a new instance of the <seealso cref="FlexibleDictionary{TKey, TValue}"/> class. Each key in the provided collection is transformed with <paramref name="valueSelector"/> and added to the dictionary.</summary>
/// <param name="keyCollection">The collection of keys to initialize the dictionary from.</param>
/// <param name="valueSelector">The selector that transforms a <typeparamref name="TKey"/> into a <typeparamref name="TValue"/>.</param>
public FlexibleDictionary(IEnumerable <TKey> keyCollection, ValueSelector <TKey, TValue> valueSelector)
: this()
{
foreach (var key in keyCollection)
{
Add(key, valueSelector(key));
}
}
public void SelectElement_ShouldReturnValueDeclarations_WhenNoAttributesArePassed()
{
// Given
var underTest = new ValueSelector();
// When
// Then
}
private Control RenderValueSelector(ValueSelector valueSelector)
{
return(new OptionSelector
{
Name = valueSelector.Name,
Margin = ControlMargin,
Options = valueSelector.Options,
SelectedItem = valueSelector.SelectedOptionKey,
});
}
public void SelectElement_ShouldReturnValueDeclarations_WhenNoAttributesArePassed()
{
// Given
var underTest = new ValueSelector();
// When
// Then
}
private void MergeVisual(Label label, params VisualCollector[] styles)
{
label.TextColor = ValueSelector.GetTextColor(styles);
label.FontAttributes = ValueSelector.FontAttribute(styles);
label.FontFamily = ValueSelector.FontFamily(styles);
label.FontSize = ValueSelector.FontSize(styles);
label.LineBreakMode = ValueSelector.GetLineBreakMode(styles);
label.VerticalTextAlignment = ValueSelector.GetVerticalAlignment(styles);
label.HorizontalTextAlignment = ValueSelector.GetHorizontalAlignment(styles);
}
public ValueSelectorValidatorTests()
{
_validator = new ValueSelectorValidator();
_settings = new Dictionary <string, string>();
var config = Substitute.For <IStronkConfig>();
config.ConfigSources.Returns(new[] { new DictionarySource(_settings) });
config.Mappers.Returns(new[] { new PropertyNamePropertyMapper() });
_selector = new ValueSelector(config);
}
/// <summary>
/// Subtracts the key-value pairs in the specified map from this one, applying the subtraction function on each key shared between the maps.
/// </summary>
/// <param name="other">A sequence of key-value pairs. This operation is much faster if it's a map compatible with this one.</param>
/// <param name="subtraction">Optionally, a subtraction function that generates the value in the resulting key-value map. Otherwise, key-value pairs are always removed.</param>
/// <remarks>
/// Subtraction over maps is anaologous to Except over sets.
/// If the subtraction function is not specified (or is null), the operation simply subtracts all the keys present in the other map from this one.
/// If a subtraction function is supplied, the operation invokes the function on each key-value pair shared with the other map. If the function returns a value,
/// that value is used in the return map. If the function returns None, the key is removed from the return map.
/// </remarks>
public override ImmSortedMap <TKey, TValue> Subtract <TValue2>(IEnumerable <KeyValuePair <TKey, TValue2> > other,
ValueSelector <TKey, TValue, TValue2, Optional <TValue> > subtraction = null)
{
other.CheckNotNull("other");
var map = other as ImmSortedMap <TKey, TValue2>;
if (map != null && Comparer.Equals(map.Comparer))
{
return(Root.Except(map.Root, Lineage.Mutable(), subtraction).WrapMap(Comparer));
}
return(base.Subtract(other, subtraction));
}
/// <summary>
/// Subtracts the key-value pairs in the specified map from this one, applying the subtraction function on each key shared between the maps.
/// </summary>
/// <param name="other">A sequence of key-value pairs. This operation is much faster if it's a map compatible with this one.</param>
/// <param name="subtraction">Optionally, a subtraction function that generates the value in the resulting key-value map. Otherwise, key-value pairs are always removed.</param>
/// <remarks>
/// Subtraction over maps is anaologous to Except over sets.
/// If the subtraction function is not specified (or is null), the operation simply subtracts all the keys present in the other map from this one.
/// If a subtraction function is supplied, the operation invokes the function on each key-value pair shared with the other map. If the function returns a value,
/// that value is used in the return map. If the function returns None, the key is removed from the return map.
/// </remarks>
public override ImmMap <TKey, TValue> Subtract <TValue2>(IEnumerable <KeyValuePair <TKey, TValue2> > other,
ValueSelector <TKey, TValue, TValue2, Optional <TValue> > subtraction = null)
{
other.CheckNotNull("other");
var map = other as ImmMap <TKey, TValue2>;
if (map != null && _equality.Equals(map._equality))
{
return(Except(map, subtraction));
}
return(base.Subtract(other, subtraction));
}
public ThresholdDimension(ValueSelector selector, DimensionFormatter formatter, params TDuration[] thresholds)
{
if (formatter == null)
{
throw new ArgumentNullException(nameof(formatter));
}
_selector = selector ?? throw new ArgumentNullException(nameof(selector));
_thresholds = thresholds ?? throw new ArgumentNullException(nameof(thresholds));
Array.Sort(_thresholds);
_thresholdStrings = _thresholds.Select(t => formatter(t)).ToArray();
}
/// <summary>
/// Joins this map with another map by key, returning a map consisting of the keys present in both maps, the value of each such key being determined by the specified collision resolution function.
/// </summary>
/// <typeparam name="TValue2">The type of value of the second map.</typeparam>
/// <param name="other">A sequence of key-value pairs. This operation is much faster if it's a map compatible with this one.</param>
/// <param name="selector">The function that determines the value associated with each key in the new map.</param>
/// <remarks>
/// A map join operation is an operation over maps of key-value pairs, which is analogous to an intersection operation over sets.
/// The operation returns a new key-value map consisting of only those keys present in both maps,
/// with the value associated with each key being determined by the collision resolution function.
/// The collision resolution function takes as input the key, and the values associated with that key in the two maps.
/// This method is optimized when the input collection is a map compatible with this one.
/// </remarks>
/// <returns></returns>
public TMap Join <TValue2>(IEnumerable <KeyValuePair <TKey, TValue2> > other,
ValueSelector <TKey, TValue, TValue2, TValue> selector)
{
other.CheckNotNull("other");
selector.CheckNotNull("selector");
//NOTE: other can be TMap when TValue = TValue2.
var map = other as TMap;
if (map != null && IsCompatibleWith(map))
{
return(Join(map, (ValueSelector <TKey, TValue, TValue, TValue>)(object) selector));
}
return(Join_Unchecked(other, selector));
}
/// <summary>
/// Merges the two maps, applying the selector function for keys appearing in both maps.
/// </summary>
/// <param name="other">A sequence of key-value pairs. This operation is much faster if it's a map compatible with this one.</param>
/// <param name="collision">
/// The collision resolution function. If null, the values in the other map overwrite the values in this map.
/// </param>
/// <remarks>
/// The merge operation is analogous to a union operation over sets.
///
/// This operation returns all key-value pairs present in either map. If a key is shared between both maps, the collision resolution function is applied to determine the value in the result map.
/// </remarks>
public virtual TMap Merge(IEnumerable <KeyValuePair <TKey, TValue> > other, ValueSelector <TKey, TValue, TValue, TValue> collision = null)
{
other.CheckNotNull("other");
if (collision == null && ReferenceEquals(this, other))
{
return(this);
}
var map = other as TMap;
if (map != null && IsCompatibleWith(map))
{
return(Merge(map, collision));
}
return(Merge_Unchecked(other, collision));
}
private TMap Join_Unchecked <TValue2>(IEnumerable <KeyValuePair <TKey, TValue2> > other,
ValueSelector <TKey, TValue, TValue2, TValue> collision)
{
using (var builder = EmptyBuilder) {
other.ForEach(pair => {
var myKvp = builder.TryGetKvp(pair.Key).Or(TryGetKvp(pair.Key));
if (myKvp.IsSome)
{
var kvp = myKvp.Value;
var newValue = collision(kvp.Key, kvp.Value, pair.Value);
builder.Set(kvp.Key, newValue);
}
});
return(builder.Produce());
}
}
public Bucket Intersect(Bucket other, Lineage lineage, ValueSelector <TKey, TValue, TValue, TValue> collision = null)
{
var newBucket = Empty;
foreach (var item in Items)
{
var otherItem = other.Find(item.Key);
if (otherItem.IsNone)
{
continue;
}
var valueToAdd = collision == null ? item.Value : collision(item.Key, item.Value, otherItem.Value);
newBucket = NewBucket(item.Key, valueToAdd, newBucket, lineage);
}
return(newBucket);
}
public Node Union(Node b, Lineage lin, ValueSelector <TKey, TValue, TValue, TValue> collision = null)
{
if (IsEmpty)
{
return(b);
}
if (b.IsEmpty)
{
return(this);
}
if (ReferenceEquals(this, b) && collision == null)
{
return(this);
}
var myCount = Count;
var bCount = b.Count;
#if ASSERTS
var expected = Pairs.Select(x => x.Key).ToHashSet(Eq);
var oldContents = b.Pairs.Select(x => x.Key).ToArray();
expected.UnionWith(oldContents);
#endif
Node aLesser, aGreater;
Node centerNode;
Split(b.Hash, out aLesser, out centerNode, out aGreater, lin);
var unitedLeft = aLesser.Union(b.Left, lin, collision);
if (centerNode == null)
{
centerNode = b;
}
else
{
var newBucket = centerNode.Bucket.Union(b.Bucket, collision, lin);
centerNode = centerNode.WithBucket(newBucket, lin);
}
var unitedRight = aGreater.Union(b.Right, lin, collision);
var concated = Concat(unitedLeft, centerNode, unitedRight, lin);
#if ASSERTS
AssertEx.AssertTrue(concated.Count <= myCount + bCount);
AssertEx.AssertTrue(concated.Count >= myCount);
AssertEx.AssertTrue(concated.Count >= bCount);
AssertEx.AssertTrue(concated.IsBalanced);
var hs = concated.Pairs.Select(x => x.Key).ToHashSet(Eq);
hs.SetEquals(expected).AssertTrue();
#endif
return(concated);
}
/// <summary>
/// Returns the set-thereotic intersection between the two trees, and applies the collision resolution function on each
/// shared key-value pair. O(min(m+n,nlogm)) where n ≤ m. <br />
/// If the collision resolution function is null, it is ignored and the value is kept is arbitrary.
/// </summary>
/// <param name="other"></param>
/// <param name="lineage"></param>
/// <param name="collision"></param>
/// <returns></returns>
public Node Intersect(Node other, Lineage lineage, ValueSelector <TKey, TValue, TValue, TValue> collision = null)
{
var intersection = IntersectElements(other);
var list = new List <KeyValuePair <TKey, TValue> >();
foreach (var pair in intersection)
{
var newValue = collision == null
? pair.First.Value : collision(pair.First.Key, pair.First.Value, pair.Second.Value);
list.Add(Kvp.Of(pair.First.Key, newValue));
}
#if ASSERTS
list.Count.AssertEqual(x => x <= Count && x <= other.Count);
Debug_Intersect(list.Select(x => x.Key).ToList(), other);
#endif
return(FromSortedList(list, 0, list.Count - 1, Comparer, lineage));
}
public void RenderPreset(IRenderPanel target, Preset preset)
{
target.ClearItems();
foreach (var controller in preset.Controllers)
{
FrameworkElement?rendered = null;
rendered = controller switch
{
Presets.Controls.Slider bitrateSlider => RenderBitrateSlider(bitrateSlider),
VideoScale videoScale => RenderVideoScale(videoScale),
VideoTime videoTime => RenderVideoTime(videoTime),
ValueSelector valueSelector => RenderValueSelector(valueSelector),
_ => throw new InvalidOperationException(),
};
target.Render(RenderLabel(controller.Label));
target.Render(rendered);
}
}
public CustomTextLayer()
{
Text = new ValueSelector <string>();
Text.Single = "Example";
Text.CountryNone = "";
Text.CountryUSSR = "СССР";
Text.CountryGermany = "Deutschland";
Text.CountryUSA = "USA";
Text.CountryFrance = "France";
Text.CountryChina = "中国";
Text.CountryUK = "UK";
Text.CountryJapan = "日本";
Text.CountryCzech = "Česko";
Text.CountrySweden = "Sverige";
Text.CountryPoland = "Polska";
Text.CountryItaly = "Italia";
Text.ClassNone = "";
Text.ClassLight = "LT";
Text.ClassMedium = "MT";
Text.ClassHeavy = "HT";
Text.ClassDestroyer = "D";
Text.ClassArtillery = "A";
Text.CategNormal = "•";
Text.CategPremium = "♦";
Text.CategSpecial = "∞";
Text.CategCollector = "❖";
Text.TierNone = "";
Text.Tier1 = "I";
Text.Tier2 = "II";
Text.Tier3 = "III";
Text.Tier4 = "IV";
Text.Tier5 = "V";
Text.Tier6 = "VI";
Text.Tier7 = "VII";
Text.Tier8 = "VIII";
Text.Tier9 = "IX";
Text.Tier10 = "X";
}
/// <summary>
/// Returns the set-theoretic union, and applies a function on the values in case of a collision. <br />
/// If the collision resolution function is null, the value of 'b' is used.
/// </summary>
/// <param name="b"></param>
/// <param name="collision"></param>
/// <param name="lin"></param>
/// <returns></returns>
public Node Union(Node b, ValueSelector <TKey, TValue, TValue, TValue> collision, Lineage lin)
{
if (IsEmpty)
{
return(b);
}
if (b.IsEmpty)
{
return(this);
}
#if ASSERTS
var expected = Pairs.Select(x => x.Key).Union(b.Pairs.Select(x => x.Key)).ToSortedSet(Comparer);
#endif
Node aLesser, aGreater;
Node centerNode;
var oldThisCount = Count;
var oldBCount = b.Count;
Split(b.Key, out aLesser, out centerNode, out aGreater, lin);
var bLeft = b.Left;
var bRight = b.Right;
var unitedLeft = aLesser.Union(bLeft, collision, lin);
var newValue = collision == null || centerNode == null ? b.Value : collision(b.Key, centerNode.Value, b.Value);
var unitedRight = aGreater.Union(bRight, collision, lin);
if (centerNode == null)
{
centerNode = b.WithChildren(unitedLeft, unitedRight, lin);
}
else
{
var chosenNode = b.CanMutateBy(lin) ? b : centerNode;
centerNode = chosenNode.MutateOrCreate(newValue, unitedLeft, unitedRight, lin);
}
var concated = Concat(unitedLeft, centerNode, unitedRight, lin);
#if ASSERTS
AssertEx.AssertTrue(concated.Count <= oldThisCount + oldBCount);
AssertEx.AssertTrue(concated.Count >= oldThisCount);
AssertEx.AssertTrue(concated.Count >= oldBCount);
AssertEx.AssertTrue(concated.IsBalanced);
var result = concated.Pairs.Select(x => x.Key).ToSortedSet(Comparer);
result.SetEquals(expected).AssertTrue();
#endif
return(concated);
}
/// <summary>
/// Subtracts the key-value pairs in the specified map from this one, applying the subtraction function on each key shared between the maps.
/// </summary>
/// <param name="other">A sequence of key-value pairs. This operation is much faster if it's a map compatible with this one.</param>
/// <param name="subtraction">Optionally, a subtraction function that generates the value in the resulting key-value map. Otherwise, key-value pairs are always removed.</param>
/// <remarks>
/// Subtraction over maps is anaologous to Except over sets.
/// If the subtraction function is not specified (or is null), the operation simply subtracts all the keys present in the other map from this one.
/// If a subtraction function is supplied, the operation invokes the function on each key-value pair shared with the other map. If the function returns a value,
/// that value is used in the return map. If the function returns None, the key is removed from the return map.
/// </remarks>
public virtual TMap Subtract <TValue2>(IEnumerable <KeyValuePair <TKey, TValue2> > other,
ValueSelector <TKey, TValue, TValue2, Optional <TValue> > subtraction = null)
{
if (subtraction == null && ReferenceEquals(other, this))
{
return(Empty);
}
other.CheckNotNull("other");
//NOTE: other can be a TMap when TValue2 = TValue! ReSharper can't seem to understand this...
var map = other as TMap;
if (map != null && IsCompatibleWith(map))
{
return(Subtract(map, (ValueSelector <TKey, TValue, TValue, Optional <TValue> >)(object) subtraction));
}
return(Subtract_Unchecked(other, subtraction));
}
TMap Merge_Unchecked(IEnumerable <KeyValuePair <TKey, TValue> > other,
ValueSelector <TKey, TValue, TValue, TValue> collision = null)
{
other.CheckNotNull("other");
using (var builder = BuilderFrom(this)) {
other.ForEach(item => {
if (collision == null)
{
builder.Set(item.Key, item.Value);
}
else
{
var myElement = builder.TryGetKvp(item.Key);
var value = myElement.IsSome ? collision(myElement.Value.Key, myElement.Value.Value, item.Value) : item.Value;
builder.Set(item.Key, value);
}
});
return(builder.Produce());
}
}
/// <summary>
/// Removes the keys of the other tree from this tree. Keys are ignored. <br />
/// Corresponds to a set theoretic relative complement: this ∖ other.
/// </summary>
/// <param name="other"></param>
/// <param name="lin"></param>
/// <param name="subtraction"></param>
/// <returns></returns>
public Node Except <TValue2>(OrderedAvlTree <TKey, TValue2> .Node other, Lineage lin,
ValueSelector <TKey, TValue, TValue2, Optional <TValue> > subtraction = null)
{
if (IsEmpty || other.IsEmpty)
{
return(this);
}
Node thisLesser, thisGreater;
Node centralNode;
Split(other.Key, out thisLesser, out centralNode, out thisGreater, lin);
var thisLesserCount = thisLesser.Count;
var thisGreaterCount = thisGreater.Count;
var exceptLesser = thisLesser.Except(other.Left, lin, subtraction);
var subtracted = centralNode != null && subtraction != null
? subtraction(other.Key, centralNode.Value, other.Value) : Optional.None;
var exceptGreater = thisGreater.Except(other.Right, lin, subtraction);
var exceptLesserCount = exceptLesser.Count;
var exceptGreaterCount = exceptGreater.Count;
Node ret;
if (subtracted.IsNone)
{
ret = Concat(exceptLesser, exceptGreater, lin);
}
else
{
centralNode = centralNode.WithValue(subtracted.Value, lin);
ret = Concat(exceptLesser, centralNode, exceptGreater, lin);
}
#if ASSERTS
AssertEx.AssertTrue(exceptLesserCount <= thisLesserCount);
AssertEx.AssertTrue(exceptGreaterCount <= thisGreaterCount);
AssertEx.AssertTrue(exceptGreaterCount + exceptLesserCount <= thisLesserCount + thisGreaterCount);
AssertEx.AssertTrue(exceptGreater.IsBalanced);
#endif
return(ret);
}
public Node Except <TValue2>(HashedAvlTree <TKey, TValue2> .Node other, Lineage lin,
ValueSelector <TKey, TValue, TValue2, Optional <TValue> > subtraction = null)
{
if (IsEmpty || other.IsEmpty)
{
return(this);
}
if (ReferenceEquals(this, other) && subtraction == null)
{
return(Empty);
}
Node thisLesser, thisGreater;
Node central;
Split(other.Hash, out thisLesser, out central, out thisGreater, lin);
var thisLesserCount = thisLesser.Count;
var thisGreaterCount = thisGreater.Count;
var exceptLesser = thisLesser.Except(other.Left, lin, subtraction);
var exceptBucket = central == null ? null : central.Bucket.Except(other.Bucket, lin, subtraction);
var exceptGreater = thisGreater.Except(other.Right, lin, subtraction);
var exceptLesserCount = exceptLesser.Count;
var exceptGreaterCount = exceptGreater.Count;
Node ret;
if (exceptBucket == null || exceptBucket.IsEmpty)
{
ret = Concat(exceptLesser, exceptGreater, lin);
}
else
{
ret = Concat(exceptLesser, central.WithBucket(exceptBucket, lin), exceptGreater, lin);
}
#if ASSERTS
AssertEx.AssertTrue(exceptLesserCount <= thisLesserCount);
AssertEx.AssertTrue(exceptGreaterCount <= thisGreaterCount);
AssertEx.AssertTrue(exceptGreaterCount + exceptLesserCount <= thisLesserCount + thisGreaterCount);
AssertEx.AssertTrue(ret.IsBalanced);
#endif
return(ret);
}
TMap Subtract_Unchecked <TValue2>(IEnumerable <KeyValuePair <TKey, TValue2> > other,
ValueSelector <TKey, TValue, TValue2, Optional <TValue> > subtraction = null)
{
other.CheckNotNull("other");
using (var builder = BuilderFrom(this)) {
var len = Length;
other.ForEachWhile(item => {
if (subtraction == null)
{
if (builder.Remove(item.Key))
{
len--;
}
}
else
{
var tryGet = builder.TryGetKvp(item.Key).Map(x => x.Value);
if (tryGet.IsNone)
{
return(len > 0);
}
var newValue = subtraction(item.Key, tryGet.Value, item.Value);
if (newValue.IsSome)
{
builder.Set(item.Key, newValue.Value);
}
else
{
if (builder.Remove(item.Key))
{
len--;
}
}
}
return(len > 0);
});
return(builder.Produce());
}
}
public CustomTextLayer()
{
Text = new ValueSelector<string>();
Text.Single = "Example";
Text.CountryNone = "";
Text.CountryUSSR = "СССР";
Text.CountryGermany = "Deutschland";
Text.CountryUSA = "USA";
Text.CountryFrance = "France";
Text.CountryChina = "中国";
Text.CountryUK = "UK";
Text.CountryJapan = "日本";
Text.ClassNone = "";
Text.ClassLight = "LT";
Text.ClassMedium = "MT";
Text.ClassHeavy = "HT";
Text.ClassDestroyer = "D";
Text.ClassArtillery = "A";
Text.CategNormal = "•";
Text.CategPremium = "♦";
Text.CategSpecial = "∞";
Text.TierNone = "";
Text.Tier1 = "I";
Text.Tier2 = "II";
Text.Tier3 = "III";
Text.Tier4 = "IV";
Text.Tier5 = "V";
Text.Tier6 = "VI";
Text.Tier7 = "VII";
Text.Tier8 = "VIII";
Text.Tier9 = "IX";
Text.Tier10 = "X";
}
public Bucket Except <TValue2>(HashedAvlTree <TKey, TValue2> .Bucket other, Lineage lineage,
ValueSelector <TKey, TValue, TValue2, Optional <TValue> > subtraction = null)
{
var newBucket = Empty;
foreach (var item in Items)
{
var findOther = other.Find(item.Key);
if (findOther.IsNone)
{
newBucket = NewBucket(item.Key, item.Value, newBucket, lineage);
}
else if (subtraction != null)
{
var newValue = subtraction(item.Key, item.Value, findOther.Value);
if (newValue.IsSome)
{
newBucket = NewBucket(item.Key, newValue.Value, newBucket, lineage);
}
}
}
return(newBucket);
}
public Bucket Union(Bucket other, ValueSelector <TKey, TValue, TValue, TValue> collision, Lineage lineage)
{
var newBucket = Empty;
foreach (var item in Items)
{
var findOther = other.Find(item.Key);
var valueToAdd = item.Value;
if (findOther.IsSome)
{
other = other.Remove(item.Key, lineage);
valueToAdd = collision == null ? findOther.Value : collision(item.Key, item.Value, findOther.Value);
}
newBucket = NewBucket(item.Key, valueToAdd, newBucket, lineage);
}
foreach (var item in other.Items)
{
newBucket = NewBucket(item.Key, item.Value, newBucket, lineage);
}
return(newBucket);
}
protected void initialiseOverlay(TextureEditGUI gui)
{
_alphaSelector = new ValueSelector<byte, ByteField>(_overlay._alpha, 0, 255, 1, "Alpha", Color.white);
_textureAlphaSelector = new ValueSelector<byte, ByteField>(_overlay._textureAlpha, 0, 255, 1, "Texture Alpha", Color.white);
_normalScaleSelector = new ValueSelector<float, FloatField>(_overlay._normalScale, 0, 5.0f, 0.1f, "Normal Scale", Color.white);
if (gui.kspTextureInfo().isSpecular) _textureAlphaSelector.setLabel("Specularity");
else if (gui.kspTextureInfo().isTransparent) _textureAlphaSelector.setLabel("Transparency");
}
public void initialise(ASPTextureEdit textureEdit, int count)
{
_windowID = _nextID;
++_nextID;
_textureEdit = textureEdit;
_windowPosition = new Rect(700, 200 -((count) * 100), 400, 400);
_locked = false;
_remakePreview = true;
_imageModifiers = _textureEdit.cloneImageModifiers();
_baseTexture = _textureEdit.cloneBaseTexture();
_baseTexture.gui().initialise(this);
_imageModifiers.guiInit(this);
_boundingBox = _textureEdit.cloneBoundingBox();
_bbXselector = new ValueSelector<int, IntField>(_boundingBox.x, 0, 999999, 1, "Bottom Left X", Color.white);
_bbYselector = new ValueSelector<int, IntField>(_boundingBox.y, 0, 999999, 1, "Bottom Left Y", Color.white);
_bbWselector = new ValueSelector<int, IntField>(_boundingBox.w, 0, 999999, 1, "Width", Color.white);
_bbHselector = new ValueSelector<int, IntField>(_boundingBox.h, 0, 999999, 1, "Height", Color.white);
_selectedModifier = -2;
Global.LastButtonPress = 0f;
Global.AutoRepeatGap = 0.4f;
}
protected override ImmMap <TKey, TValue> Subtract(ImmMap <TKey, TValue> other, ValueSelector <TKey, TValue, TValue, Optional <TValue> > subtraction = null)
{
return(Except(other, subtraction));
}
ImmMap <TKey, TValue> Except <TValue2>(ImmMap <TKey, TValue2> other,
ValueSelector <TKey, TValue, TValue2, Optional <TValue> > subtraction = null)
{
other.CheckNotNull("other");
return(_root.Except(other._root, Lineage.Mutable(), subtraction).WrapMap(_equality));
}
public void colorSelector(TextureEditGUI gui, ref ValueSelector<byte, ByteField> redSelector, ref ValueSelector<byte, ByteField> greenSelector,
ref ValueSelector<byte, ByteField> blueSelector, ref ValueSelector<byte, ByteField> alphaSelector)
{
if (redSelector.draw()) gui.setRemakePreview();
GUILayout.Space(10f);
if (greenSelector.draw()) gui.setRemakePreview();
GUILayout.Space(10f);
if (blueSelector.draw()) gui.setRemakePreview();
GUILayout.Space(10f);
if (alphaSelector.draw()) gui.setRemakePreview();
}
protected override ImmMap <TKey, TValue> Join(ImmMap <TKey, TValue> other,
ValueSelector <TKey, TValue, TValue, TValue> collision = null)
{
return(_root.Intersect(other._root, Lineage.Mutable(), collision).WrapMap(_equality));
}
public EffectBase()
{
Visible = true;
VisibleFor = new ValueSelector<BoolWithPassthrough>(BoolWithPassthrough.Yes);
}
protected void initialiseMonoOverlay(TextureEditGUI gui)
{
initialiseOverlay(gui);
_redSelector = new ValueSelector<byte, ByteField>(_overlay._red, 0, 255, 1, "Red", Color.red);
_greenSelector = new ValueSelector<byte, ByteField>(_overlay._green, 0, 255, 1, "Green", Color.green);
_blueSelector = new ValueSelector<byte, ByteField>(_overlay._blue, 0, 255, 1, "Blue", Color.blue);
}
protected override ImmSortedMap <TKey, TValue> Subtract(ImmSortedMap <TKey, TValue> other, ValueSelector <TKey, TValue, TValue, Optional <TValue> > subtraction = null)
{
return(Root.Except(other.Root, Lineage.Mutable(), subtraction).WrapMap(Comparer));
}
public CustomImageLayer()
{
ImageFile = new ValueSelector<Filename>("");
}
