public static FrameworkPropertyMetadataOptions GetOptions (FrameworkPropertyMetadata value)
{
FrameworkPropertyMetadataOptions result = FrameworkPropertyMetadataOptions.None;
if (value.AffectsArrange)
result |= FrameworkPropertyMetadataOptions.AffectsArrange;
if (value.AffectsMeasure)
result |= FrameworkPropertyMetadataOptions.AffectsMeasure;
if (value.AffectsParentArrange)
result |= FrameworkPropertyMetadataOptions.AffectsParentArrange;
if (value.AffectsParentMeasure)
result |= FrameworkPropertyMetadataOptions.AffectsParentMeasure;
if (value.AffectsRender)
result |= FrameworkPropertyMetadataOptions.AffectsRender;
if (value.BindsTwoWayByDefault)
result |= FrameworkPropertyMetadataOptions.BindsTwoWayByDefault;
if (value.Inherits)
result |= FrameworkPropertyMetadataOptions.Inherits;
if (value.Journal)
result |= FrameworkPropertyMetadataOptions.Journal;
if (value.IsNotDataBindable)
result |= FrameworkPropertyMetadataOptions.NotDataBindable;
if (value.OverridesInheritanceBehavior)
result |= FrameworkPropertyMetadataOptions.OverridesInheritanceBehavior;
if (value.SubPropertiesDoNotAffectRender)
result |= FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender;
return result;
}
private ArrayList SaveSubStreams(UIElement element)
{
ArrayList subStreams = null;
#pragma warning disable 618
if ((element != null) && (element.PersistId != 0))
#pragma warning restore 618
{
LocalValueEnumerator dpEnumerator = element.GetLocalValueEnumerator();
while (dpEnumerator.MoveNext())
{
LocalValueEntry localValueEntry = (LocalValueEntry)dpEnumerator.Current;
FrameworkPropertyMetadata metadata = localValueEntry.Property.GetMetadata(element.DependencyObjectType) as FrameworkPropertyMetadata;
if (metadata == null)
{
continue;
}
// To be saved, a DP should have the correct metadata and NOT be an expression or data bound.
// Since Bind inherits from Expression, the test for Expression will suffice.
// NOTE: we do not journal expression. So we should let parser restore it in BamlRecordReader.SetDependencyValue.
// Please see Windows OS
if (metadata.Journal && (!(localValueEntry.Value is Expression)))
{
// These properties should not be journaled.
//
if (object.ReferenceEquals(localValueEntry.Property, Frame.SourceProperty))
{
continue;
}
if (subStreams == null)
{
subStreams = new ArrayList(3);
}
object currentValue = element.GetValue(localValueEntry.Property);
byte[] bytes = null;
if ((currentValue != null) && !(currentValue is Uri))
{
// Convert the value of the DP into a byte array
MemoryStream byteStream = new MemoryStream();
new SecurityPermission(SecurityPermissionFlag.SerializationFormatter).Assert();
try
{
this.Formatter.Serialize(byteStream, currentValue);
}
finally
{
SecurityPermission.RevertAssert();
}
bytes = byteStream.ToArray();
// Dispose the stream
((IDisposable)byteStream).Dispose( );
}
// Save the byte array by the property name
subStreams.Add(new SubStream(localValueEntry.Property.Name, bytes));
}
}
}
return(subStreams);
}
//---------------------------------------------------------------------------------------------------------------------------------------
static TimeTicksElement()
{
FrameworkPropertyMetadata metadata = new FrameworkPropertyMetadata(null, new PropertyChangedCallback(OnCandlesSourceChanged))
{
AffectsRender = true
};
CandlesSourceProperty = DependencyProperty.Register("CandlesSource", typeof(IList <ICandle>), typeof(TimeTicksElement), metadata);
metadata = new FrameworkPropertyMetadata(0.0, new PropertyChangedCallback(OnCandleWidthChanged))
{
AffectsRender = true
};
CandleWidthProperty = DependencyProperty.Register("CandleWidth", typeof(double), typeof(TimeTicksElement), metadata);
metadata = new FrameworkPropertyMetadata(0.0, new PropertyChangedCallback(OnGapBetweenCandlesChanged))
{
AffectsRender = true
};
GapBetweenCandlesProperty = DependencyProperty.Register("GapBetweenCandles", typeof(double), typeof(TimeTicksElement), metadata);
metadata = new FrameworkPropertyMetadata(IntRange.Undefined)
{
AffectsRender = true
};
VisibleCandlesRangeProperty = DependencyProperty.Register("VisibleCandlesRange", typeof(IntRange), typeof(TimeTicksElement), metadata);
metadata = new FrameworkPropertyMetadata(10.0, FrameworkPropertyMetadataOptions.Inherits, new PropertyChangedCallback(OnTimeTickFontSizeChanged))
{
AffectsRender = true, AffectsMeasure = true
};
TimeTickFontSizeProperty = CandleChart.TimeTickFontSizeProperty.AddOwner(typeof(TimeTicksElement), metadata);
metadata = new FrameworkPropertyMetadata(0.0)
{
AffectsRender = true
};
TimePanelHeightProperty = DependencyProperty.Register("TimeAxisHeight", typeof(double), typeof(TimeTicksElement), metadata);
metadata = new FrameworkPropertyMetadata(0)
{
AffectsRender = true
};
TimeFrameProperty = DependencyProperty.Register("TimeFrame", typeof(int), typeof(TimeTicksElement), metadata);
metadata = new FrameworkPropertyMetadata(true)
{
AffectsRender = true
};
IsGridlinesEnabledProperty = DependencyProperty.Register("IsGridlinesEnabled", typeof(bool), typeof(TimeTicksElement), metadata);
Pen defaultPen = new Pen(new SolidColorBrush(Color.FromArgb(30, 0, 0, 0)), 1); // { DashStyle = new DashStyle(new double[] { 2, 3 }, 0) };
metadata = new FrameworkPropertyMetadata(defaultPen)
{
AffectsRender = true
};
GridlinesPenProperty = DependencyProperty.Register("GridlinesPen", typeof(Pen), typeof(TimeTicksElement), metadata);
metadata = new FrameworkPropertyMetadata(true)
{
AffectsRender = true
};
HideMinorGridlinesProperty = DependencyProperty.Register("HideMinorGridlines", typeof(bool), typeof(TimeTicksElement), metadata);
}
static ExtButton()
{
var metadata = new FrameworkPropertyMetadata(null);
SizeProperty = DependencyProperty.RegisterAttached("Size", typeof(int), typeof(ExtButton), metadata);
}
DependencyPropertyInfo GetDependencyPropertyInfo(PropertyInfo property, DependencyPropertyAttribute attribute)
{
if (_enforceWpfConvention)
{
// Find public dependency property field identifier.
const BindingFlags identifierModifiers = BindingFlags.Public | BindingFlags.Static;
string identifierField = property.Name + IdentifierSuffix;
FieldInfo identifier = OwnerType.GetField(identifierField, identifierModifiers);
if (identifier == null || (identifier.FieldType != typeof(DependencyProperty)))
{
throw new InvalidImplementationException(
ConventionEnabledError +
"There is no public static dependency property field identifier \"" + identifierField +
"\" available in the class \"" + OwnerType.Name + "\".");
}
// Verify name when set.
if (attribute.Name != null && property.Name != attribute.Name)
{
throw new InvalidImplementationException(
ConventionEnabledError + "The CLR property wrapper '" + property.Name +
"' doesn't match the name of the dependency property.");
}
}
// Set dependency property parameters.
Type propertyType = property.PropertyType;
MethodInfo setMethod = property.GetSetMethod();
object defaultValue;
if (attribute.DefaultValueProvider != null)
{
var defaultValueProvider = (IDefaultValueProvider <T>)Activator.CreateInstance(attribute.DefaultValueProvider);
defaultValue = defaultValueProvider.GetDefaultValue((T)attribute.GetId(), property.PropertyType);
}
else
{
defaultValue = attribute.DefaultValue ?? propertyType.CreateDefault();
}
if (defaultValue != null && defaultValue.GetType() != propertyType)
{
TypeConverter converter = TypeDescriptor.GetConverter(propertyType);
if (converter.CanConvertFrom(defaultValue.GetType()))
{
var context = new TypeDescriptorContext(propertyType);
defaultValue = converter.ConvertFrom(context, CultureInfo.CurrentCulture, defaultValue);
}
}
var metaData = new FrameworkPropertyMetadata
{
DefaultValue = defaultValue,
AffectsArrange = attribute.AffectsArrange,
AffectsMeasure = attribute.AffectsMeasure,
AffectsParentArrange = attribute.AffectsParentArrange,
AffectsParentMeasure = attribute.AffectsParentMeasure,
AffectsRender = attribute.AffectsRender,
SubPropertiesDoNotAffectRender = attribute.SubPropertiesDoNotAffectRender
};
var dependencyPropertyInfo = new DependencyPropertyInfo
{
IsAttached = false,
Name = attribute.Name ?? property.Name,
Type = propertyType,
// When no default value is set, use the default value.
MetaData = metaData,
// By default, readonly when setter is private.
ReadOnly = attribute.IsReadOnlySet() ? attribute.IsReadOnly() : (setMethod == null || setMethod.IsPrivate),
Id = (T)attribute.GetId()
};
return(dependencyPropertyInfo);
}
static LobbyButton()
{
var md = new FrameworkPropertyMetadata(false, IsJoiningRoomPropertyChanged);
IsJoiningRoomProperty = DependencyProperty.Register("IsJoiningRoom", typeof(bool), typeof(LobbyButton), md);
}
static IconsSelected()
{
var metadata = new FrameworkPropertyMetadata((ImageSource)null);
ImageSelectedProperty = DependencyProperty.RegisterAttached("ImageSelected", typeof(ImageSource), typeof(IconsSelected), metadata);
}
static WindowEntryView()
{
PropertyMetadata metadata = new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender); // Another attempt with no success.
WindowViewModelProperty = DependencyProperty.Register("WindowViewModel", typeof(WindowViewModel), typeof(WindowEntryView), metadata);
}
static ImageBoxControl()
{
FrameworkPropertyMetadata metadata = new FrameworkPropertyMetadata(string.Empty, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, XXXX);
ImageBoxControl.ValueProperty = DependencyProperty.Register("Value", typeof(string), typeof(ImageBoxControl), metadata);
}
static IconsHover()
{
var metadata = new FrameworkPropertyMetadata((ImageSource)null);
ImageHoverProperty = DependencyProperty.RegisterAttached("ImageHover", typeof(ImageSource), typeof(IconsHover), metadata);
}
static ColorPickerCombo()
{
FrameworkPropertyMetadata metadata = new FrameworkPropertyMetadata(Colors.Gray, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault);
SelectedColorProperty = DependencyProperty.Register("SelectedColor", typeof(Color), typeof(ColorPickerCombo), metadata);
}
//---------------------------------------------------------------------------------------------------------------------------------------
static PriceTicksElement()
{
FrameworkPropertyMetadata metadata = new FrameworkPropertyMetadata(10.0, FrameworkPropertyMetadataOptions.Inherits, new PropertyChangedCallback(OnPriceTickFontSizeChanged))
{
AffectsRender = true
};
PriceTickFontSizeProperty = CandleChart.PriceTickFontSizeProperty.AddOwner(typeof(PriceTicksElement), metadata);
metadata = new FrameworkPropertyMetadata(CandleChart.DefaultAxisTickColor, FrameworkPropertyMetadataOptions.Inherits)
{
AffectsRender = true
};
AxisTickColorProperty = CandleChart.AxisTickColorProperty.AddOwner(typeof(PriceTicksElement), metadata);
metadata = new FrameworkPropertyMetadata(0.0)
{
AffectsRender = true
};
PricePanelWidthProperty = DependencyProperty.Register("PriceAxisWidth", typeof(double), typeof(PriceTicksElement), metadata);
metadata = new FrameworkPropertyMetadata(new Vector(1, 1))
{
AffectsRender = true
};
CandlesLHProperty = DependencyProperty.Register("CandlesLH", typeof(Vector), typeof(PriceTicksElement), metadata);
metadata = new FrameworkPropertyMetadata(15.0)
{
AffectsRender = true
};
ChartBottomMarginProperty = DependencyProperty.Register("ChartBottomMargin", typeof(double), typeof(PriceTicksElement), metadata);
//MyCandleChart3.ChartBottomMarginProperty.AddOwner(typeof(PriceTicksElement), metadata);
metadata = new FrameworkPropertyMetadata(15.0)
{
AffectsRender = true
};
ChartTopMarginProperty = DependencyProperty.Register("ChartTopMargin", typeof(double), typeof(PriceTicksElement), metadata);
//MyCandleChart3.ChartTopMarginProperty.AddOwner(typeof(PriceTicksElement), metadata);
metadata = new FrameworkPropertyMetadata(0.0)
{
AffectsRender = true
};
GapBetweenTickLabelsProperty = DependencyProperty.Register("GapBetweenTickLabels", typeof(double), typeof(PriceTicksElement), metadata);
metadata = new FrameworkPropertyMetadata(true)
{
AffectsRender = true
};
IsGridlinesEnabledProperty = DependencyProperty.Register("IsGridlinesEnabled", typeof(bool), typeof(PriceTicksElement), metadata);
Pen defaultPen = new Pen(new SolidColorBrush(Color.FromArgb(50, 105, 42, 0)), 1); // { DashStyle = new DashStyle(new double[] { 2, 3 }, 0) };
metadata = new FrameworkPropertyMetadata(defaultPen)
{
AffectsRender = true
};
GridlinesPenProperty = DependencyProperty.Register("GridlinesPen", typeof(Pen), typeof(PriceTicksElement), metadata);
}
public static DependencyProperty Register(string name, Type propertyType, Type ownerType, FrameworkPropertyMetadata typeMetadata)
{
DependencyProperty dp = DependencyProperty.Register(name, propertyType, ownerType, typeMetadata);
#if SILVERLIGHT
if (typeMetadata != null && typeMetadata.CoerceValueCallback != null)
{
FrameworkPropertyMetadata.AssociatePropertyWithCoercionMethod(dp, typeMetadata.CoerceValueCallback);
}
#endif
return(dp);
}
static Button()
{
var metadata = new FrameworkPropertyMetadata((ImageSource)null);
PointsProperty = DependencyProperty.RegisterAttached("Points", typeof(PointCollection), typeof(Button), metadata);
}
private void PleaseWaitSelectLanguage(string language)
{
Dispatcher.Invoke(
(Action)(() =>
{
Thread.CurrentThread.CurrentCulture = new CultureInfo(StationRepository.CultureInfos[language.ToUpperInvariant()]);
Thread.CurrentThread.CurrentUICulture = new CultureInfo(StationRepository.CultureInfos[language.ToUpperInvariant()]);
}
));
TranslationProvider.CurrentLanguage = language;
TranslationManager.Instance.SetLanguage(CurrentLanguage.ShortName.ToUpperInvariant(), new CultureInfo(StationRepository.CultureInfos[CurrentLanguage.ShortName.ToUpperInvariant()]));
TranslationProvider.DefaultLanguage = StationRepository.DefaultDisplayLanguage;
DalStationSettings.Instance.Language = language;
if (FrameworkPropertyMetadata == null)
{
FrameworkPropertyMetadata = new FrameworkPropertyMetadata(XmlLanguage.GetLanguage(CultureInfo.CurrentCulture.IetfLanguageTag));
try
{
FrameworkElement.LanguageProperty.OverrideMetadata(typeof(FrameworkElement), FrameworkPropertyMetadata);
}
catch (Exception ex)
{
Log.Error("", ex);
}
}
Dispatcher.Invoke((Action)(() =>
{
if (ChangeTracker.CurrentMatch != null)
{
ChangeTracker.CurrentMatch.IsStartUp = true;
}
if (ChangeTracker.MainWindow != null)
{
ChangeTracker.MainWindow.Language = XmlLanguage.GetLanguage(CultureInfo.CurrentCulture.IetfLanguageTag);
}
if (IoCContainer.Kernel.Get <IChangeTracker>().UserProfileWindow != null)
{
IoCContainer.Kernel.Get <IChangeTracker>().UserProfileWindow.Language = XmlLanguage.GetLanguage(CultureInfo.CurrentCulture.IetfLanguageTag);
}
if (ChangeTracker.LiveMonitors != null)
{
foreach (var liveMonitor in ChangeTracker.LiveMonitors)
{
LiveWindowEntry monitor = liveMonitor;
Dispatcher.Invoke(() =>
{
monitor.Window.Language = XmlLanguage.GetLanguage(CultureInfo.CurrentCulture.IetfLanguageTag);
});
}
}
}));
ChangeTracker.OnPropertyChanged("AdminTitle1");
ChangeTracker.OnPropertyChanged("AdminTitle2");
Mediator.SendMessage(language, MsgTag.LanguageChosenHeader);
Mediator.SendMessage(true, MsgTag.Refresh);
Mediator.SendMessage(true, MsgTag.BasketRebindWheel);
}
public object Convert(object obj, Type type, object param,
CultureInfo culture)
{
FrameworkPropertyMetadataOptions flags = 0;
FrameworkPropertyMetadata metadata =
obj as FrameworkPropertyMetadata;
if (metadata == null)
{
return(null);
}
if (metadata.AffectsMeasure)
{
flags |= FrameworkPropertyMetadataOptions.AffectsMeasure;
}
if (metadata.AffectsArrange)
{
flags |= FrameworkPropertyMetadataOptions.AffectsArrange;
}
if (metadata.AffectsParentMeasure)
{
flags |= FrameworkPropertyMetadataOptions.AffectsParentMeasure;
}
if (metadata.AffectsParentArrange)
{
flags |= FrameworkPropertyMetadataOptions.AffectsParentArrange;
}
if (metadata.AffectsRender)
{
flags |= FrameworkPropertyMetadataOptions.AffectsRender;
}
if (metadata.Inherits)
{
flags |= FrameworkPropertyMetadataOptions.Inherits;
}
if (metadata.OverridesInheritanceBehavior)
{
flags |= FrameworkPropertyMetadataOptions.
OverridesInheritanceBehavior;
}
if (metadata.IsNotDataBindable)
{
flags |= FrameworkPropertyMetadataOptions.NotDataBindable;
}
if (metadata.BindsTwoWayByDefault)
{
flags |= FrameworkPropertyMetadataOptions.BindsTwoWayByDefault;
}
if (metadata.Journal)
{
flags |= FrameworkPropertyMetadataOptions.Journal;
}
return(flags);
}
internal static void TransformNodes(System.Xaml.XamlReader xamlReader, System.Xaml.XamlObjectWriter xamlWriter,
bool onlyLoadOneNode,
bool skipJournaledProperties,
bool shouldPassLineNumberInfo, IXamlLineInfo xamlLineInfo, IXamlLineInfoConsumer xamlLineInfoConsumer,
XamlContextStack <WpfXamlFrame> stack,
IStyleConnector styleConnector)
{
while (xamlReader.Read())
{
if (shouldPassLineNumberInfo)
{
if (xamlLineInfo.LineNumber != 0)
{
xamlLineInfoConsumer.SetLineInfo(xamlLineInfo.LineNumber, xamlLineInfo.LinePosition);
}
}
switch (xamlReader.NodeType)
{
case System.Xaml.XamlNodeType.NamespaceDeclaration:
xamlWriter.WriteNode(xamlReader);
if (stack.Depth == 0 || stack.CurrentFrame.Type != null)
{
stack.PushScope();
// Need to create an XmlnsDictionary.
// Look up stack to see if we have one earlier
// If so, use that. Otherwise new a xmlnsDictionary
WpfXamlFrame iteratorFrame = stack.CurrentFrame;
while (iteratorFrame != null)
{
if (iteratorFrame.XmlnsDictionary != null)
{
stack.CurrentFrame.XmlnsDictionary =
new XmlnsDictionary(iteratorFrame.XmlnsDictionary);
break;
}
iteratorFrame = (WpfXamlFrame)iteratorFrame.Previous;
}
if (stack.CurrentFrame.XmlnsDictionary == null)
{
stack.CurrentFrame.XmlnsDictionary =
new XmlnsDictionary();
}
}
stack.CurrentFrame.XmlnsDictionary.Add(xamlReader.Namespace.Prefix, xamlReader.Namespace.Namespace);
break;
case System.Xaml.XamlNodeType.StartObject:
WriteStartObject(xamlReader, xamlWriter, stack);
break;
case System.Xaml.XamlNodeType.GetObject:
xamlWriter.WriteNode(xamlReader);
// If there wasn't a namespace node before this get object, need to pushScope.
if (stack.CurrentFrame.Type != null)
{
stack.PushScope();
}
stack.CurrentFrame.Type = stack.PreviousFrame.Property.Type;
break;
case System.Xaml.XamlNodeType.EndObject:
xamlWriter.WriteNode(xamlReader);
// Freeze if required
if (stack.CurrentFrame.FreezeFreezable)
{
Freezable freezable = xamlWriter.Result as Freezable;
if (freezable != null && freezable.CanFreeze)
{
freezable.Freeze();
}
}
DependencyObject dependencyObject = xamlWriter.Result as DependencyObject;
if (dependencyObject != null && stack.CurrentFrame.XmlSpace.HasValue)
{
XmlAttributeProperties.SetXmlSpace(dependencyObject, stack.CurrentFrame.XmlSpace.Value ? "default" : "preserve");
}
stack.PopScope();
break;
case System.Xaml.XamlNodeType.StartMember:
// ObjectWriter should NOT process PresentationOptions:Freeze directive since it is Unknown
// The space directive node stream should not be written because it induces object instantiation,
// and the Baml2006Reader can produce space directives prematurely.
if (!(xamlReader.Member.IsDirective && xamlReader.Member == XamlReaderHelper.Freeze) &&
xamlReader.Member != XmlSpace.Value &&
xamlReader.Member != XamlLanguage.Space)
{
xamlWriter.WriteNode(xamlReader);
}
stack.CurrentFrame.Property = xamlReader.Member;
if (skipJournaledProperties)
{
if (!stack.CurrentFrame.Property.IsDirective)
{
System.Windows.Baml2006.WpfXamlMember wpfMember = stack.CurrentFrame.Property as System.Windows.Baml2006.WpfXamlMember;
if (wpfMember != null)
{
DependencyProperty prop = wpfMember.DependencyProperty;
if (prop != null)
{
FrameworkPropertyMetadata metadata = prop.GetMetadata(stack.CurrentFrame.Type.UnderlyingType) as FrameworkPropertyMetadata;
if (metadata != null && metadata.Journal == true)
{
// Ignore the BAML for this member, unless it declares a value that wasn't journaled - namely a binding or a dynamic resource
int count = 1;
while (xamlReader.Read())
{
switch (xamlReader.NodeType)
{
case System.Xaml.XamlNodeType.StartMember:
count++;
break;
case System.Xaml.XamlNodeType.StartObject:
XamlType xamlType = xamlReader.Type;
XamlType bindingBaseType = xamlType.SchemaContext.GetXamlType(typeof(BindingBase));
XamlType dynamicResourceType = xamlType.SchemaContext.GetXamlType(typeof(DynamicResourceExtension));
if (count == 1 && (xamlType.CanAssignTo(bindingBaseType) || xamlType.CanAssignTo(dynamicResourceType)))
{
count = 0;
WriteStartObject(xamlReader, xamlWriter, stack);
}
break;
case System.Xaml.XamlNodeType.EndMember:
count--;
if (count == 0)
{
xamlWriter.WriteNode(xamlReader);
stack.CurrentFrame.Property = null;
}
break;
case System.Xaml.XamlNodeType.Value:
DynamicResourceExtension value = xamlReader.Value as DynamicResourceExtension;
if (value != null)
{
WriteValue(xamlReader, xamlWriter, stack, styleConnector);
}
break;
}
if (count == 0)
{
break;
}
}
System.Diagnostics.Debug.Assert(count == 0, "Mismatch StartMember/EndMember");
}
}
}
}
}
break;
case System.Xaml.XamlNodeType.EndMember:
WpfXamlFrame currentFrame = stack.CurrentFrame;
XamlMember currentProperty = currentFrame.Property;
// ObjectWriter should not process PresentationOptions:Freeze directive nodes since it is unknown
// The space directive node stream should not be written because it induces object instantiation,
// and the Baml2006Reader can produce space directives prematurely.
if (!(currentProperty.IsDirective && currentProperty == XamlReaderHelper.Freeze) &&
currentProperty != XmlSpace.Value &&
currentProperty != XamlLanguage.Space)
{
xamlWriter.WriteNode(xamlReader);
}
currentFrame.Property = null;
break;
case System.Xaml.XamlNodeType.Value:
WriteValue(xamlReader, xamlWriter, stack, styleConnector);
break;
default:
xamlWriter.WriteNode(xamlReader);
break;
}
//Only do this loop for one node if loadAsync
if (onlyLoadOneNode)
{
return;
}
}
}
internal static void TransformNodes(System.Xaml.XamlReader xamlReader, System.Xaml.XamlObjectWriter xamlWriter,
bool onlyLoadOneNode,
bool skipJournaledProperties,
bool shouldPassLineNumberInfo, IXamlLineInfo xamlLineInfo, IXamlLineInfoConsumer xamlLineInfoConsumer,
XamlContextStack <WpfXamlFrame> stack,
IStyleConnector styleConnector)
{
while (xamlReader.Read())
{
if (shouldPassLineNumberInfo)
{
if (xamlLineInfo.LineNumber != 0)
{
xamlLineInfoConsumer.SetLineInfo(xamlLineInfo.LineNumber, xamlLineInfo.LinePosition);
}
}
switch (xamlReader.NodeType)
{
case System.Xaml.XamlNodeType.NamespaceDeclaration:
xamlWriter.WriteNode(xamlReader);
if (stack.Depth == 0 || stack.CurrentFrame.Type != null)
{
stack.PushScope();
// Need to create an XmlnsDictionary.
// Look up stack to see if we have one earlier
// If so, use that. Otherwise new a xmlnsDictionary
WpfXamlFrame iteratorFrame = stack.CurrentFrame;
while (iteratorFrame != null)
{
if (iteratorFrame.XmlnsDictionary != null)
{
stack.CurrentFrame.XmlnsDictionary =
new XmlnsDictionary(iteratorFrame.XmlnsDictionary);
break;
}
iteratorFrame = (WpfXamlFrame)iteratorFrame.Previous;
}
if (stack.CurrentFrame.XmlnsDictionary == null)
{
stack.CurrentFrame.XmlnsDictionary =
new XmlnsDictionary();
}
}
stack.CurrentFrame.XmlnsDictionary.Add(xamlReader.Namespace.Prefix, xamlReader.Namespace.Namespace);
break;
case System.Xaml.XamlNodeType.StartObject:
xamlWriter.WriteNode(xamlReader);
// If there's a frame but no Type, that means there
// was a namespace. Just set the Type
if (stack.Depth != 0 && stack.CurrentFrame.Type == null)
{
stack.CurrentFrame.Type = xamlReader.Type;
}
else
{
// Propagate the FreezeFreezable property from the current stack frame
stack.PushScope();
stack.CurrentFrame.Type = xamlReader.Type;
if (stack.PreviousFrame.FreezeFreezable)
{
stack.CurrentFrame.FreezeFreezable = true;
}
}
break;
case System.Xaml.XamlNodeType.GetObject:
xamlWriter.WriteNode(xamlReader);
// If there wasn't a namespace node before this get object, need to pushScope.
if (stack.CurrentFrame.Type != null)
{
stack.PushScope();
}
stack.CurrentFrame.Type = stack.PreviousFrame.Property.Type;
break;
case System.Xaml.XamlNodeType.EndObject:
xamlWriter.WriteNode(xamlReader);
// Freeze if required
if (stack.CurrentFrame.FreezeFreezable)
{
Freezable freezable = xamlWriter.Result as Freezable;
if (freezable != null && freezable.CanFreeze)
{
freezable.Freeze();
}
}
DependencyObject dependencyObject = xamlWriter.Result as DependencyObject;
if (dependencyObject != null && stack.CurrentFrame.XmlSpace.HasValue)
{
XmlAttributeProperties.SetXmlSpace(dependencyObject, stack.CurrentFrame.XmlSpace.Value ? "default" : "preserve");
}
stack.PopScope();
break;
case System.Xaml.XamlNodeType.StartMember:
// ObjectWriter should NOT process PresentationOptions:Freeze directive since it is Unknown
// The space directive node stream should not be written because it induces object instantiation,
// and the Baml2006Reader can produce space directives prematurely.
if (!(xamlReader.Member.IsDirective && xamlReader.Member == XamlReaderHelper.Freeze) &&
xamlReader.Member != XmlSpace.Value &&
xamlReader.Member != XamlLanguage.Space)
{
xamlWriter.WriteNode(xamlReader);
}
stack.CurrentFrame.Property = xamlReader.Member;
if (skipJournaledProperties)
{
if (!stack.CurrentFrame.Property.IsDirective)
{
System.Windows.Baml2006.WpfXamlMember wpfMember = stack.CurrentFrame.Property as System.Windows.Baml2006.WpfXamlMember;
if (wpfMember != null)
{
DependencyProperty prop = wpfMember.DependencyProperty;
if (prop != null)
{
FrameworkPropertyMetadata metadata = prop.GetMetadata(stack.CurrentFrame.Type.UnderlyingType) as FrameworkPropertyMetadata;
if (metadata != null && metadata.Journal == true)
{
//
int count = 1;
while (xamlReader.Read())
{
switch (xamlReader.NodeType)
{
case System.Xaml.XamlNodeType.StartMember:
count++;
break;
case System.Xaml.XamlNodeType.EndMember:
count--;
if (count == 0)
{
xamlWriter.WriteNode(xamlReader);
}
break;
}
if (count == 0)
{
break;
}
}
// shouldn't this have been a XamlReader.Skip()?
System.Diagnostics.Debug.Assert(count == 0, "Mismatch StartMember/EndMember");
}
}
}
}
}
break;
case System.Xaml.XamlNodeType.EndMember:
WpfXamlFrame currentFrame = stack.CurrentFrame;
XamlMember currentProperty = currentFrame.Property;
// ObjectWriter should not process PresentationOptions:Freeze directive nodes since it is unknown
// The space directive node stream should not be written because it induces object instantiation,
// and the Baml2006Reader can produce space directives prematurely.
if (!(currentProperty.IsDirective && currentProperty == XamlReaderHelper.Freeze) &&
currentProperty != XmlSpace.Value &&
currentProperty != XamlLanguage.Space)
{
xamlWriter.WriteNode(xamlReader);
}
currentFrame.Property = null;
break;
case System.Xaml.XamlNodeType.Value:
if (stack.CurrentFrame.Property.IsDirective && stack.CurrentFrame.Property == XamlLanguage.Shared)
{
bool isShared;
if (bool.TryParse(xamlReader.Value as string, out isShared))
{
if (!isShared)
{
if (!(xamlReader is Baml2006Reader))
{
throw new XamlParseException(SR.Get(SRID.SharedAttributeInLooseXaml));
}
}
}
}
// ObjectWriter should not process PresentationOptions:Freeze directive nodes since it is unknown
if (stack.CurrentFrame.Property.IsDirective && stack.CurrentFrame.Property == XamlReaderHelper.Freeze)
{
bool freeze = Convert.ToBoolean(xamlReader.Value, TypeConverterHelper.InvariantEnglishUS);
stack.CurrentFrame.FreezeFreezable = freeze;
var bamlReader = xamlReader as System.Windows.Baml2006.Baml2006Reader;
if (bamlReader != null)
{
bamlReader.FreezeFreezables = freeze;
}
}
// The space directive node stream should not be written because it induces object instantiation,
// and the Baml2006Reader can produce space directives prematurely.
else if (stack.CurrentFrame.Property == XmlSpace.Value || stack.CurrentFrame.Property == XamlLanguage.Space)
{
if (typeof(DependencyObject).IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType))
{
System.Diagnostics.Debug.Assert(xamlReader.Value is string, "XmlAttributeProperties.XmlSpaceProperty has the type string.");
stack.CurrentFrame.XmlSpace = (string)xamlReader.Value == "default";
}
}
else
{
// Ideally we should check if we're inside FrameworkTemplate's Content and not register those.
// However, checking if the instance is null accomplishes the same with a much smaller perf impact.
if (styleConnector != null &&
stack.CurrentFrame.Instance != null &&
stack.CurrentFrame.Property == XamlLanguage.ConnectionId &&
typeof(Style).IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType))
{
styleConnector.Connect((int)xamlReader.Value, stack.CurrentFrame.Instance);
}
xamlWriter.WriteNode(xamlReader);
}
break;
default:
xamlWriter.WriteNode(xamlReader);
break;
}
//Only do this loop for one node if loadAsync
if (onlyLoadOneNode)
{
return;
}
}
}
static FpsCounterLabel()
{
FrameworkPropertyMetadata fpm = new FrameworkPropertyMetadata(Guid.Empty, FrameworkPropertyMetadataOptions.AffectsRender);
ThrottleProperty = DependencyProperty.Register("Throttle", typeof(Guid), typeof(FpsCounterLabel), fpm);
}
private static BindingMode GetDefaultBindingMode(DependencyObject dependencyObject, DependencyProperty dependencyProperty)
{
FrameworkPropertyMetadata FrameworkPropertyMetadata = dependencyProperty.GetMetadata(dependencyObject.GetType()) as FrameworkPropertyMetadata;
return(FrameworkPropertyMetadata != null && FrameworkPropertyMetadata.BindsTwoWayByDefault ? BindingMode.TwoWay : BindingMode.OneWay);
}
public static DependencyProperty Attach <T>(Type owner, FrameworkPropertyMetadata meta, PropertyValidate <T> validation = null, [CallerMemberName] string autoFieldName = null) => DependencyProperty.RegisterAttached(GetPropertyName(autoFieldName), typeof(T), owner, meta, validation.TryInvoke);
static IPhone()
{
FrameworkPropertyMetadata metadata = new FrameworkPropertyMetadata();
TitleProperty = DependencyProperty.Register("Title", typeof(string), typeof(IPhone), metadata, new ValidateValueCallback(ValidateTitleValue));
}
static TestResultControl()
{
FrameworkPropertyMetadata meta = new FrameworkPropertyMetadata();
ViewModelProperty = DependencyProperty.Register("ViewModel", typeof(TestResultViewModel), typeof(TestResultControl));
}
private static FrameworkPropertyMetadataOptions GetFlags(FrameworkPropertyMetadata fpm)
{
FrameworkPropertyMetadataOptions flags = FrameworkPropertyMetadataOptions.None;
if (fpm.AffectsMeasure)
{
flags |= FrameworkPropertyMetadataOptions.AffectsMeasure;
}
if (fpm.AffectsArrange)
{
flags |= FrameworkPropertyMetadataOptions.AffectsArrange;
}
if (fpm.AffectsParentMeasure)
{
flags |= FrameworkPropertyMetadataOptions.AffectsParentMeasure;
}
if (fpm.AffectsParentArrange)
{
flags |= FrameworkPropertyMetadataOptions.AffectsParentArrange;
}
if (fpm.AffectsRender)
{
flags |= FrameworkPropertyMetadataOptions.AffectsRender;
}
if (fpm.Inherits)
{
flags |= FrameworkPropertyMetadataOptions.Inherits;
}
if (fpm.OverridesInheritanceBehavior)
{
flags |= FrameworkPropertyMetadataOptions.OverridesInheritanceBehavior;
}
if (fpm.IsNotDataBindable)
{
flags |= FrameworkPropertyMetadataOptions.NotDataBindable;
}
if (fpm.BindsTwoWayByDefault)
{
flags |= FrameworkPropertyMetadataOptions.BindsTwoWayByDefault;
}
if (fpm.Journal)
{
flags |= FrameworkPropertyMetadataOptions.Journal;
}
if (fpm.SubPropertiesDoNotAffectRender)
{
flags |= FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender;
}
return(flags);
}
/// <summary>
/// Create a new instance of the <c>DaysEditor</c> class.
/// </summary>
static BarrierCellEditor()
{
var typeofMetadata = new FrameworkPropertyMetadata(typeof(BarrierCellEditor));
DefaultStyleKeyProperty.OverrideMetadata(typeof(BarrierCellEditor), typeofMetadata);
}
static RippleCanvas()
{
var radiusMetadata = new FrameworkPropertyMetadata(OnRadiusChanged);
RadiusProperty = DependencyProperty.Register("Radius", typeof(double), typeof(RippleCanvas), radiusMetadata);
}
static Output()
{
FrameworkPropertyMetadata metadata = new FrameworkPropertyMetadata();
OutputNameProperty = DependencyProperty.RegisterAttached("OutputName", typeof(string), typeof(Output));
}
//</SnippetInitfpm>
static FEGauge()
{
//<SnippetFPMCtor1param>
fpm = new FrameworkPropertyMetadata(Double.NaN);
//</SnippetFPMCtor1param>
//<SnippetFPMCtor1paramcallback>
fpm = new FrameworkPropertyMetadata(new PropertyChangedCallback(OnCurrentReadingChanged));
//</SnippetFPMCtor1paramcallback>
//<SnippetFPMCtor2param>
fpm = new FrameworkPropertyMetadata(
Double.NaN,
new PropertyChangedCallback(OnCurrentReadingChanged)
);
//</SnippetFPMCtor2param>
//<SnippetFPMCtor3param>
fpm = new FrameworkPropertyMetadata(
Double.NaN,
new PropertyChangedCallback(OnCurrentReadingChanged),
new CoerceValueCallback(CoerceCurrentReading)
);
//</SnippetFPMCtor3param>
//<SnippetFPMCtor_DV_FPMO>
fpm = new FrameworkPropertyMetadata(
Double.NaN,
(FrameworkPropertyMetadataOptions.AffectsRender |
FrameworkPropertyMetadataOptions.BindsTwoWayByDefault)
);
//</SnippetFPMCtor_DV_FPMO>
//<SnippetFPMCtor_PCC_CVC>
fpm = new FrameworkPropertyMetadata(
new PropertyChangedCallback(OnCurrentReadingChanged),
new CoerceValueCallback(CoerceCurrentReading)
);
//</SnippetFPMCtor_PCC_CVC>
//<SnippetFPMCtor_DV_FPMO_PCC>
fpm = new FrameworkPropertyMetadata(
Double.NaN,
(FrameworkPropertyMetadataOptions.AffectsRender |
FrameworkPropertyMetadataOptions.BindsTwoWayByDefault),
new PropertyChangedCallback(OnCurrentReadingChanged)
);
//</SnippetFPMCtor_DV_FPMO_PCC>
//<SnippetFPMCtor_DV_FPMO_PCC_CVC>
fpm = new FrameworkPropertyMetadata(
Double.NaN,
(FrameworkPropertyMetadataOptions.AffectsRender |
FrameworkPropertyMetadataOptions.BindsTwoWayByDefault),
new PropertyChangedCallback(OnCurrentReadingChanged),
new CoerceValueCallback(CoerceCurrentReading)
);
//</SnippetFPMCtor_DV_FPMO_PCC_CVC>
//<SnippetFPMCtor_DV_FPMO_PCC_CVC_IAP>
fpm = new FrameworkPropertyMetadata(
Double.NaN,
(FrameworkPropertyMetadataOptions.AffectsRender |
FrameworkPropertyMetadataOptions.BindsTwoWayByDefault),
new PropertyChangedCallback(OnCurrentReadingChanged),
new CoerceValueCallback(CoerceCurrentReading),
true //Animation prohibited
);
//</SnippetFPMCtor_DV_FPMO_PCC_CVC_IAP>
//<SnippetFPMCtor_DV_FPMO_PCC_CVC_IAP_DUST>
fpm = new FrameworkPropertyMetadata(
Double.NaN,
(FrameworkPropertyMetadataOptions.AffectsRender |
FrameworkPropertyMetadataOptions.BindsTwoWayByDefault),
new PropertyChangedCallback(OnCurrentReadingChanged),
new CoerceValueCallback(CoerceCurrentReading),
true //Animation prohibited
, UpdateSourceTrigger.PropertyChanged
);
//</SnippetFPMCtor_DV_FPMO_PCC_CVC_IAP_DUST>
}
static StyleProperties()
{
var metadata = new FrameworkPropertyMetadata((ImageSource)null);
IconImageProperty = DependencyProperty.RegisterAttached("IconImage", typeof(ImageSource), typeof(StyleProperties), metadata);
}
static ToolbarButton()
{
var metadata = new FrameworkPropertyMetadata((ImageSource)null);
ImageSourceProperty = DependencyProperty.RegisterAttached("ImageSource", typeof(ImageSource), typeof(ToolbarButton), metadata);
}
void OnDPSelectionChanged(object sender, SelectionChangedEventArgs e)
{
ListBoxItem selected = (ListBoxItem)e.AddedItems[0]; // we won't handle multiselect
PropertyMetadata pm;
DependencyProperty dp = null;
switch (selected.Content.ToString())
{
case ("ToggleButton.IsChecked"):
dp = ToggleButton.IsCheckedProperty;
break;
case ("Control.Background"):
dp = Control.BackgroundProperty;
break;
case ("Storyboard.TargetName"):
dp = Storyboard.TargetNameProperty;
break;
case ("FrameworkElement.DataContext"):
dp = FrameworkElement.DataContextProperty;
break;
case ("FrameworkElement.Margin"):
dp = FrameworkElement.MarginProperty;
break;
case ("ToolBar.Orientation"):
dp = ToolBar.OrientationProperty;
break;
case ("UIElement.Visibility"):
dp = UIElement.VisibilityProperty;
break;
}
//<SnippetDPProps>
//<SnippetDPGetMetadataSingle>
pm = dp.GetMetadata(dp.OwnerType);
//</SnippetDPGetMetadataSingle>
MetadataClass.Text = pm.GetType().Name;
TypeofPropertyValue.Text = dp.PropertyType.Name;
DefaultPropertyValue.Text = (pm.DefaultValue != null) ? pm.DefaultValue.ToString() : "null";
HasCoerceValue.Text = (pm.CoerceValueCallback == null) ? "No" : pm.CoerceValueCallback.Method.Name;
HasPropertyChanged.Text = (pm.PropertyChangedCallback == null) ? "No" : pm.PropertyChangedCallback.Method.Name;
ReadOnly.Text = (dp.ReadOnly) ? "Yes" : "No";
//</SnippetDPProps>
//<SnippetFPMProperties>
FrameworkPropertyMetadata fpm = pm as FrameworkPropertyMetadata;
if (fpm != null)
{
AffectsArrange.Text = (fpm.AffectsArrange) ? "Yes" : "No";
AffectsMeasure.Text = (fpm.AffectsMeasure) ? "Yes" : "No";
AffectsRender.Text = (fpm.AffectsRender) ? "Yes" : "No";
Inherits.Text = (fpm.Inherits) ? "Yes" : "No";
IsDataBindingAllowed.Text = (fpm.IsDataBindingAllowed) ? "Yes" : "No";
BindsTwoWayByDefault.Text = (fpm.BindsTwoWayByDefault) ? "Yes" : "No";
}
//</SnippetFPMProperties>
else
{
AffectsArrange.Text = "N/A";
AffectsMeasure.Text = "N/A";
AffectsRender.Text = "N/A";
Inherits.Text = "N/A";
IsDataBindingAllowed.Text = "N/A";
BindsTwoWayByDefault.Text = "N/A";
}
//<SnippetDPDefaultValue>
PropertyMetadata pmDefault = dp.DefaultMetadata;
//</SnippetDPDefaultValue>
}
