private static void FocusCore(FrameworkElement element)
{
//System.Diagnostics.Debug.WriteLine("Focusing element " + element.ToString());
//System.Diagnostics.Debug.WriteLine(Environment.StackTrace);
if (!element.Focus())
{
//System.Diagnostics.Debug.WriteLine("- Element could not be focused, invoking in dispatcher thread");
element.Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(() => element.Focus()));
}
#if DEBUG
// no good idea, seems to block sometimes
int i = 0;
while (i < 5)
{
if (element.IsFocused)
{
//if (i > 0)
// System.Diagnostics.Debug.WriteLine("- Element is focused now in round " + i + ", leaving");
return;
}
Thread.Sleep(20);
i++;
}
//if (i >= 5)
//{
// System.Diagnostics.Debug.WriteLine("- Element is not focused after 500 ms, giving up");
//}
#endif
}
public static void UpdateImageSource(FrameworkElement content, Grid hostBody, ImageSource imageSource, Stretch stretch)
{
if (hostBody == null || content == null)
return;
var imgRects = hostBody.Children.OfType<Rectangle>().ToArray();
for (int i = imgRects.Count() - 1; i >= 0; i--)
{
hostBody.Children.Remove(imgRects[i]);
}
if (imageSource == null)
return;
var imgBrush = new ImageBrush { ImageSource = imageSource, Stretch = stretch };
var imgRect = new Rectangle
{
OpacityMask = imgBrush
};
hostBody.Children.Add(imgRect);
ApplyForegroundToFillBinding(content, imgRect);
//var sb = new Storyboard();
//ControlHelper.CreateDoubleAnimations(sb, imgBrush, "Opacity", 0.2, 1, 75);
//hostBody.Dispatcher.BeginInvoke(sb.Begin);
}
protected override void ValidateTemplatedParent(FrameworkElement templatedParent)
{
if (templatedParent == null)
throw new ArgumentNullException("templatedParent");
if (_TargetType != null && !_TargetType.IsInstanceOfType(templatedParent))
throw new ArgumentException("Template target type mismatch.");
}
/// <summary>
/// Remove the ViewModel from the View's DataContext
/// </summary>
/// <param name="frameworkElement"></param>
/// <param name="viewModel"></param>
public void UnbindViewModelFromView(FrameworkElement frameworkElement, object viewModel)
{
if (frameworkElement.DataContext == viewModel)
{
frameworkElement.DataContext = null;
}
}
private static void CheckArgument(FrameworkElement element)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
}
public Helper(FrameworkElement obj, DependencyProperty property, Action<object, object> changed, object currentValue)
{
this.obj = obj;
this.property = property;
this.changed = changed;
this.currentValue = currentValue;
}
public override IEnumerable<Timeline> CreateAnimation(FrameworkElement element)
{
double startRotation = 0.0;
double endRotation;
if (StartRotation.HasValue)
startRotation = StartRotation.Value;
else
{
var compositeTransform = element.RenderTransform as CompositeTransform;
if (compositeTransform != null)
startRotation = compositeTransform.Rotation;
}
if (EndRotation.HasValue)
endRotation = EndRotation.Value;
else
endRotation = startRotation + 360.0;
return new Timeline[]
{
element.AnimatePointProperty(AnimationProperty.RenderTransformOrigin)
.AddDiscreteKeyFrame(0.0, new Point(0.5, 0.5)),
element.AnimateProperty(AnimationProperty.Rotation)
.AddEasingKeyFrame(0.0, startRotation)
.AddEasingKeyFrame(Duration, endRotation, Easing)
.AddDiscreteKeyFrame(Duration, startRotation),
};
}
internal static void AddError (FrameworkElement element, ValidationError error)
{
var errors = GetErrorsCore (element);
errors.Add (error);
if (errors.Count == 1)
SetHasError (element, true);
}
/*!
* Initializes this calibration element
* @param rotationElement the element that rotates (can have children that travel with it)
* @param element the element that is touched to begin rotation, will track the finger
* @param the outer ring image
* @param the middle ring image
* @param the inner ring image
* @param sphero the sphero that will be calibrated
*/
public CalibrateElement(
FrameworkElement rotationElement,
FrameworkElement element,
FrameworkElement ringOuter,
FrameworkElement ringMiddle,
FrameworkElement ringInner,
FrameworkElement fingerPoint,
RobotKit.Robot sphero) {
m_sphero = (RobotKit.Sphero)sphero;
m_calibrateRotationRoot = rotationElement;
m_calibrateElement = element;
m_calibrateElement.PointerPressed += OnPointerPressed;
m_calibrateElement.PointerMoved += OnPointerMoved;
m_calibrateElement.PointerReleased += OnPointerReleased;
m_calibrateElement.PointerCaptureLost += OnPointerReleased;
m_calibrateElement.PointerCanceled += OnPointerReleased;
m_ringOuter = ringOuter;
m_ringMiddle = ringMiddle;
m_ringInner = ringInner;
m_fingerPoint = fingerPoint;
SetupRotation();
m_lastCommandSentTimeMs = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
}
/// <summary>Initializes the view model and registers events so that the OnLoaded and OnUnloaded methods are called.
/// This method must be called in the constructor after the <see cref="InitializeComponent"/> method call. </summary>
/// <param name="viewModel">The view model. </param>
/// <param name="view">The view. </param>
public static void RegisterViewModel(ViewModelBase viewModel, FrameworkElement view)
{
viewModel.Initialize();
view.Loaded += (sender, args) => viewModel.CallOnLoaded();
view.Unloaded += (sender, args) => viewModel.CallOnUnloaded();
}
/// <summary>
/// Called when template should be applied to the control
/// </summary>
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
_elementHorizontalTemplateFrameworkElement = this.GetTemplateChild(PreviewControl.ElementHorizontalTemplateName) as FrameworkElement;
_elementVerticalTemplateFrameworkElement = this.GetTemplateChild(PreviewControl.ElementVerticalTemplateName) as FrameworkElement;
if (_currentGridResizeDirection == GridSplitter.GridResizeDirection.Columns)
{
if (_elementHorizontalTemplateFrameworkElement != null)
{
_elementHorizontalTemplateFrameworkElement.Visibility = Visibility.Collapsed;
}
if (_elementVerticalTemplateFrameworkElement != null)
{
_elementVerticalTemplateFrameworkElement.Visibility = Visibility.Visible;
}
}
else
{
if (_elementHorizontalTemplateFrameworkElement != null)
{
_elementHorizontalTemplateFrameworkElement.Visibility = Visibility.Visible;
}
if (_elementVerticalTemplateFrameworkElement != null)
{
_elementVerticalTemplateFrameworkElement.Visibility = Visibility.Collapsed;
}
}
}
public DataGridCellEditingCancelEventArgs(DataGridColumnBase dataGridColumn,
DataGridRow dataGridRow,
FrameworkElement element,
DataGridEditingTriggerInfo editingTriggerInfo) : base(dataGridColumn, dataGridRow, element)
{
this.EditingTriggerInfo = editingTriggerInfo;
}
public override IEnumerable<Timeline> CreateAnimation(FrameworkElement element)
{
return new Timeline[]
{
element.AnimateProperty(AnimationProperty.Opacity)
.AddDiscreteKeyFrame(0.0, 1),
element.AnimateProperty(AnimationProperty.Rotation)
.AddDiscreteKeyFrame(0.0, 0),
element.AnimateProperty(AnimationProperty.TranslateX)
.AddDiscreteKeyFrame(0.0, 0),
element.AnimateProperty(AnimationProperty.TranslateY)
.AddDiscreteKeyFrame(0.0, 0),
element.AnimateProperty(AnimationProperty.ScaleX)
.AddDiscreteKeyFrame(0.0, 1),
element.AnimateProperty(AnimationProperty.ScaleY)
.AddDiscreteKeyFrame(0.0, 1),
element.AnimateProperty(AnimationProperty.RotationX)
.AddDiscreteKeyFrame(0.0, 0),
element.AnimateProperty(AnimationProperty.RotationY)
.AddDiscreteKeyFrame(0.0, 0),
element.AnimateProperty(AnimationProperty.RotationZ)
.AddDiscreteKeyFrame(0.0, 0),
element.AnimatePointProperty(AnimationProperty.RenderTransformOrigin)
.AddDiscreteKeyFrame(0.0, new Point(0.5, 0.5)),
};
}
public override IEnumerable<Timeline> CreateAnimation(FrameworkElement element)
{
var transform = GetTransform(element);
var animations = new List<Timeline>();
if (Math.Abs(DistanceY) > 0.001)
animations.Add(
element.AnimateProperty(AnimationProperty.TranslateY)
.AddEasingKeyFrame(0.0, transform.TranslateY)
.AddEasingKeyFrame(Duration * 0.2, transform.TranslateY)
.AddEasingKeyFrame(Duration * 0.4, transform.TranslateY + DistanceY)
.AddEasingKeyFrame(Duration * 0.5, transform.TranslateY)
.AddEasingKeyFrame(Duration * 0.6, transform.TranslateY + (DistanceY / 2))
.AddEasingKeyFrame(Duration * 0.8, transform.TranslateY)
.AddEasingKeyFrame(Duration, transform.TranslateY)
);
if (Math.Abs(DistanceX) > 0.001)
animations.Add(
element.AnimateProperty(AnimationProperty.TranslateX)
.AddEasingKeyFrame(0.0, transform.TranslateX)
.AddEasingKeyFrame(Duration * 0.2, transform.TranslateX)
.AddEasingKeyFrame(Duration * 0.4, transform.TranslateX + DistanceX)
.AddEasingKeyFrame(Duration * 0.5, transform.TranslateX)
.AddEasingKeyFrame(Duration * 0.6, transform.TranslateX + (DistanceX / 2))
.AddEasingKeyFrame(Duration * 0.8, transform.TranslateX)
.AddEasingKeyFrame(Duration, transform.TranslateX)
);
return animations;
}
public void Resume(FrameworkElement target)
{
if (Storyboard != null)
{
Storyboard.Pause(target);
}
}
public void Remove(FrameworkElement target, INameScope nameScope, object layerOwner)
{
if (Storyboard != null)
{
Storyboard.Remove(target, nameScope, layerOwner);
}
}
public void SkipToFill(FrameworkElement target)
{
if (Storyboard != null)
{
Storyboard.SkipToFill(target);
}
}
public override IEnumerable<Timeline> CreateAnimation(FrameworkElement element)
{
var transform = GetTransform(element);
return new Timeline[]
{
element.AnimatePointProperty(AnimationProperty.RenderTransformOrigin)
.AddDiscreteKeyFrame(0.0, new Point(0, 1)),
element.AnimateProperty(AnimationProperty.Opacity)
.AddEasingKeyFrame(0.0, 0)
.AddEasingKeyFrame(Duration*0.6, 1),
element.AnimateProperty(AnimationProperty.TranslateX)
.AddEasingKeyFrame(0.0, transform.TranslateX + 700)
.AddEasingKeyFrame(Duration*0.6, transform.TranslateX - 30, new QuadraticEase())
.AddEasingKeyFrame(Duration*0.8, transform.TranslateX),
element.AnimateProperty(AnimationProperty.SkewX)
.AddEasingKeyFrame(0.0, -30)
.AddEasingKeyFrame(Duration*0.6, 30)
.AddEasingKeyFrame(Duration*0.8, -15)
.AddEasingKeyFrame(Duration, 0),
};
}
public virtual void SetupEffect(FrameworkElement parent, ref PositionColoredTextured[] verts, float zOrder, bool adaptVertsToBrushTexture)
{
if (!UpdateBounds(ref verts))
return;
float w = _vertsBounds.Width;
float h = _vertsBounds.Height;
float xoff = _vertsBounds.X;
float yoff = _vertsBounds.Y;
if (adaptVertsToBrushTexture)
for (int i = 0; i < verts.Length; i++)
{
PositionColoredTextured vert = verts[i];
float x = vert.X;
float u = x - xoff;
u /= w;
float y = vert.Y;
float v = y - yoff;
v /= h;
if (u < 0) u = 0;
if (u > 1) u = 1;
if (v < 0) v = 0;
if (v > 1) v = 1;
unchecked
{
Color4 color = ColorConverter.FromColor(Color.White);
vert.Color = color.ToBgra();
}
vert.Tu1 = u;
vert.Tv1 = v;
vert.Z = zOrder;
verts[i] = vert;
}
}
/// <summary>
/// if the view model implements the IParentDataContextAwareViewModel interface then the parents view will be disconnected.
/// </summary>
/// <param name="frameworkElement"></param>
/// <param name="viewModel"></param>
public void UnbindViewModelFromView(FrameworkElement frameworkElement, object viewModel)
{
if (viewModel is IParentDataContextAwareViewModel)
{
frameworkElement.Loaded -= InjectParentDataContextOnload;
}
}
public override IEnumerable<Timeline> CreateAnimation(FrameworkElement element)
{
var transform = GetTransform(element);
var list = new List<Timeline>
{
element.AnimateProperty(AnimationProperty.Opacity)
.AddEasingKeyFrame(0.0, 0)
.AddEasingKeyFrame(Duration, 1),
};
if (Math.Abs(DistanceX) > 0)
{
list.Add(
element.AnimateProperty(AnimationProperty.TranslateX)
.AddEasingKeyFrame(0.0, transform.TranslateX + DistanceX)
.AddEasingKeyFrame(Duration, transform.TranslateX, new CubicEase()));
}
if (Math.Abs(DistanceY) > 0)
{
list.Add(
element.AnimateProperty(AnimationProperty.TranslateY)
.AddEasingKeyFrame(0.0, transform.TranslateY + DistanceY)
.AddEasingKeyFrame(Duration, transform.TranslateY, new CubicEase()));
}
return list;
}
public static void UpdateClipSize(FrameworkElement element, Size clipSize)
{
if (element != null)
{
RectangleGeometry clipRectangle = null;
if (element.Clip == null)
{
clipRectangle = new RectangleGeometry();
element.Clip = clipRectangle;
}
else
{
if (element.Clip is RectangleGeometry)
{
clipRectangle = (RectangleGeometry)element.Clip;
}
}
if (clipRectangle != null)
{
clipRectangle.Rect = new Rect(new Point(0, 0), clipSize);
}
}
}
/// <summary>
/// Goes to specified visual state, waiting for the transition to complete.
/// </summary>
/// <param name="control">
/// Control to transition.
/// </param>
/// <param name="visualStatesHost">
/// FrameworkElement that defines the visual states
/// (usually the root of the control's template).
/// </param>
/// <param name="stateGroupName">
/// Name of the state group
/// (speeds up the search for the state transition storyboard).
/// </param>
/// <param name="stateName">
/// State to transition to.
/// </param>
/// <returns>
/// Awaitable task that completes when the transition storyboard completes.
/// </returns>
/// <remarks>
/// If a state transition storyboard is not found - the task
/// completes immediately.
/// </remarks>
public static async Task GoToVisualStateAsync(
this Control control,
FrameworkElement visualStatesHost,
string stateGroupName,
string stateName)
{
var tcs = new TaskCompletionSource<Storyboard>();
var storyboard = GetStoryboardForVisualState(visualStatesHost, stateGroupName, stateName);
if (storyboard != null)
{
EventHandler eh = null;
eh = (s, e) =>
{
storyboard.Completed -= eh;
tcs.SetResult(storyboard);
};
storyboard.Completed += eh;
}
VisualStateManager.GoToState(control, stateName, true);
if (storyboard == null)
{
return;
}
await tcs.Task;
}
public static SetterValueBindingHelper GetPropertyBinding(FrameworkElement element)
{
if (null == element)
{
throw new ArgumentNullException("element");
}
return (SetterValueBindingHelper)element.GetValue(PropertyBindingProperty);
}
/// <summary>
/// Unbind the view model loaded events
/// </summary>
/// <param name="frameworkElement"></param>
/// <param name="viewModel"></param>
public void UnbindViewModelFromView(FrameworkElement frameworkElement, object viewModel)
{
if (viewModel is ILoadedAwareViewModel)
{
frameworkElement.Loaded -= ViewModelOnLoaded;
frameworkElement.Unloaded -= ViewModelOnUnloaded;
}
}
private ParentObserver(FrameworkElement view)
{
_view = ServiceProvider.WeakReferenceFactory(view);
_parent = ToolkitExtensions.GetWeakReferenceOrDefault(FindParent(view), Empty.WeakReference, false);
RoutedEventHandler handler = OnChanged;
view.Loaded += handler;
view.Unloaded += handler;
}
protected override void ApplyBindings(FrameworkElement attachedObject,
IEnumerable<MvxBindingDescription> bindingDescriptions)
{
var binder = MvxBindingSingletonCache.Instance.Binder;
var bindingDescriptionList = bindingDescriptions.ToList();
var bindings = binder.Bind(attachedObject.DataContext, attachedObject, bindingDescriptionList);
RegisterBindingsForUpdates(attachedObject, bindings);
}
public DependencyPropertyRegistration(FrameworkElement frameworkElement, DependencyProperty dependencyProperty, Action<object, object> propertyChangedCallback, object currentValue)
{
FrameworkElement = frameworkElement;
DependencyProperty = dependencyProperty;
PropertyChangedCallback = propertyChangedCallback;
_currentValue = currentValue;
}
/// <summary>
/// Causes the column cell being edited to revert to the specified value.
/// </summary>
/// <param name="editingElement">
/// The element that the column displays for a cell in editing mode.
/// </param>
/// <param name="uneditedValue">
/// The previous, unedited value in the cell being edited.
/// </param>
protected override void CancelCellEdit(FrameworkElement editingElement, object uneditedValue)
{
CheckBox editingCheckBox = editingElement as CheckBox;
if (editingCheckBox != null)
{
editingCheckBox.IsChecked = (bool?)uneditedValue;
}
}
/// <summary>
/// Parse metadata from a target FrameworkElement. This will cache the metadata on the element as an attached property.
/// </summary>
/// <param name="element">The target FrameworkElement to pull metadata from.</param>
/// <param name="forceUpdate">If set, will not pull metadata from cache.</param>
/// <param name="entity">The entity used.</param>
/// <param name="bindingExpression">The bindingExpression used.</param>
/// <returns>Returns the metadata associated with the element. Will be null if no metadata was found.</returns>
internal static ValidationMetadata ParseMetadata(FrameworkElement element, bool forceUpdate, out object entity, out BindingExpression bindingExpression)
{
entity = null;
bindingExpression = null;
if (element == null)
{
return null;
}
if (!forceUpdate)
{
ValidationMetadata existingVMD = element.GetValue(ValidationMetadataProperty) as ValidationMetadata;
if (existingVMD != null)
{
return existingVMD;
}
}
BindingExpression be = null;
FieldInfo[] fields = element.GetType().GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
foreach (FieldInfo field in fields)
{
if (field.FieldType == typeof(DependencyProperty))
{
// Found a dependency property
be = element.GetBindingExpression((DependencyProperty)field.GetValue(null));
if (be != null && be.ParentBinding != null && be.ParentBinding.Path != null)
{
// Found a BindingExpression, ensure it has valid data
entity = be.DataItem != null ? be.DataItem : element.DataContext;
if (entity != null)
{
if (be.ParentBinding.Mode == BindingMode.TwoWay)
{
bindingExpression = be;
// A twoway binding will be automatically chosen and the rest ignored
break;
}
// Perform an arbitrary sort on path (string), so the same dependency property is chosen consistently.
// Reflection ordering is not deterministic and if we just pick the first, we could be
// matched with different dependency properties depending on the run.
if (bindingExpression == null || string.Compare(be.ParentBinding.Path.Path, bindingExpression.ParentBinding.Path.Path, StringComparison.Ordinal) < 0)
{
bindingExpression = be;
}
}
}
}
}
if (bindingExpression != null)
{
ValidationMetadata newVMD = ParseMetadata(bindingExpression.ParentBinding.Path.Path, entity);
element.SetValue(ValidationMetadataProperty, newVMD);
return newVMD;
}
return null;
}
private async void Grid_Loading(FrameworkElement sender, object args)
{
createContacts();
loadContacts();
}
public static Size ArrangeElementWithSingleChild(FrameworkElement element, Size arrangeSize)
{
return(ArrangeElementWithSingleChild(element, arrangeSize, new Point(0, 0)));
}
private CutTooltipBehavior(FrameworkElement owner)
{
_owner = owner;
}
void AddNativeControls(NestedNativeControlGalleryPage page)
{
if (page.NativeControlsAdded)
{
return;
}
StackLayout sl = page.Layout;
// Create and add a native TextBlock
var originalText = "I am a native TextBlock";
var textBlock = new TextBlock
{
Text = originalText,
FontSize = 14,
FontFamily = new FontFamily("HelveticaNeue")
};
sl?.Children.Add(textBlock);
// Create and add a native Button
var button = new Windows.UI.Xaml.Controls.Button {
Content = "Toggle Font Size", Height = 80
};
button.Click += (sender, args) => { textBlock.FontSize = textBlock.FontSize == 14 ? 24 : 14; };
sl?.Children.Add(button.ToView());
// Create a control which we know doesn't behave correctly with regard to measurement
var difficultControl = new BrokenNativeControl
{
Text = "Not Sized/Arranged Properly"
};
var difficultControl2 = new BrokenNativeControl
{
Text = "Fixed"
};
// Add the misbehaving controls, one with a custom delegate for ArrangeOverrideDelegate
sl?.Children.Add(difficultControl);
sl?.Children.Add(difficultControl2,
arrangeOverrideDelegate: (renderer, finalSize) =>
{
if (finalSize.Width <= 0 || double.IsInfinity(finalSize.Width))
{
return(null);
}
FrameworkElement frameworkElement = renderer.Control;
frameworkElement.Measure(finalSize);
// The broken control always tries to size itself to the screen width
// So figure that out and we'll know how far off it's laying itself out
WRect bounds = ApplicationView.GetForCurrentView().VisibleBounds;
double scaleFactor = DisplayInformation.GetForCurrentView().RawPixelsPerViewPixel;
var screenWidth = new Size(bounds.Width * scaleFactor, bounds.Height * scaleFactor);
// We can re-center it by offsetting it during the Arrange call
double diff = Math.Abs(screenWidth.Width - finalSize.Width) / -2;
frameworkElement.Arrange(new WRect(diff, 0, finalSize.Width - diff, finalSize.Height));
// Arranging the control to the left will make it show up past the edge of the stack layout
// We can fix that by clipping it manually
var clip = new RectangleGeometry {
Rect = new WRect(-diff, 0, finalSize.Width, finalSize.Height)
};
frameworkElement.Clip = clip;
return(finalSize);
}
);
page.NativeControlsAdded = true;
}
public static FrameworkElement GetRoot(FrameworkElement element)
{
return(FindRoot(element) as FrameworkElement);
}
public static FrameworkElement FindElementByType(FrameworkElement treeRoot, Type type)
{
return(FindElement(treeRoot, element => element.GetType() == type));
}
Point GetElementPositionRelatedToPopup(FrameworkElement element)
{
return(element.TransformToVisual(this).TransformPoint(new Point()));
}
public static T FindElementByType <T>(FrameworkElement treeRoot) where T : FrameworkElement
{
return((T)FindElementByType(treeRoot, typeof(T)));
}
protected override object PrepareCellForEdit(FrameworkElement editingElement, RoutedEventArgs editingEventArgs)
{
return(null);
}
private static FrameworkElement FindTemplatedParent(FrameworkElement parent)
{
return(parent.TemplatedParent as FrameworkElement);
}
public static bool TryFindNearestStatefulControl(FrameworkElement contextElement, out FrameworkElement resolvedControl)
{
FrameworkElement frameworkElement = contextElement;
if (frameworkElement == null)
{
// TODO: should we throw an exception here? Tracked as spec issue 82282.
resolvedControl = null;
return(false);
}
// Try to find an element which is the immediate child of a UserControl, ControlTemplate or other such "boundary" element
FrameworkElement parent = frameworkElement.Parent as FrameworkElement;
bool succesfullyResolved = true;
// bubble up looking for a place to stop
while (!HasVisualStateGroupsDefined(frameworkElement) && ShouldContinueTreeWalk(parent))
{
frameworkElement = parent;
parent = parent.Parent as FrameworkElement;
}
if (HasVisualStateGroupsDefined(frameworkElement))
{
if ((frameworkElement.TemplatedParent != null) && (frameworkElement.TemplatedParent is Control))
{
// We didn't need to walk the tree to get this because TemplatedParent is set for all elements in the
// template. However, it maintains consistency in our error checking to do it this way.
frameworkElement = frameworkElement.TemplatedParent as FrameworkElement;
}
else if (parent != null && parent is UserControl)
{
// if our parent is a UserControl, then use that
frameworkElement = parent;
}
}
else
{
succesfullyResolved = false;
}
resolvedControl = frameworkElement;
return(succesfullyResolved);
}
private static bool HasVisualStateGroupsDefined(FrameworkElement frameworkElement)
{
return(frameworkElement != null && VisualStateManager.GetVisualStateGroups(frameworkElement).Count != 0);
}
/// <summary>
/// Creates a new <see cref="T:System.Windows.Controls.UIElementCollection"/>.
/// </summary>
/// <param name="logicalParent">The logical parent element of the collection to be created.</param>
/// <returns>
/// An ordered collection of elements that have the specified logical parent.
/// </returns>
protected sealed override UIElementCollection CreateUIElementCollection(FrameworkElement logicalParent)
{
children = new UIChildrenCollection(this, logicalParent);
return(children);
}
protected override bool CommitCellEdit(FrameworkElement editingElement)
{
return(true);
}
public static FrameworkElement Render(AdaptiveColumnSet columnSet, AdaptiveRenderContext context)
{
var uiColumnSet = new Grid();
uiColumnSet.Style = context.GetStyle($"Adaptive.{columnSet.Type}");
// Keep track of ContainerStyle.ForegroundColors before Container is rendered
var outerStyle = context.ForegroundColors;
var parentContainerStyle = context.ParentStyle;
if (columnSet.Style != null)
{
AdaptiveContainerRenderer.ApplyPadding(uiColumnSet, columnSet, parentContainerStyle, context);
// Apply background color
var columnSetStyle = context.Config.ContainerStyles.GetContainerStyleConfig(columnSet.Style);
uiColumnSet.SetBackgroundColor(columnSetStyle.BackgroundColor, context);
context.ForegroundColors = columnSetStyle.ForegroundColors;
}
AdaptiveContainerStyle columnSetContainerStyle = columnSet.Style ?? parentContainerStyle;
if (columnSetContainerStyle == AdaptiveContainerStyle.None)
{
columnSetContainerStyle = parentContainerStyle;
}
context.ParentStyle = columnSetContainerStyle;
foreach (var column in columnSet.Columns)
{
FrameworkElement uiContainer = context.Render(column);
// Add vertical Seperator
if (uiColumnSet.ColumnDefinitions.Count > 0)
{
if (column.Separator || column.Spacing != AdaptiveSpacing.None)
{
var uiSep = new Grid();
uiSep.Style = context.GetStyle($"Adaptive.VerticalSeparator");
uiSep.VerticalAlignment = VerticalAlignment.Stretch;
int spacing = context.Config.GetSpacing(column.Spacing);
uiSep.Margin = new Thickness(spacing / 2.0, 0, spacing / 2.0, 0);
uiSep.Width = context.Config.Separator.LineThickness;
if (column.Separator && context.Config.Separator.LineColor != null)
{
uiSep.Background = context.GetColorBrush(context.Config.Separator.LineColor);
}
uiColumnSet.ColumnDefinitions.Add(new ColumnDefinition()
{
Width = GridLength.Auto
});
Grid.SetColumn(uiSep, uiColumnSet.ColumnDefinitions.Count - 1);
uiColumnSet.Children.Add(uiSep);
}
}
// do some sizing magic using the magic GridUnitType.Star
var width = column.Width?.ToLower();
if (string.IsNullOrEmpty(width))
#pragma warning disable CS0618 // Type or member is obsolete
{
width = column.Size?.ToLower();
}
#pragma warning restore CS0618 // Type or member is obsolete
if (width == null || width == AdaptiveColumnWidth.Stretch.ToLower())
{
uiColumnSet.ColumnDefinitions.Add(new ColumnDefinition()
{
Width = new GridLength(1, GridUnitType.Star)
});
}
else if (width == AdaptiveColumnWidth.Auto.ToLower())
{
uiColumnSet.ColumnDefinitions.Add(new ColumnDefinition()
{
Width = GridLength.Auto
});
}
else
{
if (double.TryParse(width, out double val) && val >= 0)
{
// Weighted proportion (number only)
uiColumnSet.ColumnDefinitions.Add(new ColumnDefinition()
{
Width = new GridLength(val, GridUnitType.Star)
});
}
else if (width.EndsWith("px") && double.TryParse(width.Substring(0, width.Length - 2), out double pxVal) && pxVal >= 0)
{
// Exact pixel (number followed by "px")
uiColumnSet.ColumnDefinitions.Add(new ColumnDefinition()
{
Width = new GridLength((int)pxVal, GridUnitType.Pixel)
});
}
else
{
uiColumnSet.ColumnDefinitions.Add(new ColumnDefinition()
{
Width = GridLength.Auto
});
}
}
Grid.SetColumn(uiContainer, uiColumnSet.ColumnDefinitions.Count - 1);
uiColumnSet.Children.Add(uiContainer);
}
if (columnSet.SelectAction != null)
{
return(context.RenderSelectAction(columnSet.SelectAction, uiColumnSet));
}
if (!columnSet.IsVisible)
{
uiColumnSet.Visibility = Visibility.Collapsed;
}
// Revert context's value to that of outside the Container
context.ForegroundColors = outerStyle;
context.ParentStyle = parentContainerStyle;
return(uiColumnSet);
}
protected override void CancelCellEdit(FrameworkElement editingElement, object uneditedValue)
{
}
private void Rotary_ManipulationStarting(object sender, ManipulationStartingRoutedEventArgs e)
{
FrameworkElement element = sender as FrameworkElement;
e.Pivot = new ManipulationPivot(element.Center(), element.ActualWidth / 2.0);
}
/// <summary>
/// Called when child is added.
/// </summary>
/// <param name="child">The added child.</param>
protected internal virtual void OnChildAdded(FrameworkElement child)
{
}
public static FrameworkElement FindElementByName(FrameworkElement treeRoot, string name)
{
return(FindElement(treeRoot, element => element.Name == name));
}
private static void UnsubscribeFromEvents(FrameworkElement element)
{
DragDropManager.RemoveDragInitializeHandler(element, OnElementDragInitialize);
DragDropManager.RemoveDragDropCompletedHandler(element, OnElementDragDropCompleted);
element.Unloaded -= OnElementUnloaded;
}
/// <summary>
/// The animation method that is fired when the value changes
/// </summary>
/// <param name="element">The element</param>
/// <param name="value">The new value</param>
protected virtual void DoAnimation(FrameworkElement element, bool value)
{
}
/// <summary>
/// Assume adornments can't have their own adornments.
/// </summary>
/// <param name="selelt"></param>
/// <param name="templ"></param>
/// <returns></returns>
public override Adornment MakeAdornment(FrameworkElement selelt, DataTemplate templ)
{
return(null);
}
public WidthService(TextBlock tblTitle, TextBlock tblArtist, ColumnDefinition cdSong, FrameworkElement slider)
{
this.tblTitle = tblTitle;
this.tblArtist = tblArtist;
this.cdSong = cdSong;
this.slider = slider;
var tblDPD = DependencyPropertyDescriptor.FromProperty(TextBlock.TextProperty, typeof(TextBlock));
tblDPD.AddValueChanged(tblTitle, OnReset);
tblDPD.AddValueChanged(tblArtist, OnReset);
var cdDPD = DependencyPropertyDescriptor.FromProperty(FrameworkElement.ActualWidthProperty, typeof(FrameworkElement));
cdDPD.AddValueChanged(slider, OnUpdate);
}
/// <summary>Construct FeatureLayerFromLocalGeodatabase sample control</summary>
public FeatureLayerFromShapefile()
{
InitializeComponent();
_featureOverlay = MyMapView.Overlays.Items[0] as FrameworkElement;
MyMapView.MapViewTapped += MyMapView_MapViewTapped;
}
public override DataTemplate SelectTemplate(object item, DependencyObject container)
{
FrameworkElement element = container as FrameworkElement;
return((DataTemplate)element.FindResource("DataTempate_Normal"));
}
public void BeginAnimateScore(double newValue, FrameworkElement parent)
{
if (newValue != this.CurrentValue)
{
lock (this)
{
if (newValue != this.CurrentValue)
{
var boostTransparentAnimation = new DoubleAnimation(newValue, BoostDuration)
{
EasingFunction = EasingFunction
};
Storyboard.SetTargetName(boostTransparentAnimation, this.boostBarTransparentStopName);
Storyboard.SetTargetProperty(boostTransparentAnimation, new PropertyPath(GradientStop.OffsetProperty));
var boostStopAnimation = new DoubleAnimation(newValue, BoostDuration)
{
EasingFunction = EasingFunction
};
Storyboard.SetTargetName(boostStopAnimation, this.boostBarBlackStopName);
Storyboard.SetTargetProperty(boostStopAnimation, new PropertyPath(GradientStop.OffsetProperty));
var scoreTransparentAnimation = new DoubleAnimation(newValue, ScoreDuration)
{
EasingFunction = EasingFunction
};
Storyboard.SetTargetName(scoreTransparentAnimation, this.scoreBarTransparentStopName);
Storyboard.SetTargetProperty(scoreTransparentAnimation, new PropertyPath(GradientStop.OffsetProperty));
var scoreStopAnimation = new DoubleAnimation(newValue, ScoreDuration)
{
EasingFunction = EasingFunction
};
Storyboard.SetTargetName(scoreStopAnimation, this.scoreBarBlackStopName);
Storyboard.SetTargetProperty(scoreStopAnimation, new PropertyPath(GradientStop.OffsetProperty));
if (newValue > this.CurrentValue)
{
boostStopAnimation.BeginTime = BoostStopDelayDuration;
scoreTransparentAnimation.BeginTime = ScoreStartDelayDuration;
scoreStopAnimation.BeginTime = ScoreStartDelayDuration + ScoreStopDelayDuration;
}
else
{
scoreTransparentAnimation.BeginTime = BoostStopDelayDuration;
boostStopAnimation.BeginTime = ScoreStartDelayDuration;
boostTransparentAnimation.BeginTime = ScoreStartDelayDuration + ScoreStopDelayDuration;
}
var storyboard = new Storyboard();
storyboard.Children.Add(boostTransparentAnimation);
storyboard.Children.Add(boostStopAnimation);
storyboard.Children.Add(scoreTransparentAnimation);
storyboard.Children.Add(scoreStopAnimation);
storyboard.Begin(parent);
this.CurrentValue = newValue;
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AnimationItem" /> class.
/// </summary>
/// <param name="element">The element.</param>
/// <param name="animation">The animation.</param>
public AnimationItem(FrameworkElement element, AnimationTimeline animation)
{
this.Element = element;
this.Animation = animation;
}
private static void ParseRectangle(FrameworkElement element)
{
_currentObject.AddRenderableElement(new RenderableRectangle(element));
}
public static bool IsPointInsideElementBounds(Point position, FrameworkElement element, Thickness margin)
{
Rect rect = new Rect(-margin.Left, -margin.Top, element.ActualWidth + margin.Right + margin.Left, element.ActualHeight + margin.Bottom + margin.Top);
return(rect.Contains(position));
}
/// <summary>
/// Set the Icon to the underlying TrayIcon.Icon
/// </summary>
public void SetIcon(FrameworkElement value)
{
var taskbarIcon = TrayIcon as FrameworkElement;
taskbarIcon?.SetCurrentValue(FrameworkElementIcon.ValueProperty, value);
}
