From ca13f3f5818ebdb9b3bf1b2c48257a7cdec19a15 Mon Sep 17 00:00:00 2001 From: stubbfel Date: Mon, 15 Jul 2013 13:26:47 +0200 Subject: [PATCH] finish #104 --- CampusAppWP8/CampusAppWP8/App.xaml | 1 + CampusAppWP8/CampusAppWP8/CampusAppWP8.csproj | 5 + .../Resources/AppResources.Designer.cs | 20 +- .../CampusAppWP8/Resources/AppResources.resx | 14 +- .../CampusAppWP8/Styles/ListButton.xaml | 10 +- .../CampusAppWP8/Styles/StartPageStyles.xaml | 25 + .../CampusAppWP8/Utility/TiltEffect.cs | 648 ++++++++++++++++++ .../CampusAppWP8/pages/StartPage.xaml | 110 +-- .../CampusAppWP8/pages/StartPage.xaml.cs | 9 + 9 files changed, 780 insertions(+), 62 deletions(-) create mode 100644 CampusAppWP8/CampusAppWP8/Styles/StartPageStyles.xaml create mode 100644 CampusAppWP8/CampusAppWP8/Utility/TiltEffect.cs diff --git a/CampusAppWP8/CampusAppWP8/App.xaml b/CampusAppWP8/CampusAppWP8/App.xaml index 57460a46..5358a12e 100644 --- a/CampusAppWP8/CampusAppWP8/App.xaml +++ b/CampusAppWP8/CampusAppWP8/App.xaml @@ -11,6 +11,7 @@ + diff --git a/CampusAppWP8/CampusAppWP8/CampusAppWP8.csproj b/CampusAppWP8/CampusAppWP8/CampusAppWP8.csproj index 755f5d02..735540fb 100644 --- a/CampusAppWP8/CampusAppWP8/CampusAppWP8.csproj +++ b/CampusAppWP8/CampusAppWP8/CampusAppWP8.csproj @@ -216,6 +216,7 @@ + @@ -290,6 +291,10 @@ MSBuild:Compile Designer + + MSBuild:Compile + Designer + Designer MSBuild:Compile diff --git a/CampusAppWP8/CampusAppWP8/Resources/AppResources.Designer.cs b/CampusAppWP8/CampusAppWP8/Resources/AppResources.Designer.cs index 68a90e99..d7c1c526 100644 --- a/CampusAppWP8/CampusAppWP8/Resources/AppResources.Designer.cs +++ b/CampusAppWP8/CampusAppWP8/Resources/AppResources.Designer.cs @@ -1,7 +1,7 @@ //------------------------------------------------------------------------------ // // Dieser Code wurde von einem Tool generiert. -// Laufzeitversion:4.0.30319.18046 +// Laufzeitversion:4.0.30319.18051 // // Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn // der Code erneut generiert wird. @@ -177,6 +177,15 @@ namespace CampusAppWP8.Resources { } } + /// + /// Sucht eine lokalisierte Zeichenfolge, die Haus- aufgaben ähnelt. + /// + public static string HomeworkApp_Title2 { + get { + return ResourceManager.GetString("HomeworkApp_Title2", resourceCulture); + } + } + /// /// Sucht eine lokalisierte Zeichenfolge, die Studiengang ähnelt. /// @@ -447,6 +456,15 @@ namespace CampusAppWP8.Resources { } } + /// + /// Sucht eine lokalisierte Zeichenfolge, die Öffnungs- zeiten ähnelt. + /// + public static string OpenHoursApp_Title2 { + get { + return ResourceManager.GetString("OpenHoursApp_Title2", resourceCulture); + } + } + /// /// Sucht eine lokalisierte Zeichenfolge, die Fachschaften ähnelt. /// diff --git a/CampusAppWP8/CampusAppWP8/Resources/AppResources.resx b/CampusAppWP8/CampusAppWP8/Resources/AppResources.resx index eac8d920..eb67220a 100644 --- a/CampusAppWP8/CampusAppWP8/Resources/AppResources.resx +++ b/CampusAppWP8/CampusAppWP8/Resources/AppResources.resx @@ -149,8 +149,8 @@ Events - - Hausaufgaben + + Haus- aufgaben Vorlesungen @@ -167,8 +167,8 @@ News - - Öffnungszeiten + + Öffnungs- zeiten Fachschaften @@ -293,4 +293,10 @@ allg. Links + + Hausaufgaben + + + Öffnungszeiten + \ No newline at end of file diff --git a/CampusAppWP8/CampusAppWP8/Styles/ListButton.xaml b/CampusAppWP8/CampusAppWP8/Styles/ListButton.xaml index b356d6a7..a5fc5adc 100644 --- a/CampusAppWP8/CampusAppWP8/Styles/ListButton.xaml +++ b/CampusAppWP8/CampusAppWP8/Styles/ListButton.xaml @@ -2,11 +2,13 @@ xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" + xmlns:tilt="clr-namespace:CampusAppWP8.Utility" mc:Ignorable="d"> \ No newline at end of file diff --git a/CampusAppWP8/CampusAppWP8/Styles/StartPageStyles.xaml b/CampusAppWP8/CampusAppWP8/Styles/StartPageStyles.xaml new file mode 100644 index 00000000..51c57f07 --- /dev/null +++ b/CampusAppWP8/CampusAppWP8/Styles/StartPageStyles.xaml @@ -0,0 +1,25 @@ + + + + + \ No newline at end of file diff --git a/CampusAppWP8/CampusAppWP8/Utility/TiltEffect.cs b/CampusAppWP8/CampusAppWP8/Utility/TiltEffect.cs new file mode 100644 index 00000000..db78de32 --- /dev/null +++ b/CampusAppWP8/CampusAppWP8/Utility/TiltEffect.cs @@ -0,0 +1,648 @@ +/* + Copyright (c) 2010 Microsoft Corporation. All rights reserved. + Use of this sample source code is subject to the terms of the Microsoft license + agreement under which you licensed this sample source code and is provided AS-IS. + If you did not accept the terms of the license agreement, you are not authorized + to use this sample source code. For the terms of the license, please see the + license agreement between you and Microsoft. +*/ + + +using System; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Input; +using System.Windows.Media; +using System.Windows.Media.Animation; +using System.Collections.Generic; +using System.Windows.Controls.Primitives; + + +#if WINDOWS_PHONE +using Microsoft.Phone.Controls; +#endif + +namespace CampusAppWP8.Utility +{ + /// + /// This code provides attached properties for adding a 'tilt' effect to all controls within a container. + /// + public class TiltEffect : DependencyObject + { + + #region Constructor and Static Constructor + /// + /// This is not a constructable class, but it cannot be static because it derives from DependencyObject. + /// + private TiltEffect() + { + } + + /// + /// Initialize the static properties + /// + static TiltEffect() + { + // The tiltable items list. + TiltableItems = new List() { typeof(ButtonBase), typeof(ListBoxItem), }; + UseLogarithmicEase = false; + } + + #endregion + + + #region Fields and simple properties + + // These constants are the same as the built-in effects + /// + /// Maximum amount of tilt, in radians + /// + const double MaxAngle = 0.3; + + /// + /// Maximum amount of depression, in pixels + /// + const double MaxDepression = 25; + + /// + /// Delay between releasing an element and the tilt release animation playing + /// + static readonly TimeSpan TiltReturnAnimationDelay = TimeSpan.FromMilliseconds(200); + + /// + /// Duration of tilt release animation + /// + static readonly TimeSpan TiltReturnAnimationDuration = TimeSpan.FromMilliseconds(100); + + /// + /// The control that is currently being tilted + /// + static FrameworkElement currentTiltElement; + + /// + /// The single instance of a storyboard used for all tilts + /// + static Storyboard tiltReturnStoryboard; + + /// + /// The single instance of an X rotation used for all tilts + /// + static DoubleAnimation tiltReturnXAnimation; + + /// + /// The single instance of a Y rotation used for all tilts + /// + static DoubleAnimation tiltReturnYAnimation; + + /// + /// The single instance of a Z depression used for all tilts + /// + static DoubleAnimation tiltReturnZAnimation; + + /// + /// The center of the tilt element + /// + static Point currentTiltElementCenter; + + /// + /// Whether the animation just completed was for a 'pause' or not + /// + static bool wasPauseAnimation = false; + + /// + /// Whether to use a slightly more accurate (but slightly slower) tilt animation easing function + /// + public static bool UseLogarithmicEase { get; set; } + + /// + /// Default list of items that are tiltable + /// + public static List TiltableItems { get; private set; } + + #endregion + + + #region Dependency properties + + /// + /// Whether the tilt effect is enabled on a container (and all its children) + /// + public static readonly DependencyProperty IsTiltEnabledProperty = DependencyProperty.RegisterAttached( + "IsTiltEnabled", + typeof(bool), + typeof(TiltEffect), + new PropertyMetadata(OnIsTiltEnabledChanged) + ); + + /// + /// Gets the IsTiltEnabled dependency property from an object + /// + /// The object to get the property from + /// The property's value + public static bool GetIsTiltEnabled(DependencyObject source) { return (bool)source.GetValue(IsTiltEnabledProperty); } + + /// + /// Sets the IsTiltEnabled dependency property on an object + /// + /// The object to set the property on + /// The value to set + public static void SetIsTiltEnabled(DependencyObject source, bool value) { source.SetValue(IsTiltEnabledProperty, value); } + + /// + /// Suppresses the tilt effect on a single control that would otherwise be tilted + /// + public static readonly DependencyProperty SuppressTiltProperty = DependencyProperty.RegisterAttached( + "SuppressTilt", + typeof(bool), + typeof(TiltEffect), + null + ); + + /// + /// Gets the SuppressTilt dependency property from an object + /// + /// The object to get the property from + /// The property's value + public static bool GetSuppressTilt(DependencyObject source) { return (bool)source.GetValue(SuppressTiltProperty); } + + /// + /// Sets the SuppressTilt dependency property from an object + /// + /// The object to get the property from + /// The property's value + public static void SetSuppressTilt(DependencyObject source, bool value) { source.SetValue(SuppressTiltProperty, value); } + + + /// + /// Property change handler for the IsTiltEnabled dependency property + /// + /// The element that the property is atteched to + /// Event args + /// + /// Adds or removes event handlers from the element that has been (un)registered for tilting + /// + static void OnIsTiltEnabledChanged(DependencyObject target, DependencyPropertyChangedEventArgs args) + { + if (target is FrameworkElement) + { + // Add / remove the event handler if necessary + if ((bool)args.NewValue == true) + { + (target as FrameworkElement).ManipulationStarted += TiltEffect_ManipulationStarted; + } + else + { + (target as FrameworkElement).ManipulationStarted -= TiltEffect_ManipulationStarted; + } + } + } + + #endregion + + + #region Top-level manipulation event handlers + + /// + /// Event handler for ManipulationStarted + /// + /// sender of the event - this will be the tilt container (eg, entire page) + /// event args + static void TiltEffect_ManipulationStarted(object sender, ManipulationStartedEventArgs e) + { + + TryStartTiltEffect(sender as FrameworkElement, e); + } + + /// + /// Event handler for ManipulationDelta + /// + /// sender of the event - this will be the tilting object (eg a button) + /// event args + static void TiltEffect_ManipulationDelta(object sender, ManipulationDeltaEventArgs e) + { + + ContinueTiltEffect(sender as FrameworkElement, e); + } + + /// + /// Event handler for ManipulationCompleted + /// + /// sender of the event - this will be the tilting object (eg a button) + /// event args + static void TiltEffect_ManipulationCompleted(object sender, ManipulationCompletedEventArgs e) + { + + EndTiltEffect(currentTiltElement); + } + + #endregion + + + #region Core tilt logic + + /// + /// Checks if the manipulation should cause a tilt, and if so starts the tilt effect + /// + /// The source of the manipulation (the tilt container, eg entire page) + /// The args from the ManipulationStarted event + static void TryStartTiltEffect(FrameworkElement source, ManipulationStartedEventArgs e) + { + foreach (FrameworkElement ancestor in (e.OriginalSource as FrameworkElement).GetVisualAncestors()) + { + foreach (Type t in TiltableItems) + { + if (t.IsAssignableFrom(ancestor.GetType())) + { + if ((bool)ancestor.GetValue(SuppressTiltProperty) != true) + { + // Use first child of the control, so that you can add transforms and not + // impact any transforms on the control itself + FrameworkElement element = VisualTreeHelper.GetChild(ancestor, 0) as FrameworkElement; + FrameworkElement container = e.ManipulationContainer as FrameworkElement; + + if (element == null || container == null) + return; + + // Touch point relative to the element being tilted + Point tiltTouchPoint = container.TransformToVisual(element).Transform(e.ManipulationOrigin); + + // Center of the element being tilted + Point elementCenter = new Point(element.ActualWidth / 2, element.ActualHeight / 2); + + // Camera adjustment + Point centerToCenterDelta = GetCenterToCenterDelta(element, source); + + BeginTiltEffect(element, tiltTouchPoint, elementCenter, centerToCenterDelta); + return; + } + } + } + } + } + + /// + /// Computes the delta between the centre of an element and its container + /// + /// The element to compare + /// The element to compare against + /// A point that represents the delta between the two centers + static Point GetCenterToCenterDelta(FrameworkElement element, FrameworkElement container) + { + Point elementCenter = new Point(element.ActualWidth / 2, element.ActualHeight / 2); + Point containerCenter; + +#if WINDOWS_PHONE + + // Need to special-case the frame to handle different orientations + if (container is PhoneApplicationFrame) + { + PhoneApplicationFrame frame = container as PhoneApplicationFrame; + + // Switch width and height in landscape mode + if ((frame.Orientation & PageOrientation.Landscape) == PageOrientation.Landscape) + { + + containerCenter = new Point(container.ActualHeight / 2, container.ActualWidth / 2); + } + else + containerCenter = new Point(container.ActualWidth / 2, container.ActualHeight / 2); + } + else + containerCenter = new Point(container.ActualWidth / 2, container.ActualHeight / 2); +#else + + containerCenter = new Point(container.ActualWidth / 2, container.ActualHeight / 2); + +#endif + + Point transformedElementCenter = element.TransformToVisual(container).Transform(elementCenter); + Point result = new Point(containerCenter.X - transformedElementCenter.X, containerCenter.Y - transformedElementCenter.Y); + + return result; + } + + /// + /// Begins the tilt effect by preparing the control and doing the initial animation + /// + /// The element to tilt + /// The touch point, in element coordinates + /// The center point of the element in element coordinates + /// The delta between the 's center and + /// the container's center + static void BeginTiltEffect(FrameworkElement element, Point touchPoint, Point centerPoint, Point centerDelta) + { + + + if (tiltReturnStoryboard != null) + StopTiltReturnStoryboardAndCleanup(); + + if (PrepareControlForTilt(element, centerDelta) == false) + return; + + currentTiltElement = element; + currentTiltElementCenter = centerPoint; + PrepareTiltReturnStoryboard(element); + + ApplyTiltEffect(currentTiltElement, touchPoint, currentTiltElementCenter); + } + + /// + /// Prepares a control to be tilted by setting up a plane projection and some event handlers + /// + /// The control that is to be tilted + /// Delta between the element's center and the tilt container's + /// true if successful; false otherwise + /// + /// This method is conservative; it will fail any attempt to tilt a control that already + /// has a projection on it + /// + static bool PrepareControlForTilt(FrameworkElement element, Point centerDelta) + { + // Prevents interference with any existing transforms + if (element.Projection != null || (element.RenderTransform != null && element.RenderTransform.GetType() != typeof(MatrixTransform))) + return false; + + TranslateTransform transform = new TranslateTransform(); + transform.X = centerDelta.X; + transform.Y = centerDelta.Y; + element.RenderTransform = transform; + + PlaneProjection projection = new PlaneProjection(); + projection.GlobalOffsetX = -1 * centerDelta.X; + projection.GlobalOffsetY = -1 * centerDelta.Y; + element.Projection = projection; + + element.ManipulationDelta += TiltEffect_ManipulationDelta; + element.ManipulationCompleted += TiltEffect_ManipulationCompleted; + + return true; + } + + /// + /// Removes modifications made by PrepareControlForTilt + /// + /// THe control to be un-prepared + /// + /// This method is basic; it does not do anything to detect if the control being un-prepared + /// was previously prepared + /// + static void RevertPrepareControlForTilt(FrameworkElement element) + { + element.ManipulationDelta -= TiltEffect_ManipulationDelta; + element.ManipulationCompleted -= TiltEffect_ManipulationCompleted; + element.Projection = null; + element.RenderTransform = null; + } + + /// + /// Creates the tilt return storyboard (if not already created) and targets it to the projection + /// + /// the projection that should be the target of the animation + static void PrepareTiltReturnStoryboard(FrameworkElement element) + { + + if (tiltReturnStoryboard == null) + { + tiltReturnStoryboard = new Storyboard(); + tiltReturnStoryboard.Completed += TiltReturnStoryboard_Completed; + + tiltReturnXAnimation = new DoubleAnimation(); + Storyboard.SetTargetProperty(tiltReturnXAnimation, new PropertyPath(PlaneProjection.RotationXProperty)); + tiltReturnXAnimation.BeginTime = TiltReturnAnimationDelay; + tiltReturnXAnimation.To = 0; + tiltReturnXAnimation.Duration = TiltReturnAnimationDuration; + + tiltReturnYAnimation = new DoubleAnimation(); + Storyboard.SetTargetProperty(tiltReturnYAnimation, new PropertyPath(PlaneProjection.RotationYProperty)); + tiltReturnYAnimation.BeginTime = TiltReturnAnimationDelay; + tiltReturnYAnimation.To = 0; + tiltReturnYAnimation.Duration = TiltReturnAnimationDuration; + + tiltReturnZAnimation = new DoubleAnimation(); + Storyboard.SetTargetProperty(tiltReturnZAnimation, new PropertyPath(PlaneProjection.GlobalOffsetZProperty)); + tiltReturnZAnimation.BeginTime = TiltReturnAnimationDelay; + tiltReturnZAnimation.To = 0; + tiltReturnZAnimation.Duration = TiltReturnAnimationDuration; + + if (UseLogarithmicEase) + { + tiltReturnXAnimation.EasingFunction = new LogarithmicEase(); + tiltReturnYAnimation.EasingFunction = new LogarithmicEase(); + tiltReturnZAnimation.EasingFunction = new LogarithmicEase(); + } + + tiltReturnStoryboard.Children.Add(tiltReturnXAnimation); + tiltReturnStoryboard.Children.Add(tiltReturnYAnimation); + tiltReturnStoryboard.Children.Add(tiltReturnZAnimation); + } + + Storyboard.SetTarget(tiltReturnXAnimation, element.Projection); + Storyboard.SetTarget(tiltReturnYAnimation, element.Projection); + Storyboard.SetTarget(tiltReturnZAnimation, element.Projection); + } + + + /// + /// Continues a tilt effect that is currently applied to an element, presumably because + /// the user moved their finger + /// + /// The element being tilted + /// The manipulation event args + static void ContinueTiltEffect(FrameworkElement element, ManipulationDeltaEventArgs e) + { + FrameworkElement container = e.ManipulationContainer as FrameworkElement; + if (container == null || element == null) + return; + + Point tiltTouchPoint = container.TransformToVisual(element).Transform(e.ManipulationOrigin); + + // If touch moved outside bounds of element, then pause the tilt (but don't cancel it) + if (new Rect(0, 0, currentTiltElement.ActualWidth, currentTiltElement.ActualHeight).Contains(tiltTouchPoint) != true) + { + + PauseTiltEffect(); + return; + } + + // Apply the updated tilt effect + ApplyTiltEffect(currentTiltElement, e.ManipulationOrigin, currentTiltElementCenter); + } + + /// + /// Ends the tilt effect by playing the animation + /// + /// The element being tilted + static void EndTiltEffect(FrameworkElement element) + { + if (element != null) + { + element.ManipulationCompleted -= TiltEffect_ManipulationCompleted; + element.ManipulationDelta -= TiltEffect_ManipulationDelta; + } + + if (tiltReturnStoryboard != null) + { + wasPauseAnimation = false; + if (tiltReturnStoryboard.GetCurrentState() != ClockState.Active) + tiltReturnStoryboard.Begin(); + } + else + StopTiltReturnStoryboardAndCleanup(); + } + + /// + /// Handler for the storyboard complete event + /// + /// sender of the event + /// event args + static void TiltReturnStoryboard_Completed(object sender, EventArgs e) + { + if (wasPauseAnimation) + ResetTiltEffect(currentTiltElement); + else + StopTiltReturnStoryboardAndCleanup(); + } + + /// + /// Resets the tilt effect on the control, making it appear 'normal' again + /// + /// The element to reset the tilt on + /// + /// This method doesn't turn off the tilt effect or cancel any current + /// manipulation; it just temporarily cancels the effect + /// + static void ResetTiltEffect(FrameworkElement element) + { + PlaneProjection projection = element.Projection as PlaneProjection; + projection.RotationY = 0; + projection.RotationX = 0; + projection.GlobalOffsetZ = 0; + } + + /// + /// Stops the tilt effect and release resources applied to the currently-tilted control + /// + static void StopTiltReturnStoryboardAndCleanup() + { + if (tiltReturnStoryboard != null) + tiltReturnStoryboard.Stop(); + + RevertPrepareControlForTilt(currentTiltElement); + } + + /// + /// Pauses the tilt effect so that the control returns to the 'at rest' position, but doesn't + /// stop the tilt effect (handlers are still attached, etc.) + /// + static void PauseTiltEffect() + { + if ((tiltReturnStoryboard != null) && !wasPauseAnimation) + { + tiltReturnStoryboard.Stop(); + wasPauseAnimation = true; + tiltReturnStoryboard.Begin(); + } + } + + /// + /// Resets the storyboard to not running + /// + private static void ResetTiltReturnStoryboard() + { + tiltReturnStoryboard.Stop(); + wasPauseAnimation = false; + } + + /// + /// Applies the tilt effect to the control + /// + /// the control to tilt + /// The touch point, in the container's coordinates + /// The center point of the container + static void ApplyTiltEffect(FrameworkElement element, Point touchPoint, Point centerPoint) + { + // Stop any active animation + ResetTiltReturnStoryboard(); + + // Get relative point of the touch in percentage of container size + Point normalizedPoint = new Point( + Math.Min(Math.Max(touchPoint.X / (centerPoint.X * 2), 0), 1), + Math.Min(Math.Max(touchPoint.Y / (centerPoint.Y * 2), 0), 1)); + + // Shell values + double xMagnitude = Math.Abs(normalizedPoint.X - 0.5); + double yMagnitude = Math.Abs(normalizedPoint.Y - 0.5); + double xDirection = -Math.Sign(normalizedPoint.X - 0.5); + double yDirection = Math.Sign(normalizedPoint.Y - 0.5); + double angleMagnitude = xMagnitude + yMagnitude; + double xAngleContribution = xMagnitude + yMagnitude > 0 ? xMagnitude / (xMagnitude + yMagnitude) : 0; + + double angle = angleMagnitude * MaxAngle * 180 / Math.PI; + double depression = (1 - angleMagnitude) * MaxDepression; + + // RotationX and RotationY are the angles of rotations about the x- or y-*axis*; + // to achieve a rotation in the x- or y-*direction*, we need to swap the two. + // That is, a rotation to the left about the y-axis is a rotation to the left in the x-direction, + // and a rotation up about the x-axis is a rotation up in the y-direction. + PlaneProjection projection = element.Projection as PlaneProjection; + projection.RotationY = angle * xAngleContribution * xDirection; + projection.RotationX = angle * (1 - xAngleContribution) * yDirection; + projection.GlobalOffsetZ = -depression; + } + + #endregion + + + #region Custom easing function + + /// + /// Provides an easing function for the tilt return + /// + private class LogarithmicEase : EasingFunctionBase + { + /// + /// Computes the easing function + /// + /// The time + /// The eased value + protected override double EaseInCore(double normalizedTime) + { + return Math.Log(normalizedTime + 1) / 0.693147181; // ln(t + 1) / ln(2) + } + } + + #endregion + } + + /// + /// Couple of simple helpers for walking the visual tree + /// + static class TreeHelpers + { + /// + /// Gets the ancestors of the element, up to the root + /// + /// The element to start from + /// An enumerator of the ancestors + public static IEnumerable GetVisualAncestors(this FrameworkElement node) + { + FrameworkElement parent = node.GetVisualParent(); + while (parent != null) + { + yield return parent; + parent = parent.GetVisualParent(); + } + } + + /// + /// Gets the visual parent of the element + /// + /// The element to check + /// The visual parent + public static FrameworkElement GetVisualParent(this FrameworkElement node) + { + return VisualTreeHelper.GetParent(node) as FrameworkElement; + } + } +} + diff --git a/CampusAppWP8/CampusAppWP8/pages/StartPage.xaml b/CampusAppWP8/CampusAppWP8/pages/StartPage.xaml index ee5f7207..f3c7d82c 100644 --- a/CampusAppWP8/CampusAppWP8/pages/StartPage.xaml +++ b/CampusAppWP8/CampusAppWP8/pages/StartPage.xaml @@ -28,7 +28,7 @@ - + @@ -43,90 +43,94 @@ - - + + - + - - - - - - - - - + + - + + + + + + + + - - - - - - - - - - - - - - - + + - + + + + + + + + + + + + + + + - - + + - + - - - - + + + + - - + + - + - - + + - + - - - - - - - - - + + - + + + + + + + + + + + diff --git a/CampusAppWP8/CampusAppWP8/pages/StartPage.xaml.cs b/CampusAppWP8/CampusAppWP8/pages/StartPage.xaml.cs index f5cc8301..2f286a93 100644 --- a/CampusAppWP8/CampusAppWP8/pages/StartPage.xaml.cs +++ b/CampusAppWP8/CampusAppWP8/pages/StartPage.xaml.cs @@ -39,26 +39,35 @@ namespace CampusAppWP8.Pages { OpenHoursAppButton.SetValue(Grid.RowProperty, 0); OpenHoursAppButton.SetValue(Grid.ColumnProperty, 3); + OpenHoursAppButtonText.Text = AppResources.OpenHoursApp_Title; OSAAppButton.SetValue(Grid.RowProperty, 1); OSAAppButton.SetValue(Grid.ColumnProperty, 3); LinkAppButton.SetValue(Grid.RowProperty, 2); LinkAppButton.SetValue(Grid.ColumnProperty, 3); + ContentPanel.Margin = new Thickness(12, -24, 0, 0); + + HomeworkAppButtonText.Text = AppResources.HomeworkApp_Title; } else { // If not in portrait, move buttonList content to visible row and column. + ContentPanel.Margin = new Thickness(12, 0, 12, 12); OpenHoursAppButton.SetValue(Grid.RowProperty, 3); OpenHoursAppButton.SetValue(Grid.ColumnProperty, 0); + OpenHoursAppButtonText.Text = AppResources.OpenHoursApp_Title2; OSAAppButton.SetValue(Grid.RowProperty, 3); OSAAppButton.SetValue(Grid.ColumnProperty, 1); LinkAppButton.SetValue(Grid.RowProperty, 3); LinkAppButton.SetValue(Grid.ColumnProperty, 2); + ContentPanel.Margin = new Thickness(12, 0, 0, 0); + + HomeworkAppButtonText.Text = AppResources.HomeworkApp_Title2; } } }