WPF

<Grid xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Name="themeGrid">
    <Image Height="Auto" HorizontalAlignment="Left" Margin="0" Stretch="Fill" VerticalAlignment="Top" Width="Auto">
        <Image.Source>
            <BitmapImage UriSource="pack://siteoforigin:,,,/Resources/image1.jpg" CacheOption="OnLoad" />
        </Image.Source>
    </Image>
</Grid>

Imports System.IO
Class MainWindow
    Private Sub MainWindow_Loaded(sender As Object, e As System.Windows.RoutedEventArgs) Handles Me.Loaded
        loadInterface()
    End Sub
    Sub loadInterface()
        ' Load xaml file as content of the window
        Dim GridUri As String = System.AppDomain.CurrentDomain.BaseDirectory & "Resources\theme.xaml"
        Dim fs As FileStream = New FileStream(GridUri, FileMode.Open, FileAccess.Read)
        Dim sri = TryCast(System.Windows.Markup.XamlReader.Load(fs), Grid)
        Me.Content = sri
        fs.Close()
    End Sub
End Class

<Grid xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Name="themeGrid">
    <Image Height="Auto" HorizontalAlignment="Left" Margin="0" Stretch="Fill" VerticalAlignment="Top" Width="Auto">
        <Image.Source>
            <BitmapImage UriSource="pack://siteoforigin:,,,/Resources/image1.jpg" CacheOption="OnLoad" />
        </Image.Source>
    </Image>
    <Label FontFamily="pack://siteoforigin:,,,/Resources/#Digital-7" Content="Have a nice day!"/>
</Grid>

<Frame x:Name="_home"     NavigationUIVisibility="Hidden" HorizontalAlignment="Stretch"   Width="2749" Margin="0,12,0,0"   />

(Application.Current.MainWindow.FindName("_home") as Frame).Source = new Uri("/F1.xaml", UriKind.Relative);

<pre lang="c#">private void btnCalculate_Click(object sender, RoutedEventArgs e)
 {
     F1 f1 = new F1();
     f1.CalculateYear();
 }</pre>

using System;
using System.Windows;
using System.Windows.Media;
using System.ComponentModel;
using System.Windows.Input;

namespace WpfPrismTests
{

    public class CanvasPoint : FrameworkElement, INotifyPropertyChanged
    {

        private VisualCollection _children;

        #region "Constructors"
        public CanvasPoint()
        {
            _children = new VisualCollection(this);
            _children.Add(CreateDrawingVisualCircle());

        }

        protected override void OnMouseEnter(MouseEventArgs e)
        {
            base.OnMouseEnter(e);
        }

        public CanvasPoint(Point p_position)
        {
            PositionOnCanvas = p_position;

            _children = new VisualCollection(this);
            _children.Add(CreateDrawingVisualCircle());
        }
        #endregion

        private DrawingVisual CreateDrawingVisualCircle()
        {
            DrawingVisual drawingVisual = new DrawingVisual();

            // Retrieve the DrawingContext in order to create new drawing content.
            DrawingContext drawingContext = drawingVisual.RenderOpen();

            // Create a circle and draw it in the DrawingContext.
            drawingContext.DrawEllipse(BackgroundColor, new Pen(BackgroundColor, 1.0), PositionOnCanvas, 4, 4);

            // Persist the drawing content.
            drawingContext.Close();

            return drawingVisual;
        }

        #region "Dependency Properties"

        public static DependencyProperty ShowContentProperty = DependencyProperty.Register("ShowContent",
            typeof(bool), typeof(CanvasPoint), new PropertyMetadata(false, OnShowContentPropertyChanged));

        public bool ShowContent
        {
            get
            {
                return (bool)this.GetValue(ShowContentProperty);
            }
            set
            {
                this.SetValue(ShowContentProperty, value);
            }
        }

        private static void OnShowContentPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            bool value = (bool)e.NewValue;
            CanvasPoint thisElement = d as CanvasPoint;
            if (value)
            {
                thisElement.AddLogicalChild(thisElement.Content);
            }
            else
            {
                thisElement.RemoveLogicalChild(thisElement.Content);
            }

        }

