/// <summary>
/// Construct an instance of TextFormatter implementation with the specified context
/// </summary>
/// <param name="soleContext"></param>
/// <remarks>
/// TextFormatter created via this special ctor takes a specified context and uses it as the only known
/// context within its entire lifetime. It prohibits reentering of TextFormatter during formatting as only
/// one context is allowed. This restriction is critical to the optimal break algorithm supported by the current
/// version of PTLS.
/// </remarks>
internal TextFormatterImp(TextFormatterContext soleContext, TextFormattingMode textFormattingMode)
{
_textFormattingMode = textFormattingMode;
if (soleContext != null)
{
_contextList.Add(soleContext);
}
_multipleContextProhibited = (_contextList.Count != 0);
}
/// <summary>
/// ShrinkToFit - Shrink the data to fit in exactly one chunk
/// </summary>
internal void ShrinkToFit()
{
Debug.Assert(_chunkList.Count != 0);
if (_chunkList.Count > 1 ||
_chunkList[0].Length != _currOffset)
{
byte [] buffer = new byte[_currOffset];
unsafe
{
fixed(byte *pbData = buffer)
{
ReadData(pbData, 0, _currOffset);
}
}
ByteStreamGeometryContext.ReturnChunkToPool(_chunkList[0]);
// The common case is a single chunk in a SingleItemList held by the FrugalStructList.
// Avoid tearing down and recreating the SingleItemList by updating the lone element in-place,
// especially since ShrinkToFit is called from DisposeCore when this object is about to die.
if (_chunkList.Count == 1)
{
_chunkList[0] = buffer;
}
else
{
_chunkList = new FrugalStructList <byte[]>();
_chunkList.Add(buffer);
}
}
}
/// <summary>
/// Implementation of Freezable.CloneCurrentValueCore()
/// </summary>
protected override void CloneCurrentValueCore(Freezable source)
{
PointCollection sourcePointCollection = (PointCollection)source;
base.CloneCurrentValueCore(source);
int count = sourcePointCollection._collection.Count;
_collection = new FrugalStructList <Point>(count);
for (int i = 0; i < count; i++)
{
_collection.Add(sourcePointCollection._collection[i]);
}
}
/// <summary>
/// Implementation of Freezable.CloneCore()
/// </summary>
protected override void CloneCore(Freezable source)
{
DoubleCollection sourceDoubleCollection = (DoubleCollection)source;
base.CloneCore(source);
int count = sourceDoubleCollection._collection.Count;
_collection = new FrugalStructList <double>(count);
for (int i = 0; i < count; i++)
{
_collection.Add(sourceDoubleCollection._collection[i]);
}
}
/// <summary>
/// Implementation of Freezable.GetCurrentValueAsFrozenCore()
/// </summary>
protected override void GetCurrentValueAsFrozenCore(Freezable source)
{
Vector3DCollection sourceVector3DCollection = (Vector3DCollection)source;
base.GetCurrentValueAsFrozenCore(source);
int count = sourceVector3DCollection._collection.Count;
_collection = new FrugalStructList <Vector3D>(count);
for (int i = 0; i < count; i++)
{
_collection.Add(sourceVector3DCollection._collection[i]);
}
}
/// <summary>
/// Implementation of Freezable.GetAsFrozenCore()
/// </summary>
protected override void GetAsFrozenCore(Freezable source)
{
Point3DCollection sourcePoint3DCollection = (Point3DCollection)source;
base.GetAsFrozenCore(source);
int count = sourcePoint3DCollection._collection.Count;
_collection = new FrugalStructList <Point3D>(count);
for (int i = 0; i < count; i++)
{
_collection.Add(sourcePoint3DCollection._collection[i]);
}
}
/// <summary>
/// Implementation of Freezable.GetCurrentValueAsFrozenCore()
/// </summary>
protected override void GetCurrentValueAsFrozenCore(Freezable source)
{
TextEffectCollection sourceTextEffectCollection = (TextEffectCollection)source;
base.GetCurrentValueAsFrozenCore(source);
int count = sourceTextEffectCollection._collection.Count;
_collection = new FrugalStructList <TextEffect>(count);
for (int i = 0; i < count; i++)
{
TextEffect newValue = (TextEffect)sourceTextEffectCollection._collection[i].GetCurrentValueAsFrozen();
OnFreezablePropertyChanged(/* oldValue = */ null, newValue);
_collection.Add(newValue);
}
}
/// <summary>
/// Implementation of Freezable.CloneCurrentValueCore()
/// </summary>
protected override void CloneCurrentValueCore(Freezable source)
{
GradientStopCollection sourceGradientStopCollection = (GradientStopCollection)source;
base.CloneCurrentValueCore(source);
int count = sourceGradientStopCollection._collection.Count;
_collection = new FrugalStructList <GradientStop>(count);
for (int i = 0; i < count; i++)
{
GradientStop newValue = (GradientStop)sourceGradientStopCollection._collection[i].CloneCurrentValue();
OnFreezablePropertyChanged(/* oldValue = */ null, newValue);
_collection.Add(newValue);
}
}
/// <summary>
/// Implementation of Freezable.GetAsFrozenCore()
/// </summary>
protected override void GetAsFrozenCore(Freezable source)
{
GeneralTransformCollection sourceGeneralTransformCollection = (GeneralTransformCollection)source;
base.GetAsFrozenCore(source);
int count = sourceGeneralTransformCollection._collection.Count;
_collection = new FrugalStructList <GeneralTransform>(count);
for (int i = 0; i < count; i++)
{
GeneralTransform newValue = (GeneralTransform)sourceGeneralTransformCollection._collection[i].GetAsFrozen();
OnFreezablePropertyChanged(/* oldValue = */ null, newValue);
_collection.Add(newValue);
}
}
/// <summary>
/// Implementation of Freezable.CloneCore()
/// </summary>
protected override void CloneCore(Freezable source)
{
PathSegmentCollection sourcePathSegmentCollection = (PathSegmentCollection)source;
base.CloneCore(source);
int count = sourcePathSegmentCollection._collection.Count;
_collection = new FrugalStructList <PathSegment>(count);
for (int i = 0; i < count; i++)
{
PathSegment newValue = (PathSegment)sourcePathSegmentCollection._collection[i].Clone();
OnFreezablePropertyChanged(/* oldValue = */ null, newValue);
_collection.Add(newValue);
}
}
/// <summary>
/// Implementation of Freezable.CloneCore()
/// </summary>
protected override void CloneCore(Freezable source)
{
GeometryCollection sourceGeometryCollection = (GeometryCollection)source;
base.CloneCore(source);
int count = sourceGeometryCollection._collection.Count;
_collection = new FrugalStructList <Geometry>(count);
for (int i = 0; i < count; i++)
{
Geometry newValue = (Geometry)sourceGeometryCollection._collection[i].Clone();
OnFreezablePropertyChanged(/* oldValue = */ null, newValue);
_collection.Add(newValue);
OnInsert(newValue);
}
}
/// <summary>
/// Implementation of Freezable.CloneCurrentValueCore()
/// </summary>
protected override void CloneCurrentValueCore(Freezable source)
{
Transform3DCollection sourceTransform3DCollection = (Transform3DCollection)source;
base.CloneCurrentValueCore(source);
int count = sourceTransform3DCollection._collection.Count;
_collection = new FrugalStructList <Transform3D>(count);
for (int i = 0; i < count; i++)
{
Transform3D newValue = (Transform3D)sourceTransform3DCollection._collection[i].CloneCurrentValue();
OnFreezablePropertyChanged(/* oldValue = */ null, newValue);
_collection.Add(newValue);
OnInsert(newValue);
}
}
/// <summary>
/// Implementation of Freezable.GetAsFrozenCore()
/// </summary>
protected override void GetAsFrozenCore(Freezable source)
{
MaterialCollection sourceMaterialCollection = (MaterialCollection)source;
base.GetAsFrozenCore(source);
int count = sourceMaterialCollection._collection.Count;
_collection = new FrugalStructList <Material>(count);
for (int i = 0; i < count; i++)
{
Material newValue = (Material)sourceMaterialCollection._collection[i].GetAsFrozen();
OnFreezablePropertyChanged(/* oldValue = */ null, newValue);
_collection.Add(newValue);
OnInsert(newValue);
}
}
/// <summary>
/// Creates a Vector3DCollection with all of the same elements as collection
/// </summary>
public Vector3DCollection(IEnumerable <Vector3D> collection)
{
// The WritePreamble and WritePostscript aren't technically necessary
// in the constructor as of 1/20/05 but they are put here in case
// their behavior changes at a later date
WritePreamble();
if (collection != null)
{
ICollection <Vector3D> icollectionOfT = collection as ICollection <Vector3D>;
if (icollectionOfT != null)
{
_collection = new FrugalStructList <Vector3D>(icollectionOfT);
}
else
{
ICollection icollection = collection as ICollection;
if (icollection != null) // an IC but not and IC<T>
{
_collection = new FrugalStructList <Vector3D>(icollection);
}
else // not a IC or IC<T> so fall back to the slower Add
{
_collection = new FrugalStructList <Vector3D>();
foreach (Vector3D item in collection)
{
_collection.Add(item);
}
}
}
WritePostscript();
}
else
{
throw new ArgumentNullException("collection");
}
}
//
// This method
// 1. Adds a ChildPropertyDependent entry to the given
// PropertyDependents list. This is used when invalidating
// properties dependent upon a certain property on the container.
// The dependent properties could have originated from a Trigger
// or from a property alias on a TemplateNode.
//
private static void AddPropertyDependent(
int childIndex,
DependencyProperty dp,
ref FrugalStructList<ChildPropertyDependent> propertyDependents)
{
ChildPropertyDependent dependent = new ChildPropertyDependent();
dependent.ChildIndex = childIndex;
dependent.Property = dp;
propertyDependents.Add(dependent);
}
//
// This method
// 1. Adds a ChildPropertyDependent entry to the given
// ResourceDependents list. This is used when invalidating
// resource references
//
private static void AddResourceDependent(
int childIndex,
DependencyProperty dp,
object name,
ref FrugalStructList<ChildPropertyDependent> resourceDependents)
{
bool add = true;
for (int i = 0; i < resourceDependents.Count; i++)
{
// Check for duplicate entry
ChildPropertyDependent resourceDependent = resourceDependents[i];
if ((resourceDependent.ChildIndex == childIndex) &&
(resourceDependent.Property == dp) &&
(resourceDependent.Name == name))
{
add = false;
break;
}
}
if (add)
{
// Since there isn't a duplicate entry,
// create and add a new one
ChildPropertyDependent resourceDependent = new ChildPropertyDependent();
resourceDependent.ChildIndex = childIndex;
resourceDependent.Property = dp;
resourceDependent.Name = name;
resourceDependents.Add(resourceDependent);
}
}
/// <summary>
/// Add a new span to vector
/// </summary>
private void Add(Span span)
{
_spans.Add(span);
}
internal void ShrinkToFit()
{
Debug.Assert(_chunkList.Count != 0);
if (_chunkList.Count > 1 ||
_chunkList[0].Length != _currOffset)
{
byte [] buffer = new byte[_currOffset];
unsafe
{
fixed (byte *pbData = buffer)
{
ReadData(pbData, 0, _currOffset);
}
_chunkList = new FrugalStructList<byte[]>();
_chunkList.Add(buffer);
}
}
}
//
// All table datastructures read-lock-free/write-lock
// AddContainerDependent writes the datastructures, locks set by callers
//
// This method
// 1. Adds a ContainerDependent to the ContainerDependents list if not
// already present. This is used to invalidate container dependents.
//
internal static void AddContainerDependent(
DependencyProperty dp,
bool fromVisualTrigger,
ref FrugalStructList<ContainerDependent> containerDependents)
{
ContainerDependent dependent;
for (int i = 0; i < containerDependents.Count; i++)
{
dependent = containerDependents[i];
if (dp == dependent.Property)
{
// If the dp is set on targetType tag and can be set via TriggerBase it is recorded as coming
// from TriggerBase because that way we are pessimistic in invalidating and always invalidate.
dependent.FromVisualTrigger |= fromVisualTrigger;
return;
}
}
dependent = new ContainerDependent();
dependent.Property = dp;
dependent.FromVisualTrigger = fromVisualTrigger;
containerDependents.Add(dependent);
}
/// <summary>
/// Creates a TextEffectCollection with all of the same elements as collection
/// </summary>
public TextEffectCollection(IEnumerable <TextEffect> collection)
{
// The WritePreamble and WritePostscript aren't technically necessary
// in the constructor as of 1/20/05 but they are put here in case
// their behavior changes at a later date
WritePreamble();
if (collection != null)
{
bool needsItemValidation = true;
ICollection <TextEffect> icollectionOfT = collection as ICollection <TextEffect>;
if (icollectionOfT != null)
{
_collection = new FrugalStructList <TextEffect>(icollectionOfT);
}
else
{
ICollection icollection = collection as ICollection;
if (icollection != null) // an IC but not and IC<T>
{
_collection = new FrugalStructList <TextEffect>(icollection);
}
else // not a IC or IC<T> so fall back to the slower Add
{
_collection = new FrugalStructList <TextEffect>();
foreach (TextEffect item in collection)
{
if (item == null)
{
throw new System.ArgumentException(SR.Get(SRID.Collection_NoNull));
}
TextEffect newValue = item;
OnFreezablePropertyChanged(/* oldValue = */ null, newValue);
_collection.Add(newValue);
}
needsItemValidation = false;
}
}
if (needsItemValidation)
{
foreach (TextEffect item in collection)
{
if (item == null)
{
throw new System.ArgumentException(SR.Get(SRID.Collection_NoNull));
}
OnFreezablePropertyChanged(/* oldValue = */ null, item);
}
}
WritePostscript();
}
else
{
throw new ArgumentNullException("collection");
}
}
internal void ShrinkToFit()
{
Debug.Assert(_chunkList.Count != 0);
if (_chunkList.Count > 1 ||
_chunkList[0].Length != _currOffset)
{
byte [] buffer = new byte[_currOffset];
unsafe
{
fixed (byte *pbData = buffer)
{
ReadData(pbData, 0, _currOffset);
}
}
ByteStreamGeometryContext.ReturnChunkToPool(_chunkList[0]);
// The common case is a single chunk in a SingleItemList held by the FrugalStructList.
// Avoid tearing down and recreating the SingleItemList by updating the lone element in-place,
// especially since ShrinkToFit is called from DisposeCore when this object is about to die.
if (_chunkList.Count == 1)
{
_chunkList[0] = buffer;
}
else
{
_chunkList = new FrugalStructList<byte[]>();
_chunkList.Add(buffer);
}
}
}