        private static FrameworkPropertyMetadata ContentMetadata =
                      new FrameworkPropertyMetadata(null,
                               FrameworkPropertyMetadataOptions.BindsTwoWayByDefault);

        public static readonly DependencyProperty ContentProperty =
            DependencyProperty.RegisterAttached("Content", typeof(UIElement),
                typeof(CanvasPoint), ContentMetadata);

        public UIElement Content
        {
            get
            {
                return (UIElement)this.GetValue(ContentProperty);
            }
            set
            {
                this.SetValue(ContentProperty, value);
            }
        }

        #endregion

        #region "Properties"

        private Point p_PositionOnCanvas = new Point();
        public Point PositionOnCanvas
        {
            get { return p_PositionOnCanvas; }
            set
            {
                p_PositionOnCanvas = value;
                INotifyChange("PositionOnCanvas");
            }
        }

        private SolidColorBrush pBackgoundColor = Brushes.Red;
        public SolidColorBrush BackgroundColor
        {
            get { return pBackgoundColor; }
            set
            {
                pBackgoundColor = value;

                _children.Clear();
                _children = new VisualCollection(this);
                _children.Add(CreateDrawingVisualCircle());
            }
        }
        #endregion

        #region "Overided properties"

        // Provide a required override for the VisualChildrenCount property.
        protected override int VisualChildrenCount
        {

            get
            {
                if (this.ShowContent)
                {
                    UIElement childElement = (UIElement)GetValue(ContentProperty);
                    return childElement != null ? 1 : 0;
                }
                else
                {
                    return _children.Count;
                }
            }
        }

        // Provide a required override for the GetVisualChild method.
        protected override Visual GetVisualChild(int index)
        {
            if (this.ShowContent)
            {
                return (UIElement)GetValue(ContentProperty);
            }
            else
            {
                if (index < 0 || index >= _children.Count)
                {
                    throw new ArgumentOutOfRangeException();
                }

                return _children[index];
            }
        }

        protected override Size MeasureOverride(Size availableSize)
        {
            UIElement childElement = (UIElement)GetValue(ContentProperty);
            if (childElement != null)
                childElement.Measure(availableSize);

            return availableSize;
        }

        protected override Size ArrangeOverride(Size finalSize)
        {
            UIElement childElement = (UIElement)GetValue(ContentProperty);
            if (childElement != null)
            {
                Rect ChildSize = new Rect(new Point(0, 0), finalSize);
                double CenterX = ChildSize.Width / 2;
                double CenterY = ChildSize.Height / 2;
                childElement.Arrange(new Rect(new Point(-CenterX + PositionOnCanvas.X, -CenterY + PositionOnCanvas.Y), finalSize));
            }

            return finalSize;
        }


        #endregion

        public event PropertyChangedEventHandler PropertyChanged;

        protected void INotifyChange(string name)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null)
            {
                handler(this, new PropertyChangedEventArgs(name));
            }
        }

    }
}

protected override Size ArrangeOverride(Size finalSize)
{
    UIElement childElement = (UIElement)GetValue(ContentProperty);
    if (childElement != null)
    {
        Rect ChildSize = new Rect(new Point(0, 0), finalSize);
        double CenterX = ChildSize.Width / 2;
        double CenterY = ChildSize.Height / 2;
        childElement.Arrange(new Rect(new Point(-CenterX + PositionOnCanvas.X, -CenterY + PositionOnCanvas.Y), finalSize));
    }

    return finalSize;
}

using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;


public class MyCanvas : Canvas
{
    public static DependencyProperty ItemsSourceProperty =
        DependencyProperty.Register("ItemsSource",
        typeof(IEnumerable), typeof(MyCanvas),

        new FrameworkPropertyMetadata((IEnumerable)null,
            new PropertyChangedCallback(OnItemsSourcePropertyChanged)));

    private static Dictionary<INotifyCollectionChanged, MyCanvas> references = new Dictionary<INotifyCollectionChanged, MyCanvas>();

    public IEnumerable ItemsSource
    {
        get
        {
            return (IEnumerable)this.GetValue(ItemsSourceProperty);
        }
        set
        {
            this.SetValue(ItemsSourceProperty, value);
        }
    }

    private static void OnItemsSourcePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var canvas = d as MyCanvas;
        repopulateChildren(canvas);


        if (canvas.ItemsSource is CompositeCollection)
        {
            CompositeCollection CollectionHolder = ((CompositeCollection)canvas.ItemsSource);

                foreach (CollectionContainer item in CollectionHolder)
            {

                ObservableCollection<UIElement> elements = (ObservableCollection<UIElement>)item.Collection;
                references.Add((elements as INotifyCollectionChanged), canvas);
                elements.CollectionChanged -= collectionChangedHandler;
                elements.CollectionChanged += collectionChangedHandler;
            }

        }
        else if (canvas.ItemsSource is IEnumerable<UIElement>)
        {
            var be = BindingOperations.GetBindingExpression(canvas, MyCanvas.ItemsSourceProperty);

            if (be != null)
            {
                var elements = (be.ResolvedSourcePropertyName == null ? be.ResolvedSource :
                    be.ResolvedSource.GetType().GetProperty(be.ResolvedSourcePropertyName).GetValue(be.ResolvedSource)) as INotifyCollectionChanged;

                if (elements != null)
                {
                    var cv = references.FirstOrDefault(i => i.Value == canvas);
                    if (!cv.Equals(default(KeyValuePair<INotifyCollectionChanged, MyCanvas>)))
                        references.Remove(cv.Key);


                    references[elements] = canvas;
                    elements.CollectionChanged -= collectionChangedHandler;
                    elements.CollectionChanged += collectionChangedHandler;
                }
            }
            else references.Clear();

        }

    }

    private static void collectionChangedHandler(object sender, NotifyCollectionChangedEventArgs e)
    {
        
        MyCanvas cv;

        if (references.TryGetValue(sender as INotifyCollectionChanged, out cv))
        {

            switch (e.Action)
        {
            case NotifyCollectionChangedAction.Add:
                foreach (var item in e.NewItems) cv.Children.Add(item as UIElement);
                break;
            case NotifyCollectionChangedAction.Remove:
                {
                    foreach (var item in e.OldItems)
                    {
                        cv.Children.Remove(item as UIElement);
                    }

                    break;
                }

            case NotifyCollectionChangedAction.Reset:
                repopulateChildren(cv);
                break;
        }
        }
    }


    public static DependencyProperty PerservedChildrenProperty = DependencyProperty.Register("PerservedChildren", typeof(int), typeof(MyCanvas), new PropertyMetadata(0));

    public int PerservedChildren
    {
        get
        {
            return (int)this.GetValue(PerservedChildrenProperty);
        }
        set
        {
            this.SetValue(PerservedChildrenProperty, value);
        }
    }

    private static void repopulateChildren(MyCanvas cv)
    {


        for (int i = cv.Children.Count - 1; i >= cv.PerservedChildren; i--)
        {
            cv.Children.RemoveAt(i);
        }

        var elements = (IEnumerable)cv.GetValue(ItemsSourceProperty );

        if (elements is CompositeCollection)
        {
            CompositeCollection CollectionHost = ((CompositeCollection)elements);
            foreach (CollectionContainer item in CollectionHost)
            {

                foreach (UIElement pp in item.Collection)
                {
                    if (!(cv.Children.Contains(pp)))
                        cv.Children.Add(pp);
                }
            }
        }
        else if (elements is IEnumerable<UIElement>)
        {
            foreach (UIElement elem in elements)
            {
                cv.Children.Add(elem);
            }
        }

    }

}

//Part 1 -- its not Getting updated 
           Status.Background = new SolidColorBrush(Colors.Orange);
            Status.Content = "Exporting, please wait...";

       //Part 2 is working
           Logger.ExportLogToExcel(); 

      //Part 3 is Working 

            Status.Background = new SolidColorBrush(Colors.Yellow);
            Status.Content = "Exported to Excel Successfully";