Import WixBA from old v4 repo

20 files changed, 2636 insertions, 0 deletions

diff --git a/src/WixToolset.WixBA/BrowserProperties.cs b/src/WixToolset.WixBA/BrowserProperties.cs
new file mode 100644
index 00000000..f40d4ed9
--- /dev/null
+++ b/src/WixToolset.WixBA/BrowserProperties.cs
@@ -0,0 +1,40 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.UX
+{
+    using System.Windows;
+    using System.Windows.Controls;
+
+    /// <summary>
+    /// Dependency Properties to support using a WebBrowser object.
+    /// </summary>
+    class BrowserProperties
+    {
+        /// <summary>
+        /// Dependency Propery used to pass an HTML string to the webBrowser object.
+        /// </summary>
+        public static readonly DependencyProperty HtmlDocProperty =
+            DependencyProperty.RegisterAttached("HtmlDoc", typeof(string), typeof(BrowserProperties), new PropertyMetadata(OnHtmlDocChanged));
+
+        public static string GetHtmlDoc(DependencyObject dependencyObject)
+        {
+            return (string)dependencyObject.GetValue(HtmlDocProperty);
+        }
+
+        public static void SetHtmlDoc(DependencyObject dependencyObject, string htmldoc)
+        {
+            dependencyObject.SetValue(HtmlDocProperty, htmldoc);
+        }
+
+        /// <summary>
+        /// Event handler that passes the HtmlDoc Dependency Property to MavigateToString method.
+        /// </summary>
+        /// <param name="d"></param>
+        /// <param name="e"></param>
+        private static void OnHtmlDocChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var webBrowser = (WebBrowser)d;
+            webBrowser.NavigateToString((string)e.NewValue);
+        }
+    }
+}
diff --git a/src/WixToolset.WixBA/Hresult.cs b/src/WixToolset.WixBA/Hresult.cs
new file mode 100644
index 00000000..68b4c5ea
--- /dev/null
+++ b/src/WixToolset.WixBA/Hresult.cs
@@ -0,0 +1,22 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.UX
+{
+    using System;
+
+    /// <summary>
+    /// Utility class to work with HRESULTs
+    /// </summary>
+    internal class Hresult
+    {
+        /// <summary>
+        /// Determines if an HRESULT was a success code or not.
+        /// </summary>
+        /// <param name="status">HRESULT to verify.</param>
+        /// <returns>True if the status is a success code.</returns>
+        public static bool Succeeded(int status)
+        {
+            return status >= 0;
+        }
+    }
+}
diff --git a/src/WixToolset.WixBA/InstallationViewModel.cs b/src/WixToolset.WixBA/InstallationViewModel.cs
new file mode 100644
index 00000000..6bec427a
--- /dev/null
+++ b/src/WixToolset.WixBA/InstallationViewModel.cs
@@ -0,0 +1,670 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.UX
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Linq;
+    using System.Reflection;
+    using System.Windows;
+    using System.Windows.Input;
+    using IO = System.IO;
+    using WixToolset.Bootstrapper;
+
+    /// <summary>
+    /// The states of detection.
+    /// </summary>
+    public enum DetectionState
+    {
+        Absent,
+        Present,
+        Newer,
+    }
+
+    /// <summary>
+    /// The states of installation.
+    /// </summary>
+    public enum InstallationState
+    {
+        Initializing,
+        Detecting,
+        Waiting,
+        Planning,
+        Applying,
+        Applied,
+        Failed,
+    }
+
+    /// <summary>
+    /// The model of the installation view in WixBA.
+    /// </summary>
+    public class InstallationViewModel : PropertyNotifyBase
+    {
+        private RootViewModel root;
+
+        private Dictionary<string, int> downloadRetries;
+        private bool downgrade;
+        private string downgradeMessage;
+
+        private ICommand licenseCommand;
+        private ICommand launchHomePageCommand;
+        private ICommand launchNewsCommand;
+        private ICommand launchVSExtensionPageCommand;
+        private ICommand installCommand;
+        private ICommand repairCommand;
+        private ICommand uninstallCommand;
+        private ICommand openLogCommand;
+        private ICommand openLogFolderCommand;
+        private ICommand tryAgainCommand;
+
+        private string message;
+        private DateTime cachePackageStart;
+        private DateTime executePackageStart;
+
+        /// <summary>
+        /// Creates a new model of the installation view.
+        /// </summary>
+        public InstallationViewModel(RootViewModel root)
+        {
+            this.root = root;
+            this.downloadRetries = new Dictionary<string, int>();
+
+            this.root.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(this.RootPropertyChanged);
+
+            WixBA.Model.Bootstrapper.DetectBegin += this.DetectBegin;
+            WixBA.Model.Bootstrapper.DetectRelatedBundle += this.DetectedRelatedBundle;
+            WixBA.Model.Bootstrapper.DetectComplete += this.DetectComplete;
+            WixBA.Model.Bootstrapper.PlanPackageBegin += this.PlanPackageBegin;
+            WixBA.Model.Bootstrapper.PlanComplete += this.PlanComplete;
+            WixBA.Model.Bootstrapper.ApplyBegin += this.ApplyBegin;
+            WixBA.Model.Bootstrapper.CacheAcquireBegin += this.CacheAcquireBegin;
+            WixBA.Model.Bootstrapper.CacheAcquireComplete += this.CacheAcquireComplete;
+            WixBA.Model.Bootstrapper.ExecutePackageBegin += this.ExecutePackageBegin;
+            WixBA.Model.Bootstrapper.ExecutePackageComplete += this.ExecutePackageComplete;
+            WixBA.Model.Bootstrapper.Error += this.ExecuteError;
+            WixBA.Model.Bootstrapper.ResolveSource += this.ResolveSource;
+            WixBA.Model.Bootstrapper.ApplyComplete += this.ApplyComplete;
+        }
+
+        void RootPropertyChanged(object sender, PropertyChangedEventArgs e)
+        {
+            if (("DetectState" == e.PropertyName) || ("InstallState" == e.PropertyName))
+            {
+                base.OnPropertyChanged("RepairEnabled");
+                base.OnPropertyChanged("InstallEnabled");
+                base.OnPropertyChanged("IsComplete");
+                base.OnPropertyChanged("IsSuccessfulCompletion");
+                base.OnPropertyChanged("IsFailedCompletion");
+                base.OnPropertyChanged("StatusText");
+                base.OnPropertyChanged("UninstallEnabled");
+            }
+        }
+
+        /// <summary>
+        /// Gets the version for the application.
+        /// </summary>
+        public string Version
+        {
+            get { return String.Concat("v", WixBA.Model.Version.ToString()); }
+        }
+
+        /// <summary>
+        /// The Publisher of this bundle.
+        /// </summary>
+        public string Publisher
+        {
+            get
+            {
+                string company = "[AssemblyCompany]";
+                return WixDistribution.ReplacePlaceholders(company, typeof(WixBA).Assembly);
+            }
+        }
+
+        /// <summary>
+        /// The Publisher of this bundle.
+        /// </summary>
+        public string SupportUrl
+        {
+            get
+            {
+                return WixDistribution.SupportUrl;
+            }
+        }
+        public string VSExtensionUrl
+        {
+            get
+            {
+                return WixDistribution.VSExtensionsLandingUrl;
+            }
+        }
+
+        public string Message
+        {
+            get
+            {
+                return this.message;
+            }
+
+            set
+            {
+                if (this.message != value)
+                {
+                    this.message = value;
+                    base.OnPropertyChanged("Message");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets and sets whether the view model considers this install to be a downgrade.
+        /// </summary>
+        public bool Downgrade
+        {
+            get
+            {
+                return this.downgrade;
+            }
+
+            set
+            {
+                if (this.downgrade != value)
+                {
+                    this.downgrade = value;
+                    base.OnPropertyChanged("Downgrade");
+                }
+            }
+        }
+
+        public string DowngradeMessage
+        {
+            get
+            {
+                return this.downgradeMessage;
+            }
+            set
+            {
+                if (this.downgradeMessage != value)
+                {
+                    this.downgradeMessage = value;
+                    base.OnPropertyChanged("DowngradeMessage");
+                }
+            }
+        }
+
+        public ICommand LaunchHomePageCommand
+        {
+            get
+            {
+                if (this.launchHomePageCommand == null)
+                {
+                    this.launchHomePageCommand = new RelayCommand(param => WixBA.LaunchUrl(this.SupportUrl), param => true);
+                }
+
+                return this.launchHomePageCommand;
+            }
+        }
+
+        public ICommand LaunchNewsCommand
+        {
+            get
+            {
+                if (this.launchNewsCommand == null)
+                {
+                    this.launchNewsCommand = new RelayCommand(param => WixBA.LaunchUrl(WixDistribution.NewsUrl), param => true);
+                }
+
+                return this.launchNewsCommand;
+            }
+        }
+
+        public ICommand LaunchVSExtensionPageCommand
+        {
+            get
+            {
+                if (this.launchVSExtensionPageCommand == null)
+                {
+                    this.launchVSExtensionPageCommand = new RelayCommand(param => WixBA.LaunchUrl(WixDistribution.VSExtensionsLandingUrl), param => true);
+                }
+
+                return this.launchVSExtensionPageCommand;
+            }
+        }
+
+        public ICommand LicenseCommand
+        {
+            get
+            {
+                if (this.licenseCommand == null)
+                {
+                    this.licenseCommand = new RelayCommand(param => this.LaunchLicense(), param => true);
+                }
+
+                return this.licenseCommand;
+            }
+        }
+
+        public bool LicenseEnabled
+        {
+            get { return this.LicenseCommand.CanExecute(this); }
+        }
+
+        public ICommand CloseCommand
+        {
+            get { return this.root.CloseCommand; }
+        }
+
+        public bool IsComplete
+        {
+            get { return IsSuccessfulCompletion || IsFailedCompletion; }
+        }
+
+        public bool IsSuccessfulCompletion
+        {
+            get { return InstallationState.Applied == this.root.InstallState; }
+        }
+
+        public bool IsFailedCompletion
+        {
+            get { return InstallationState.Failed == this.root.InstallState; }
+        }
+
+        public ICommand InstallCommand
+        {
+            get
+            {
+                if (this.installCommand == null)
+                {
+                    this.installCommand = new RelayCommand(param => WixBA.Plan(LaunchAction.Install), param => this.root.DetectState == DetectionState.Absent && this.root.InstallState == InstallationState.Waiting);
+                }
+
+                return this.installCommand;
+            }
+        }
+
+        public bool InstallEnabled
+        {
+            get { return this.InstallCommand.CanExecute(this); }
+        }
+
+        public ICommand RepairCommand
+        {
+            get
+            {
+                if (this.repairCommand == null)
+                {
+                    this.repairCommand = new RelayCommand(param => WixBA.Plan(LaunchAction.Repair), param => this.root.DetectState == DetectionState.Present && this.root.InstallState == InstallationState.Waiting);
+                }
+
+                return this.repairCommand;
+            }
+        }
+
+        public bool RepairEnabled
+        {
+            get { return this.RepairCommand.CanExecute(this); }
+        }
+
+        public ICommand UninstallCommand
+        {
+            get
+            {
+                if (this.uninstallCommand == null)
+                {
+                    this.uninstallCommand = new RelayCommand(param => WixBA.Plan(LaunchAction.Uninstall), param => this.root.DetectState == DetectionState.Present && this.root.InstallState == InstallationState.Waiting);
+                }
+
+                return this.uninstallCommand;
+            }
+        }
+
+        public bool UninstallEnabled
+        {
+            get { return this.UninstallCommand.CanExecute(this); }
+        }
+
+        public ICommand OpenLogCommand
+        {
+            get
+            {
+                if (this.openLogCommand == null)
+                {
+                    this.openLogCommand = new RelayCommand(param => WixBA.OpenLog(new Uri(WixBA.Model.Engine.StringVariables["WixBundleLog"])));
+                }
+                return this.openLogCommand;
+            }
+        }
+
+        public ICommand OpenLogFolderCommand
+        {
+            get
+            {
+                if (this.openLogFolderCommand == null)
+                {
+                    string logFolder = IO.Path.GetDirectoryName(WixBA.Model.Engine.StringVariables["WixBundleLog"]);
+                    this.openLogFolderCommand = new RelayCommand(param => WixBA.OpenLogFolder(logFolder));
+                }
+                return this.openLogFolderCommand;
+            }
+        }
+
+        public ICommand TryAgainCommand
+        {
+            get
+            {
+                if (this.tryAgainCommand == null)
+                {
+                    this.tryAgainCommand = new RelayCommand(param =>
+                        {
+                            this.root.Canceled = false;
+                            WixBA.Plan(WixBA.Model.PlannedAction);
+                        }, param => IsFailedCompletion);
+                }
+
+                return this.tryAgainCommand;
+            }
+        }
+
+        public string StatusText
+        {
+            get
+            {
+                switch(this.root.InstallState)
+                {
+                    case InstallationState.Applied:
+                        return "Complete";
+                    case InstallationState.Failed:
+                        return this.root.Canceled ? "Cancelled" : "Failed";
+                    default:
+                        return "Unknown"; // this shouldn't be shown in the UI.
+                }
+            }
+        }
+
+        /// <summary>
+        /// Launches the license in the default viewer.
+        /// </summary>
+        private void LaunchLicense()
+        {
+            string folder = IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+            WixBA.LaunchUrl(IO.Path.Combine(folder, "License.txt"));
+        }
+
+        private void DetectBegin(object sender, DetectBeginEventArgs e)
+        {
+            this.root.DetectState = e.Installed ? DetectionState.Present : DetectionState.Absent;
+            WixBA.Model.PlannedAction = LaunchAction.Unknown;
+        }
+
+        private void DetectedRelatedBundle(object sender, DetectRelatedBundleEventArgs e)
+        {
+            if (e.Operation == RelatedOperation.Downgrade)
+            {
+                this.Downgrade = true;
+            }
+
+            if (!WixBA.Model.Bootstrapper.BAManifest.Bundle.Packages.ContainsKey(e.ProductCode))
+            {
+                WixBA.Model.Bootstrapper.BAManifest.Bundle.AddRelatedBundleAsPackage(e);
+            }
+        }
+
+        private void DetectComplete(object sender, DetectCompleteEventArgs e)
+        {
+            // Parse the command line string before any planning.
+            this.ParseCommandLine();
+            this.root.InstallState = InstallationState.Waiting;
+
+            if (LaunchAction.Uninstall == WixBA.Model.Command.Action &&
+                ResumeType.Arp != WixBA.Model.Command.Resume) // MSI and WixStdBA require some kind of confirmation before proceeding so WixBA should, too.
+            {
+                WixBA.Model.Engine.Log(LogLevel.Verbose, "Invoking automatic plan for uninstall");
+                WixBA.Plan(LaunchAction.Uninstall);
+            }
+            else if (Hresult.Succeeded(e.Status))
+            {
+                if (this.Downgrade)
+                {
+                    this.root.DetectState = DetectionState.Newer;
+                    IEnumerable<PackageInfo> relatedPackages = WixBA.Model.Bootstrapper.BAManifest.Bundle.Packages.Values.Where(p => p.Type == PackageType.UpgradeBundle);
+                    Version installedVersion = relatedPackages.Any() ? new Version(relatedPackages.Max(p => p.Version)) : null;
+                    if (installedVersion != null && installedVersion < new Version(4, 1) && installedVersion.Build > 10)
+                    {
+                        this.DowngradeMessage = "You must uninstall WiX v" + installedVersion + " before you can install this.";
+                    }
+                    else
+                    {
+                        this.DowngradeMessage = "There is already a newer version of WiX installed on this machine.";
+                    }
+                }
+
+                if (LaunchAction.Layout == WixBA.Model.Command.Action)
+                {
+                    WixBA.PlanLayout();
+                }
+                else if (WixBA.Model.Command.Display != Display.Full)
+                {
+                    // If we're not waiting for the user to click install, dispatch plan with the default action.
+                    WixBA.Model.Engine.Log(LogLevel.Verbose, "Invoking automatic plan for non-interactive mode.");
+                    WixBA.Plan(WixBA.Model.Command.Action);
+                }
+            }
+            else
+            {
+                this.root.InstallState = InstallationState.Failed;
+            }
+
+            // Force all commands to reevaluate CanExecute.
+            // InvalidateRequerySuggested must be run on the UI thread.
+            root.Dispatcher.Invoke(new Action(CommandManager.InvalidateRequerySuggested));
+        }
+
+        private void PlanPackageBegin(object sender, PlanPackageBeginEventArgs e)
+        {
+            // If we're able to run our BA, we don't want to install the .NET Framework since the framework on the machine is already good enough.
+            if ( e.PackageId.StartsWith("NetFx4", StringComparison.OrdinalIgnoreCase))
+            {
+                e.State = RequestState.None;
+            }
+        }
+
+        private void PlanComplete(object sender, PlanCompleteEventArgs e)
+        {
+            if (Hresult.Succeeded(e.Status))
+            {
+                this.root.PreApplyState = this.root.InstallState;
+                this.root.InstallState = InstallationState.Applying;
+                WixBA.Model.Engine.Apply(this.root.ViewWindowHandle);
+            }
+            else
+            {
+                this.root.InstallState = InstallationState.Failed;
+            }
+        }
+
+        private void ApplyBegin(object sender, ApplyBeginEventArgs e)
+        {
+            this.downloadRetries.Clear();
+        }
+
+        private void CacheAcquireBegin(object sender, CacheAcquireBeginEventArgs e)
+        {
+            this.cachePackageStart = DateTime.Now;
+        }
+
+        private void CacheAcquireComplete(object sender, CacheAcquireCompleteEventArgs e)
+        {
+            this.AddPackageTelemetry("Cache", e.PackageOrContainerId ?? String.Empty, DateTime.Now.Subtract(this.cachePackageStart).TotalMilliseconds, e.Status);
+        }
+
+        private void ExecutePackageBegin(object sender, ExecutePackageBeginEventArgs e)
+        {
+            lock (this)
+            {
+                this.executePackageStart = e.ShouldExecute ? DateTime.Now : DateTime.MinValue;
+            }
+        }
+
+        private void ExecutePackageComplete(object sender, ExecutePackageCompleteEventArgs e)
+        {
+            lock (this)
+            {
+                if (DateTime.MinValue < this.executePackageStart)
+                {
+                    this.AddPackageTelemetry("Execute", e.PackageId ?? String.Empty, DateTime.Now.Subtract(this.executePackageStart).TotalMilliseconds, e.Status);
+                    this.executePackageStart = DateTime.MinValue;
+                }
+            }
+        }
+
+        private void ExecuteError(object sender, ErrorEventArgs e)
+        {
+            lock (this)
+            {
+                if (!this.root.Canceled)
+                {
+                    // If the error is a cancel coming from the engine during apply we want to go back to the preapply state.
+                    if (InstallationState.Applying == this.root.InstallState && (int)Error.UserCancelled == e.ErrorCode)
+                    {
+                        this.root.InstallState = this.root.PreApplyState;
+                    }
+                    else
+                    {
+                        this.Message = e.ErrorMessage;
+
+                        if (Display.Full == WixBA.Model.Command.Display)
+                        {
+                            // On HTTP authentication errors, have the engine try to do authentication for us.
+                            if (ErrorType.HttpServerAuthentication == e.ErrorType || ErrorType.HttpProxyAuthentication == e.ErrorType)
+                            {
+                                e.Result = Result.TryAgain;
+                            }
+                            else // show an error dialog.
+                            {
+                                MessageBoxButton msgbox = MessageBoxButton.OK;
+                                switch (e.UIHint & 0xF)
+                                {
+                                    case 0:
+                                        msgbox = MessageBoxButton.OK;
+                                        break;
+                                    case 1:
+                                        msgbox = MessageBoxButton.OKCancel;
+                                        break;
+                                    // There is no 2! That would have been MB_ABORTRETRYIGNORE.
+                                    case 3:
+                                        msgbox = MessageBoxButton.YesNoCancel;
+                                        break;
+                                    case 4:
+                                        msgbox = MessageBoxButton.YesNo;
+                                        break;
+                                    // default: stay with MBOK since an exact match is not available.
+                                }
+
+                                MessageBoxResult result = MessageBoxResult.None;
+                                WixBA.View.Dispatcher.Invoke((Action)delegate()
+                                    {
+                                        result = MessageBox.Show(WixBA.View, e.ErrorMessage, "WiX Toolset", msgbox, MessageBoxImage.Error);
+                                    }
+                                    );
+
+                                // If there was a match from the UI hint to the msgbox value, use the result from the
+                                // message box. Otherwise, we'll ignore it and return the default to Burn.
+                                if ((e.UIHint & 0xF) == (int)msgbox)
+                                {
+                                    e.Result = (Result)result;
+                                }
+                            }
+                        }
+                    }
+                }
+                else // canceled, so always return cancel.
+                {
+                    e.Result = Result.Cancel;
+                }
+            }
+        }
+
+        private void ResolveSource(object sender, ResolveSourceEventArgs e)
+        {
+            int retries = 0;
+
+            this.downloadRetries.TryGetValue(e.PackageOrContainerId, out retries);
+            this.downloadRetries[e.PackageOrContainerId] = retries + 1;
+
+            e.Action = retries < 3 && !String.IsNullOrEmpty(e.DownloadSource) ? BOOTSTRAPPER_RESOLVESOURCE_ACTION.Download : BOOTSTRAPPER_RESOLVESOURCE_ACTION.None;
+        }
+
+        private void ApplyComplete(object sender, ApplyCompleteEventArgs e)
+        {
+            WixBA.Model.Result = e.Status; // remember the final result of the apply.
+
+            // Set the state to applied or failed unless the state has already been set back to the preapply state
+            // which means we need to show the UI as it was before the apply started.
+            if (this.root.InstallState != this.root.PreApplyState)
+            {
+                this.root.InstallState = Hresult.Succeeded(e.Status) ? InstallationState.Applied : InstallationState.Failed;
+            }
+
+            // If we're not in Full UI mode, we need to alert the dispatcher to stop and close the window for passive.
+            if (Bootstrapper.Display.Full != WixBA.Model.Command.Display)
+            {
+                // If its passive, send a message to the window to close.
+                if (Bootstrapper.Display.Passive == WixBA.Model.Command.Display)
+                {
+                    WixBA.Model.Engine.Log(LogLevel.Verbose, "Automatically closing the window for non-interactive install");
+                    WixBA.Dispatcher.BeginInvoke(new Action(WixBA.View.Close));
+                }
+                else
+                {
+                    WixBA.Dispatcher.InvokeShutdown();
+                }
+                return;
+            }
+            else if (Hresult.Succeeded(e.Status) && LaunchAction.UpdateReplace == WixBA.Model.PlannedAction) // if we successfully applied an update close the window since the new Bundle should be running now.
+            {
+                WixBA.Model.Engine.Log(LogLevel.Verbose, "Automatically closing the window since update successful.");
+                WixBA.Dispatcher.BeginInvoke(new Action(WixBA.View.Close));
+                return;
+            }
+            else if (root.AutoClose)
+            {
+                // Automatically closing since the user clicked the X button.
+                WixBA.Dispatcher.BeginInvoke(new Action(WixBA.View.Close));
+                return;
+            }
+
+            // Force all commands to reevaluate CanExecute.
+            // InvalidateRequerySuggested must be run on the UI thread.
+            root.Dispatcher.Invoke(new Action(CommandManager.InvalidateRequerySuggested));
+        }
+
+        private void ParseCommandLine()
+        {
+            // Get array of arguments based on the system parsing algorithm.
+            string[] args = WixBA.Model.Command.GetCommandLineArgs();
+            for (int i = 0; i < args.Length; ++i)
+            {
+                if (args[i].StartsWith("InstallFolder=", StringComparison.InvariantCultureIgnoreCase))
+                {
+                    // Allow relative directory paths. Also validates.
+                    string[] param = args[i].Split(new char[] {'='}, 2);
+                    this.root.InstallDirectory = IO.Path.Combine(Environment.CurrentDirectory, param[1]);
+                }
+            }
+        }
+
+        private void AddPackageTelemetry(string prefix, string id, double time, int result)
+        {
+            lock (this)
+            {
+                string key = String.Format("{0}Time_{1}", prefix, id);
+                string value = time.ToString();
+                WixBA.Model.Telemetry.Add(new KeyValuePair<string, string>(key, value));
+
+                key = String.Format("{0}Result_{1}", prefix, id);
+                value = String.Concat("0x", result.ToString("x"));
+                WixBA.Model.Telemetry.Add(new KeyValuePair<string, string>(key, value));
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.WixBA/Model.cs b/src/WixToolset.WixBA/Model.cs
new file mode 100644
index 00000000..9f03e95b
--- /dev/null
+++ b/src/WixToolset.WixBA/Model.cs
@@ -0,0 +1,129 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.UX
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Net;
+    using WixToolset.Bootstrapper;
+
+    /// <summary>
+    /// The model.
+    /// </summary>
+    public class Model
+    {
+        private const string BurnBundleInstallDirectoryVariable = "InstallFolder";
+        private const string BurnBundleLayoutDirectoryVariable = "WixBundleLayoutDirectory";
+        private const string BurnBundleVersionVariable = "WixBundleVersion";
+
+        /// <summary>
+        /// Creates a new model for the UX.
+        /// </summary>
+        /// <param name="bootstrapper">Bootstrapper hosting the UX.</param>
+        public Model(BootstrapperApplication bootstrapper)
+        {
+            this.Bootstrapper = bootstrapper;
+            this.Telemetry = new List<KeyValuePair<string, string>>();
+            this.Version = this.Engine.VersionVariables[BurnBundleVersionVariable];
+        }
+
+        /// <summary>
+        /// Gets the bootstrapper.
+        /// </summary>
+        public BootstrapperApplication Bootstrapper { get; private set; }
+
+        /// <summary>
+        /// Gets the bootstrapper command-line.
+        /// </summary>
+        public Command Command { get { return this.Bootstrapper.Command; } }
+
+        /// <summary>
+        /// Gets the bootstrapper engine.
+        /// </summary>
+        public Engine Engine { get { return this.Bootstrapper.Engine; } }
+
+        /// <summary>
+        /// Gets the key/value pairs used in telemetry.
+        /// </summary>
+        public List<KeyValuePair<string, string>> Telemetry { get; private set; }
+
+        /// <summary>
+        /// Get or set the final result of the installation.
+        /// </summary>
+        public int Result { get; set; }
+
+        /// <summary>
+        /// Get the version of the install.
+        /// </summary>
+        public Version Version { get; private set; }
+
+        /// <summary>
+        /// Get or set the path where the bundle is installed.
+        /// </summary>
+        public string InstallDirectory
+        {
+            get
+            {
+                if (!this.Engine.StringVariables.Contains(BurnBundleInstallDirectoryVariable))
+                {
+                    return null;
+                }
+
+                return this.Engine.StringVariables[BurnBundleInstallDirectoryVariable];
+            }
+
+            set
+            {
+                this.Engine.StringVariables[BurnBundleInstallDirectoryVariable] = value;
+            }
+        }
+
+        /// <summary>
+        /// Get or set the path for the layout to be created.
+        /// </summary>
+        public string LayoutDirectory
+        {
+            get
+            {
+                if (!this.Engine.StringVariables.Contains(BurnBundleLayoutDirectoryVariable))
+                {
+                    return null;
+                }
+
+                return this.Engine.StringVariables[BurnBundleLayoutDirectoryVariable];
+            }
+
+            set
+            {
+                this.Engine.StringVariables[BurnBundleLayoutDirectoryVariable] = value;
+            }
+        }
+
+        public LaunchAction PlannedAction { get; set; }
+
+        /// <summary>
+        /// Creates a correctly configured HTTP web request.
+        /// </summary>
+        /// <param name="uri">URI to connect to.</param>
+        /// <returns>Correctly configured HTTP web request.</returns>
+        public HttpWebRequest CreateWebRequest(string uri)
+        {
+            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
+            request.UserAgent = String.Concat("WixInstall", this.Version.ToString());
+
+            return request;
+        }
+
+        /// <summary>
+        /// Gets the display name for a package if possible.
+        /// </summary>
+        /// <param name="packageId">Identity of the package to find the display name.</param>
+        /// <returns>Display name of the package if found or the package id if not.</returns>
+        public string GetPackageName(string packageId)
+        {
+            PackageInfo package;
+
+            return this.Bootstrapper.BAManifest.Bundle.Packages.TryGetValue(packageId, out package) ? package.DisplayName : packageId;
+        }
+    }
+}
diff --git a/src/WixToolset.WixBA/NewsItem.cs b/src/WixToolset.WixBA/NewsItem.cs
new file mode 100644
index 00000000..a8350104
--- /dev/null
+++ b/src/WixToolset.WixBA/NewsItem.cs
@@ -0,0 +1,18 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.UX
+{
+    using System;
+
+    /// <summary>
+    /// The model for an individual news item.
+    /// </summary>
+    public class NewsItem
+    {
+        public string Author { get; set; }
+        public string Title { get; set; }
+        public string Url { get; set; }
+        public string Snippet { get; set; }
+        public DateTime Updated { get; set; }
+    }
+}
diff --git a/src/WixToolset.WixBA/ProgressViewModel.cs b/src/WixToolset.WixBA/ProgressViewModel.cs
new file mode 100644
index 00000000..30aee5f1
--- /dev/null
+++ b/src/WixToolset.WixBA/ProgressViewModel.cs
@@ -0,0 +1,194 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Text.RegularExpressions;
+using WixToolset.Bootstrapper;
+
+namespace WixToolset.UX
+{
+    public class ProgressViewModel : PropertyNotifyBase
+    {
+        private static readonly Regex TrimActionTimeFromMessage = new Regex(@"^\w+\s+\d+:\d+:\d+:\s+", RegexOptions.CultureInvariant | RegexOptions.ExplicitCapture | RegexOptions.Singleline);
+
+        private RootViewModel root;
+        private Dictionary<string, int> executingPackageOrderIndex;
+
+        private int progressPhases;
+        private int progress;
+        private int cacheProgress;
+        private int executeProgress;
+        private string package;
+        private string message;
+
+        public ProgressViewModel(RootViewModel root)
+        {
+            this.root = root;
+            this.executingPackageOrderIndex = new Dictionary<string, int>();
+
+            this.root.PropertyChanged += this.RootPropertyChanged;
+
+            WixBA.Model.Bootstrapper.ExecutePackageBegin += this.ExecutePackageBegin;
+            WixBA.Model.Bootstrapper.ExecutePackageComplete += this.ExecutePackageComplete;
+            WixBA.Model.Bootstrapper.ExecuteProgress += this.ApplyExecuteProgress;
+            WixBA.Model.Bootstrapper.PlanBegin += this.PlanBegin;
+            WixBA.Model.Bootstrapper.PlanPackageComplete += this.PlanPackageComplete;
+            WixBA.Model.Bootstrapper.ApplyBegin += this.ApplyBegin;
+            WixBA.Model.Bootstrapper.Progress += this.ApplyProgress;
+            WixBA.Model.Bootstrapper.CacheAcquireProgress += this.CacheAcquireProgress;
+            WixBA.Model.Bootstrapper.CacheComplete += this.CacheComplete;
+        }
+
+        public bool ProgressEnabled
+        {
+            get { return this.root.InstallState == InstallationState.Applying; }
+        }
+
+        public int Progress
+        {
+            get
+            {
+                return this.progress;
+            }
+
+            set
+            {
+                if (this.progress != value)
+                {
+                    this.progress = value;
+                    base.OnPropertyChanged("Progress");
+                }
+            }
+        }
+
+        public string Package
+        {
+            get
+            {
+                return this.package;
+            }
+
+            set
+            {
+                if (this.package != value)
+                {
+                    this.package = value;
+                    base.OnPropertyChanged("Package");
+                }
+            }
+        }
+
+        public string Message
+        {
+            get
+            {
+                return this.message;
+            }
+
+            set
+            {
+                if (this.message != value)
+                {
+                    this.message = value;
+                    base.OnPropertyChanged("Message");
+                }
+            }
+        }
+
+        void RootPropertyChanged(object sender, PropertyChangedEventArgs e)
+        {
+            if ("InstallState" == e.PropertyName)
+            {
+                base.OnPropertyChanged("ProgressEnabled");
+            }
+        }
+
+        private void PlanBegin(object sender, PlanBeginEventArgs e)
+        {
+            lock (this)
+            {
+                this.executingPackageOrderIndex.Clear();
+            }
+        }
+
+        private void PlanPackageComplete(object sender, PlanPackageCompleteEventArgs e)
+        {
+            if (ActionState.None != e.Execute)
+            {
+                lock (this)
+                {
+                    Debug.Assert(!this.executingPackageOrderIndex.ContainsKey(e.PackageId));
+                    this.executingPackageOrderIndex.Add(e.PackageId, this.executingPackageOrderIndex.Count);
+                }
+            }
+        }
+
+        private void ExecutePackageBegin(object sender, ExecutePackageBeginEventArgs e)
+        {
+            lock (this)
+            {
+                this.Package = WixBA.Model.GetPackageName(e.PackageId);
+                this.Message = String.Format("Processing: {0}", this.Package);
+                e.Cancel = this.root.Canceled;
+            }
+        }
+
+        private void ExecutePackageComplete(object sender, ExecutePackageCompleteEventArgs e)
+        {
+            lock (this)
+            {   // avoid a stale display
+                this.Message = String.Empty;
+            }
+        }
+
+        private void ApplyBegin(object sender, ApplyBeginEventArgs e)
+        {
+            this.progressPhases = e.PhaseCount;
+        }
+
+        private void ApplyProgress(object sender, ProgressEventArgs e)
+        {
+            lock (this)
+            {
+                e.Cancel = this.root.Canceled;
+            }
+        }
+
+        private void CacheAcquireProgress(object sender, CacheAcquireProgressEventArgs e)
+        {
+            lock (this)
+            {
+                this.cacheProgress = e.OverallPercentage;
+                this.Progress = (this.cacheProgress + this.executeProgress) / this.progressPhases;
+                e.Cancel = this.root.Canceled;
+            }
+        }
+
+        private void CacheComplete(object sender, CacheCompleteEventArgs e)
+        {
+            lock (this)
+            {
+                this.cacheProgress = 100;
+                this.Progress = (this.cacheProgress + this.executeProgress) / this.progressPhases;
+            }
+        }
+
+        private void ApplyExecuteProgress(object sender, ExecuteProgressEventArgs e)
+        {
+            lock (this)
+            {
+                this.executeProgress = e.OverallPercentage;
+                this.Progress = (this.cacheProgress + this.executeProgress) / this.progressPhases;
+
+                if (WixBA.Model.Command.Display == Display.Embedded)
+                {
+                    WixBA.Model.Engine.SendEmbeddedProgress(e.ProgressPercentage, this.Progress);
+                }
+
+                e.Cancel = this.root.Canceled;
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.WixBA/Properties/AssemblyInfo.cs b/src/WixToolset.WixBA/Properties/AssemblyInfo.cs
new file mode 100644
index 00000000..58d88046
--- /dev/null
+++ b/src/WixToolset.WixBA/Properties/AssemblyInfo.cs
@@ -0,0 +1,22 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+using System;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using WixToolset.Bootstrapper;
+using WixToolset.UX;
+
+
+[assembly: AssemblyTitle("WixBA")]
+[assembly: AssemblyDescription("WiX User Experience")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+[assembly: Guid("0ffc4944-9295-40b7-adac-3a6864b5219b")]
+[assembly: CLSCompliantAttribute(true)]
+
+// Identifies the class that derives from UserExperience and is the UX class that gets
+// instantiated by the interop layer
+[assembly: BootstrapperApplication(typeof(WixBA))]
diff --git a/src/WixToolset.WixBA/PropertyNotifyBase.cs b/src/WixToolset.WixBA/PropertyNotifyBase.cs
new file mode 100644
index 00000000..03174306
--- /dev/null
+++ b/src/WixToolset.WixBA/PropertyNotifyBase.cs
@@ -0,0 +1,59 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.UX
+{
+    using System;
+    using System.ComponentModel;
+    using System.Diagnostics;
+
+    /// <summary>
+    /// It provides support for property change notifications.
+    /// </summary>
+    public abstract class PropertyNotifyBase : INotifyPropertyChanged
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PropertyNotifyBase"/> class.
+        /// </summary>
+        protected PropertyNotifyBase()
+        {
+        }
+
+        /// <summary>
+        /// Raised when a property on this object has a new value.
+        /// </summary>
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        /// <summary>
+        /// Warns the developer if this object does not have a public property with the
+        /// specified name. This method does not exist in a Release build.
+        /// </summary>
+        /// <param name="propertyName">Property name to verify.</param>
+        [Conditional("DEBUG")]
+        [DebuggerStepThrough]
+        public void VerifyPropertyName(string propertyName)
+        {
+            // Verify that the property name matches a real, public, instance property
+            // on this object.
+            if (null == TypeDescriptor.GetProperties(this)[propertyName])
+            {
+                Debug.Fail(String.Concat("Invalid property name: ", propertyName));
+            }
+        }
+
+        /// <summary>
+        /// Raises this object's PropertyChanged event.
+        /// </summary>
+        /// <param name="propertyName">The property that has a new value.</param>
+        protected virtual void OnPropertyChanged(string propertyName)
+        {
+            this.VerifyPropertyName(propertyName);
+
+            PropertyChangedEventHandler handler = this.PropertyChanged;
+            if (null != handler)
+            {
+                PropertyChangedEventArgs e = new PropertyChangedEventArgs(propertyName);
+                handler(this, e);
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.WixBA/RelayCommand.cs b/src/WixToolset.WixBA/RelayCommand.cs
new file mode 100644
index 00000000..ecc482da
--- /dev/null
+++ b/src/WixToolset.WixBA/RelayCommand.cs
@@ -0,0 +1,45 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.UX
+{
+    using System;
+    using System.Diagnostics;
+    using System.Windows.Input;
+
+    /// <summary>
+    /// Base class that implements ICommand interface via delegates.
+    /// </summary>
+    public class RelayCommand : ICommand
+    {
+        private readonly Action<object> execute;
+        private readonly Predicate<object> canExecute;
+
+        public RelayCommand(Action<object> execute)
+            : this(execute, null)
+        {
+        }
+
+        public RelayCommand(Action<object> execute, Predicate<object> canExecute)
+        {
+            this.execute = execute;
+            this.canExecute = canExecute;
+        }
+
+        public event EventHandler CanExecuteChanged
+        {
+            add { CommandManager.RequerySuggested += value; }
+            remove { CommandManager.RequerySuggested -= value; }
+        }
+
+        [DebuggerStepThrough]
+        public bool CanExecute(object parameter)
+        {
+            return this.canExecute == null ? true : this.canExecute(parameter);
+        }
+
+        public void Execute(object parameter)
+        {
+            this.execute(parameter);
+        }
+    }
+}
diff --git a/src/WixToolset.WixBA/Resources/logo-black-hollow.png b/src/WixToolset.WixBA/Resources/logo-black-hollow.png
new file mode 100644
index 00000000..9d0290bd
--- /dev/null
+++ b/src/WixToolset.WixBA/Resources/logo-black-hollow.png
diff --git a/src/WixToolset.WixBA/Resources/logo-white-hollow.png b/src/WixToolset.WixBA/Resources/logo-white-hollow.png
new file mode 100644
index 00000000..242c7350
--- /dev/null
+++ b/src/WixToolset.WixBA/Resources/logo-white-hollow.png
diff --git a/src/WixToolset.WixBA/RootView.xaml b/src/WixToolset.WixBA/RootView.xaml
new file mode 100644
index 00000000..bbf2f9f2
--- /dev/null
+++ b/src/WixToolset.WixBA/RootView.xaml
@@ -0,0 +1,420 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!-- Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. -->
+
+<Window x:Class="WixToolset.UX.RootView"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:ux="clr-namespace:WixToolset.UX"
+        MinWidth="550"
+        MinHeight="400"
+        Width="750"
+        Height="400"
+        AllowsTransparency="False"
+        Background="{x:Null}"
+        Closing="Window_Closing"
+        ResizeMode="CanResizeWithGrip"
+        WindowStartupLocation="CenterScreen"
+        WindowStyle="ThreeDBorderWindow">
+
+    <Window.Resources>
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <ResourceDictionary Source="pack://application:,,,/WixBA;component/Styles.xaml" />
+            </ResourceDictionary.MergedDictionaries>
+        </ResourceDictionary>
+    </Window.Resources>
+
+    <Border Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+            BorderBrush="{DynamicResource {x:Static SystemColors.ActiveBorderBrushKey}}"
+            BorderThickness="0">
+
+        <DockPanel x:Name="AppArtBoardArea"
+                   Margin="20, 10">
+
+            <DockPanel x:Name="ActionArea"
+                       DockPanel.Dock="Bottom">
+
+                <Grid x:Name="ActionGrid">
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto" />
+                    </Grid.RowDefinitions>
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="*" MinWidth="150" />
+                        <ColumnDefinition Width="Auto" />
+                    </Grid.ColumnDefinitions>
+
+                    <StackPanel x:Name="LeftMarqueeDcIsland"
+                                Grid.Column="0"
+                                VerticalAlignment="Center"
+                                DataContext="{Binding UpdateViewModel}">
+                        <ProgressBar x:Name="CheckingUpdatesProgress"
+                                     MinHeight="10"
+                                     IsIndeterminate="{Binding CheckingEnabled}"
+                                     Style="{DynamicResource UpdateMarqueeStyle}"
+                                     Visibility="{Binding CheckingEnabled,
+                                                          Converter={StaticResource BooleanToVisibilityConverter}}" />
+                    </StackPanel>
+
+                    <StackPanel x:Name="InitiateActionArea"
+                                Grid.Column="1"
+                                Margin="30, 0, 0, 0"
+                                HorizontalAlignment="Right"
+                                Orientation="Horizontal">
+                        <!-- Displayed from left to right, when ordered from top to bottom.  Most preferred is at the top. -->
+                        <StackPanel x:Name="UpdateBtnDcIsland"
+                                    DataContext="{Binding UpdateViewModel}"
+                                    Style="{DynamicResource ActionBtnStkPnlStyle}">
+                            <Button AutomationProperties.HelpText="An update is available. Click to get the update"
+                                    AutomationProperties.Name="Update"
+                                    Command="{Binding UpdateCommand}"
+                                    Content="Update"
+                                    Style="{DynamicResource ActionButtonStyle}"
+                                    Visibility="{Binding CanUpdate,
+                                                         Converter={StaticResource BooleanToVisibilityConverter}}" />
+                        </StackPanel>
+                        <StackPanel x:Name="InstallBtnDcIsland"
+                                    DataContext="{Binding InstallationViewModel}"
+                                    Style="{DynamicResource ActionBtnStkPnlStyle}">
+                            <Button AutomationProperties.HelpText="Click to accept license and install"
+                                    AutomationProperties.Name="Install"
+                                    Command="{Binding InstallCommand}"
+                                    Content="_Install"
+                                    IsDefault="True"
+                                    Style="{DynamicResource ActionButtonStyle}"
+                                    Visibility="{Binding InstallEnabled,
+                                                         Converter={StaticResource BooleanToVisibilityConverter}}" />
+                        </StackPanel>
+                        <StackPanel x:Name="RepairBtnDcIsland"
+                                    DataContext="{Binding InstallationViewModel}"
+                                    Style="{DynamicResource ActionBtnStkPnlStyle}">
+                            <Button x:Name="RepairButton"
+                                    AutomationProperties.HelpText="Click to Repair"
+                                    AutomationProperties.Name="Repair"
+                                    Command="{Binding RepairCommand}"
+                                    Content="Repair"
+                                    Style="{DynamicResource ActionButtonStyle}"
+                                    Visibility="{Binding RepairEnabled,
+                                                         Converter={StaticResource BooleanToVisibilityConverter}}" />
+                        </StackPanel>
+                        <StackPanel x:Name="UninstallBtnDcIsland"
+                                    DataContext="{Binding InstallationViewModel}"
+                                    Style="{DynamicResource ActionBtnStkPnlStyle}">
+                            <Button AutomationProperties.HelpText="Click to Uninstall"
+                                    AutomationProperties.Name="Uninstall"
+                                    Command="{Binding UninstallCommand}"
+                                    Content="Uninstall"
+                                    Style="{DynamicResource ActionButtonStyle}"
+                                    Visibility="{Binding UninstallEnabled,
+                                                         Converter={StaticResource BooleanToVisibilityConverter}}" />
+                        </StackPanel>
+                        <StackPanel x:Name="TryAgainBtnDcIsland"
+                                    DataContext="{Binding InstallationViewModel}"
+                                    Style="{DynamicResource ActionBtnStkPnlStyle}">
+                            <Button HorizontalAlignment="Center"
+                                    VerticalAlignment="Center"
+                                    AutomationProperties.HelpText="Click to try again"
+                                    AutomationProperties.Name="Try Again?"
+                                    Command="{Binding TryAgainCommand}"
+                                    Content="Try Again?"
+                                    Style="{DynamicResource ActionButtonStyle}"
+                                    Visibility="{Binding IsFailedCompletion,
+                                                         Converter={StaticResource BooleanToVisibilityConverter}}" />
+                        </StackPanel>
+
+                        <!-- Final Actions - only one of these is expected to be displayed, if any -->
+                        <StackPanel x:Name="CloseBtnDcIsland"
+                                    HorizontalAlignment="Right"
+                                    DataContext="{Binding InstallationViewModel}"
+                                    Style="{DynamicResource ActionBtnStkPnlStyle}">
+                            <Button x:Name="CloseButton"
+                                    AutomationProperties.HelpText="Click to Close"
+                                    AutomationProperties.Name="Close"
+                                    Command="{Binding CloseCommand}"
+                                    Content="Close"
+                                    Style="{DynamicResource FinalActionButtonStyle}"
+                                    Visibility="{Binding IsSuccessfulCompletion,
+                                                         Converter={StaticResource BooleanToVisibilityConverter}}" />
+                        </StackPanel>
+                        <StackPanel x:Name="CancelBtnDcIsland"
+                                    HorizontalAlignment="Right"
+                                    DataContext="{Binding}"
+                                    Style="{DynamicResource ActionBtnStkPnlStyle}">
+                            <Button AutomationProperties.HelpText="Press to Cancel"
+                                    AutomationProperties.Name="Cancel"
+                                    Command="{Binding CancelCommand}"
+                                    Content="Cancel"
+                                    Style="{DynamicResource FinalActionButtonStyle}"
+                                    Visibility="{Binding CancelAvailable,
+                                                         Converter={StaticResource BooleanToVisibilityConverter}}" />
+                        </StackPanel>
+                    </StackPanel>
+                </Grid>
+            </DockPanel>
+
+            <StackPanel x:Name="FinalStatusArea"
+                        DataContext="{Binding InstallationViewModel}"
+                        HorizontalAlignment="Right"
+                        Margin="0,10,0,20"
+                        Orientation="Horizontal"
+                        Visibility="{Binding IsComplete,
+                                             Converter={StaticResource BooleanToVisibilityConverter}}"
+                        DockPanel.Dock="Bottom">
+                <TextBlock x:Name="StatusTextBlk"
+                           Style="{DynamicResource LabelTextBlkStyle}"
+                           Text="{Binding StatusText, StringFormat={}{0}:}"
+                           TextBlock.FontWeight="Bold" />
+                <Button x:Name="ViewLogLink"
+                        Margin="10,2,10,0"
+                        Command="{Binding OpenLogCommand}"
+                        Style="{StaticResource HyperlinkedButtonStyle}">
+                    <TextBlock>
+                            <Hyperlink Command="{Binding OpenLogCommand}"><Run FontSize="{DynamicResource FontSizeButton}" Text="View Log" /></Hyperlink>
+                    </TextBlock>
+                </Button>
+                <Button x:Name="ViewLogFolderLink"
+                            Command="{Binding OpenLogFolderCommand}"
+                            Style="{StaticResource HyperlinkedButtonStyle}">
+                    <TextBlock>
+                            <Hyperlink Command="{Binding OpenLogFolderCommand}"><Run FontSize="{DynamicResource FontSizeButton}" Text="View Log Folder" /></Hyperlink>
+                    </TextBlock>
+                </Button>
+            </StackPanel>
+
+            <StackPanel x:Name="StatusStkPnlDcIsland"
+                        Margin="0,10"
+                        DataContext="{Binding ProgressViewModel}"
+                        DockPanel.Dock="Bottom">
+
+                <StackPanel x:Name="ActionPackageNameTextStkPnl"
+                            VerticalAlignment="Top">
+                    <TextBlock Style="{StaticResource StatusTextStyle}"
+                               Text="{Binding Message}"
+                               TextWrapping="WrapWithOverflow"
+                               Visibility="{Binding ProgressEnabled,
+                                                    Converter={StaticResource BooleanToVisibilityConverter}}" />
+                </StackPanel>
+
+                <StackPanel x:Name="ActionProgressStkPnl"
+                            Margin="0,5,0,0">
+                    <ProgressBar x:Name="ActionProgress"
+                                 Height="20"
+                                 VerticalAlignment="Center"
+                                 Style="{DynamicResource ActionProgressStyle}"
+                                 Visibility="{Binding ProgressEnabled,
+                                                      Converter={StaticResource BooleanToVisibilityConverter}}"
+                                 Value="{Binding Progress}" />
+                </StackPanel>
+            </StackPanel>
+
+            <StackPanel x:Name="TitleAndLogoStkPnl"
+                        DockPanel.Dock="Top">
+                <Grid x:Name="TitleGrid">
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto" />
+                    </Grid.RowDefinitions>
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="*" />
+                        <ColumnDefinition Width="Auto" />
+                    </Grid.ColumnDefinitions>
+
+                    <TextBlock x:Name="TitleTextBlk"
+                               Grid.Column="0"
+                               Style="{DynamicResource TitleTextBlkStyle}"
+                               Text="{Binding Title,
+                                              Mode=OneTime}" />
+                    <Image x:Name="Logo"
+                           Grid.Column="2"
+                           Style="{DynamicResource LogoStyle}">
+                    </Image>
+                </Grid>
+            </StackPanel>
+
+            <Grid x:Name="MainStkPnl">
+                <Grid.RowDefinitions>
+                    <RowDefinition Height="*" />
+                    <RowDefinition Height="Auto" />
+                </Grid.RowDefinitions>
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="1*" />
+                    <ColumnDefinition Width="4*" MinWidth="200" />
+                </Grid.ColumnDefinitions>
+
+                <Grid x:Name="SkuInfo"
+                      Grid.Column="0"
+                      Grid.Row="0"
+                      DataContext="{Binding InstallationViewModel}">
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto" />
+                        <RowDefinition Height="Auto" />
+                        <RowDefinition Height="Auto" />
+                        <RowDefinition Height="Auto" />
+                        <RowDefinition Height="Auto" />
+                        <RowDefinition Height="Auto" />
+                        <RowDefinition Height="Auto" />
+                    </Grid.RowDefinitions>
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="*" />
+                    </Grid.ColumnDefinitions>
+
+                    <TextBlock x:Name="SkuPublisherLabel"
+                               Grid.Row="0"
+                               Grid.Column="0"
+                               Style="{DynamicResource LabelTextBlkStyle}"
+                               Text="Publisher:" />
+                    <TextBlock x:Name="SkuPublisherData"
+                               Grid.Row="0"
+                               Grid.Column="1"
+                               Style="{DynamicResource DataTextBlkStyle}"
+                               Text="{Binding Publisher,
+                                              Mode=OneTime}" />
+
+                    <TextBlock x:Name="SkuVersionLabel"
+                               Grid.Row="1"
+                               Grid.Column="0"
+                               Style="{DynamicResource LabelTextBlkStyle}"
+                               Text="Version:" />
+                    <TextBlock Grid.Row="1"
+                               Grid.Column="1"
+                               Style="{DynamicResource DataTextBlkStyle}"
+                               Text="{Binding Version}" />
+
+                    <TextBlock x:Name="SkuLicenseLabel"
+                               Grid.Row="2"
+                               Grid.Column="0"
+                               Style="{DynamicResource LabelTextBlkStyle}"
+                               Text="License:" />
+                    <Button x:Name="SkuLicenseBtn"
+                            Grid.Row="2"
+                            Grid.Column="1"
+                            HorizontalAlignment="Left"
+                            AutomationProperties.HelpText="View the license"
+                            AutomationProperties.Name="License"
+                            Command="{Binding LicenseCommand}"
+                            KeyboardNavigation.IsTabStop="False"
+                            Style="{StaticResource HyperlinkedButtonStyle}">
+                        <TextBlock HorizontalAlignment="Left">
+                            <Hyperlink Command="{Binding LicenseCommand}"
+                                       IsEnabled="True"
+                                       KeyboardNavigation.IsTabStop="False"><Run FontSize="{DynamicResource FontSizeButton}" Text="View License" /></Hyperlink>
+                        </TextBlock>
+                    </Button>
+
+                    <TextBlock x:Name="SkuNewsLabel"
+                               Grid.Row="3"
+                               Grid.Column="0"
+                               Style="{DynamicResource LabelTextBlkStyle}"
+                               Text="News:" />
+                    <Button x:Name="SkuNewsBtn"
+                            Grid.Row="3"
+                            Grid.Column="1"
+                            HorizontalAlignment="Left"
+                            AutomationProperties.HelpText="Latest News"
+                            AutomationProperties.Name="News"
+                            Command="{Binding LaunchNewsCommand}"
+                            KeyboardNavigation.IsTabStop="False"
+                            Style="{StaticResource HyperlinkedButtonStyle}">
+                        <TextBlock HorizontalAlignment="Left">
+                            <Hyperlink Command="{Binding LaunchNewsCommand}"
+                                       IsEnabled="True"
+                                       KeyboardNavigation.IsTabStop="False"><Run FontSize="{DynamicResource FontSizeButton}" Text="Latest News" /></Hyperlink>
+                        </TextBlock>
+                    </Button>
+
+                    <TextBlock x:Name="SkuSupportLabel"
+                               Grid.Row="4"
+                               Grid.Column="0"
+                               Style="{DynamicResource LabelTextBlkStyle}"
+                               Text="Support:" />
+                    <Button x:Name="SkuSupportBtn"
+                            Grid.Row="4"
+                            Grid.Column="1"
+                            HorizontalAlignment="Left"
+                            AutomationProperties.HelpText="View Home Page for Support"
+                            AutomationProperties.Name="Home Page"
+                            Command="{Binding LaunchHomePageCommand}"
+                            KeyboardNavigation.IsTabStop="False"
+                            Style="{StaticResource HyperlinkedButtonStyle}">
+                        <TextBlock HorizontalAlignment="Left">
+                            <Hyperlink Command="{Binding LaunchHomePageCommand}"
+                                       IsEnabled="True"
+                                       KeyboardNavigation.IsTabStop="False"><Run FontSize="{DynamicResource FontSizeButton}" Text="{Binding SupportUrl, Mode=OneTime}" /></Hyperlink>
+                        </TextBlock>
+                    </Button>
+
+                    <TextBlock x:Name="SkuVSExtensionLabel1"
+                               Grid.Row="5"
+                               Grid.Column="0"
+                               Style="{DynamicResource LabelTextBlkStyle}"
+                               Text="Visual Studio" />
+                    <TextBlock x:Name="SkuVSExtensionLabel2"
+                               Grid.Row="6"
+                               Grid.Column="0"
+                               Style="{DynamicResource LabelTextBlkStyle}"
+                               Text="Extension:" />
+                    <Button x:Name="SkuVSExtensionBtn"
+                            Grid.Row="6"
+                            Grid.Column="1"
+                            HorizontalAlignment="Left"
+                            AutomationProperties.HelpText="View Releases Page for VS Extension"
+                            AutomationProperties.Name="Releases Page"
+                            Command="{Binding LaunchVSExtensionPageCommand}"
+                            KeyboardNavigation.IsTabStop="False"
+                            Style="{StaticResource HyperlinkedButtonStyle}">
+                        <TextBlock HorizontalAlignment="Left">
+                            <Hyperlink Command="{Binding LaunchVSExtensionPageCommand}"
+                                       IsEnabled="True"
+                                       KeyboardNavigation.IsTabStop="False"><Run FontSize="{DynamicResource FontSizeButton}" Text="{Binding VSExtensionUrl, Mode=OneTime}" /></Hyperlink>
+                        </TextBlock>
+                    </Button>
+                </Grid>
+
+                <DockPanel x:Name="UpdateChangesStkPnlDcIsland"
+                           Grid.Row="0"
+                           Grid.Column="2"
+                           DataContext="{Binding UpdateViewModel}"
+                           Visibility="{Binding IsUpdateAvailable,
+                                                Converter={StaticResource BooleanToVisibilityConverter}}">
+
+                    <Grid x:Name="UpdateInfoGrid"
+                          DockPanel.Dock="Top">
+                        <Grid.RowDefinitions>
+                            <RowDefinition Height="Auto" />
+                        </Grid.RowDefinitions>
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition Width="Auto" />
+                            <ColumnDefinition Width="*" />
+                        </Grid.ColumnDefinitions>
+
+                        <TextBlock x:Name="UpdateTitleLabel"
+                                   Grid.Row="0"
+                                   Grid.Column="0"
+                                   Style="{DynamicResource LabelTextBlkStyle}"
+                                   Text="Available Update:" />
+
+                        <TextBlock x:Name="UpdateVersionLabel"
+                                   Grid.Row="0"
+                                   Grid.Column="1"
+                                   Style="{DynamicResource DataTextBlkStyle}"
+                                   Text="{Binding UpdateVersion}" />
+                    </Grid>
+
+                    <WebBrowser DockPanel.Dock="Bottom"
+                                ux:BrowserProperties.HtmlDoc="{Binding UpdateChanges}" />
+                </DockPanel>
+
+                <TextBlock x:Name="DowngradeMessageTextBlk"
+                           Grid.Row="1"
+                           Grid.Column="0"
+                           Grid.ColumnSpan="3"
+                           DataContext="{Binding InstallationViewModel}"
+                           Style="{DynamicResource LabelTextBlkStyle}"
+                           Text="{Binding DowngradeMessage}"
+                           Visibility="{Binding Downgrade,
+                                                Converter={StaticResource BooleanToVisibilityConverter}}" />
+            </Grid>
+        </DockPanel>
+    </Border>
+</Window>
diff --git a/src/WixToolset.WixBA/RootView.xaml.cs b/src/WixToolset.WixBA/RootView.xaml.cs
new file mode 100644
index 00000000..1d4301f2
--- /dev/null
+++ b/src/WixToolset.WixBA/RootView.xaml.cs
@@ -0,0 +1,51 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.UX
+{
+    using System.ComponentModel;
+    using System.Windows;
+    using System.Windows.Interop;
+
+    /// <summary>
+    /// Interaction logic for View.xaml
+    /// </summary>
+    public partial class RootView : Window
+    {
+        /// <summary>
+        /// Creates the view populated with it's model.
+        /// </summary>
+        /// <param name="viewModel">Model for the view.</param>
+        public RootView(RootViewModel viewModel)
+        {
+            this.DataContext = viewModel;
+
+            this.Loaded += (sender, e) => WixBA.Model.Engine.CloseSplashScreen();
+            this.Closed += (sender, e) => this.Dispatcher.InvokeShutdown(); // shutdown dispatcher when the window is closed.
+
+            this.InitializeComponent();
+
+            viewModel.Dispatcher = this.Dispatcher;
+            viewModel.ViewWindowHandle = new WindowInteropHelper(this).EnsureHandle();
+        }
+
+        /// <summary>
+        /// Event is fired when the window is closing.
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        private void Window_Closing(object sender, CancelEventArgs e)
+        {
+            RootViewModel rvm = this.DataContext as RootViewModel;
+            if ((null != rvm) && (InstallationState.Applying == rvm.InstallState))
+            {
+                rvm.CancelButton_Click();
+                if (rvm.Canceled)
+                {
+                    // Defer closing until the engine has canceled processing.
+                    e.Cancel = true;
+                    rvm.AutoClose = true;
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.WixBA/RootViewModel.cs b/src/WixToolset.WixBA/RootViewModel.cs
new file mode 100644
index 00000000..1de89adf
--- /dev/null
+++ b/src/WixToolset.WixBA/RootViewModel.cs
@@ -0,0 +1,204 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.UX
+{
+    using System;
+    using System.Diagnostics;
+    using System.Reflection;
+    using System.Windows;
+    using System.Windows.Input;
+    using System.Windows.Threading;
+    using WixToolset.Bootstrapper;
+
+    /// <summary>
+    /// The errors returned from the engine
+    /// </summary>
+    public enum Error
+    {
+        UserCancelled = 1223,
+    }
+
+    /// <summary>
+    /// The model of the root view in WixBA.
+    /// </summary>
+    public class RootViewModel : PropertyNotifyBase
+    {
+        private ICommand cancelCommand;
+        private ICommand closeCommand;
+
+        private bool canceled;
+        private InstallationState installState;
+        private DetectionState detectState;
+
+        /// <summary>
+        /// Creates a new model of the root view.
+        /// </summary>
+        public RootViewModel()
+        {
+            this.InstallationViewModel = new InstallationViewModel(this);
+            this.ProgressViewModel = new ProgressViewModel(this);
+            this.UpdateViewModel = new UpdateViewModel(this);
+        }
+
+        public InstallationViewModel InstallationViewModel { get; private set; }
+        public ProgressViewModel ProgressViewModel { get; private set; }
+        public UpdateViewModel UpdateViewModel { get; private set; }
+        public Dispatcher Dispatcher { get; set; }
+        public IntPtr ViewWindowHandle { get; set; }
+        public bool AutoClose { get; set; }
+
+        public ICommand CloseCommand
+        {
+            get
+            {
+                if (this.closeCommand == null)
+                {
+                    this.closeCommand = new RelayCommand(param => WixBA.View.Close());
+                }
+
+                return this.closeCommand;
+            }
+        }
+
+        public ICommand CancelCommand
+        {
+            get
+            {
+                if (this.cancelCommand == null)
+                {
+                    this.cancelCommand = new RelayCommand(param =>
+                    {
+                        this.CancelButton_Click();
+                    },
+                    param => !this.Canceled);
+                }
+
+                return this.cancelCommand;
+            }
+        }
+
+        public bool CancelAvailable
+        {
+            get { return InstallationState.Applying == this.InstallState; }
+        }
+
+        public bool Canceled
+        {
+            get
+            {
+                return this.canceled;
+            }
+
+            set
+            {
+                if (this.canceled != value)
+                {
+                    this.canceled = value;
+                    base.OnPropertyChanged("Canceled");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets and sets the detect state of the view's model.
+        /// </summary>
+        public DetectionState DetectState
+        {
+            get
+            {
+                return this.detectState;
+            }
+
+            set
+            {
+                if (this.detectState != value)
+                {
+                    this.detectState = value;
+
+                    // Notify all the properties derived from the state that the state changed.
+                    base.OnPropertyChanged("DetectState");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets and sets the installation state of the view's model.
+        /// </summary>
+        public InstallationState InstallState
+        {
+            get
+            {
+                return this.installState;
+            }
+
+            set
+            {
+                if (this.installState != value)
+                {
+                    this.installState = value;
+
+                    // Notify all the properties derived from the state that the state changed.
+                    base.OnPropertyChanged("InstallState");
+                    base.OnPropertyChanged("CancelAvailable");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets and sets the state of the view's model before apply begins in order to return to that state if cancel or rollback occurs.
+        /// </summary>
+        public InstallationState PreApplyState { get; set; }
+
+        /// <summary>
+        /// Gets and sets the path where the bundle is currently installed or will be installed.
+        /// </summary>
+        public string InstallDirectory
+        {
+            get
+            {
+                return WixBA.Model.InstallDirectory;
+            }
+
+            set
+            {
+                if (WixBA.Model.InstallDirectory != value)
+                {
+                    WixBA.Model.InstallDirectory = value;
+                    base.OnPropertyChanged("InstallDirectory");
+                }
+            }
+        }
+
+        /// <summary>
+        /// The Title of this bundle.
+        /// </summary>
+        public string Title
+        {
+            get
+            {
+                return WixDistribution.ShortProduct;
+            }
+        }
+
+        /// <summary>
+        /// Prompts the user to make sure they want to cancel.
+        /// This needs to run on the UI thread, use Dispatcher.Invoke to call this from a background thread.
+        /// </summary>
+        public void CancelButton_Click()
+        {
+            if (this.Canceled)
+            {
+                return;
+            }
+
+            if (Display.Full == WixBA.Model.Command.Display)
+            {
+                this.Canceled = (MessageBoxResult.Yes == MessageBox.Show(WixBA.View, "Are you sure you want to cancel?", "WiX Toolset", MessageBoxButton.YesNo, MessageBoxImage.Error));
+            }
+            else
+            {
+                this.Canceled = true;
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.WixBA/Styles.xaml b/src/WixToolset.WixBA/Styles.xaml
new file mode 100644
index 00000000..89ccd2ea
--- /dev/null
+++ b/src/WixToolset.WixBA/Styles.xaml
@@ -0,0 +1,194 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!-- Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. -->
+
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    xmlns:System="clr-namespace:System;assembly=mscorlib"
+                    xmlns:po="http://schemas.microsoft.com/winfx/2006/xaml/presentation/options"
+                    xmlns:shell="clr-namespace:System.Windows.Shell;assembly=PresentationFramework"
+                    xmlns:ux="clr-namespace:WixToolset.UX">
+
+    <!-- Converters -->
+    <BooleanToVisibilityConverter x:Key="BooleanToVisibilityConverter" />
+
+    <!-- Fonts -->
+    <FontFamily x:Key="FontFamily">Segoe UI, Arial</FontFamily>
+    <System:Double x:Key="FontSizeBranding">45</System:Double>
+    <System:Double x:Key="FontSizeMedium">12</System:Double>
+    <System:Double x:Key="FontSizeButton">14</System:Double>
+
+    <!-- Images -->
+    <BitmapImage x:Key="LogoOverLightBackground" UriSource="pack://application:,,,/WixBA;component/resources/logo-white-hollow.png" />
+    <BitmapImage x:Key="LogoOverDarkBackground" UriSource="pack://application:,,,/WixBA;component/resources/logo-black-hollow.png" />
+
+    <!-- Colors -->
+    <Color x:Key="ProgressIndicatorColor">#FF1EF1E8</Color>
+
+    <!-- Brushs -->
+    <SolidColorBrush x:Key="ProgressIndicatorBrush" Color="{DynamicResource ProgressIndicatorColor}" />
+
+    <LinearGradientBrush x:Key="ProgressBarIndicatorAnimatedFill" StartPoint="0,0" EndPoint="1,0">
+        <LinearGradientBrush.GradientStops>
+            <GradientStopCollection>
+                <GradientStop Offset="0" Color="#000000FF" />
+                <GradientStop Offset="0.5" Color="#600000FF" />
+                <GradientStop Offset="0.54" Color="{DynamicResource {x:Static SystemColors.ControlTextColorKey}}" />
+                <GradientStop Offset="0.56" Color="{DynamicResource {x:Static SystemColors.ControlTextColorKey}}" />
+                <GradientStop Offset="0.6" Color="#600000FF" />
+                <GradientStop Offset="1" Color="#000000FF" />
+            </GradientStopCollection>
+        </LinearGradientBrush.GradientStops>
+    </LinearGradientBrush>
+
+    <!-- Control Templates -->
+    <ControlTemplate x:Key="HyperlinkedButtonTemplateKey" TargetType="{x:Type Button}">
+        <ContentPresenter Margin="{TemplateBinding Control.Padding}"
+                          HorizontalAlignment="{TemplateBinding Control.HorizontalContentAlignment}"
+                          VerticalAlignment="{TemplateBinding Control.VerticalContentAlignment}"
+                          Content="{TemplateBinding ContentControl.Content}"
+                          ContentTemplate="{TemplateBinding ContentControl.ContentTemplate}"
+                          SnapsToDevicePixels="{TemplateBinding UIElement.SnapsToDevicePixels}" />
+    </ControlTemplate>
+
+    <ControlTemplate x:Key="ProgressBarTemplateKey" TargetType="{x:Type ProgressBar}">
+        <Border Name="TemplateRoot"
+                Margin="0,5"
+                BorderBrush="{TemplateBinding BorderBrush}"
+                BorderThickness="{TemplateBinding BorderThickness}"
+                CornerRadius="3">
+            <Grid ClipToBounds="True" SnapsToDevicePixels="true">
+                <Rectangle Fill="{TemplateBinding Background}" />
+                <Rectangle Name="PART_Track" ClipToBounds="True" />
+                <Decorator x:Name="PART_Indicator" HorizontalAlignment="Left">
+                    <Grid Name="Foreground">
+                        <Rectangle x:Name="Indicator" Fill="{TemplateBinding Foreground}" />
+                        <Grid x:Name="Animation">
+                            <Rectangle x:Name="PART_GlowRect"
+                                       Width="80"
+                                       Margin="-100,0,0,0"
+                                       HorizontalAlignment="Left"
+                                       Fill="{StaticResource ProgressBarIndicatorAnimatedFill}" />
+                        </Grid>
+                    </Grid>
+                </Decorator>
+            </Grid>
+        </Border>
+    </ControlTemplate>
+
+    <!-- Styles -->
+    <Style x:Key="ActionBtnStkPnlStyle" TargetType="StackPanel">
+        <Setter Property="Margin" Value="0,2,0,0" />
+        <Setter Property="HorizontalAlignment" Value="Center" />
+    </Style>
+
+    <Style x:Key="FinalActionsStkPnlStyle" TargetType="StackPanel">
+        <Setter Property="Margin" Value="80,2,0,0" />
+    </Style>
+
+    <Style x:Key="BrandStkPnlStyle" TargetType="StackPanel">
+        <Setter Property="Margin" Value="0,0,20,0" />
+        <Setter Property="VerticalAlignment" Value="Top" />
+        <Setter Property="HorizontalAlignment" Value="Right" />
+        <Setter Property="Width" Value="100" />
+        <Setter Property="Width" Value="100" />
+    </Style>
+
+    <Style x:Key="CommonTextBlkStyle" TargetType="TextBlock">
+        <Setter Property="VerticalAlignment" Value="Center" />
+        <Setter Property="HorizontalAlignment" Value="Center" />
+        <Setter Property="FontWeight" Value="Bold" />
+        <Setter Property="TextAlignment" Value="Center" />
+        <Setter Property="TextWrapping" Value="WrapWithOverflow" />
+        <Setter Property="FontFamily" Value="{DynamicResource FontFamily}" />
+    </Style>
+
+    <Style x:Key="TitleTextBlkStyle"
+           BasedOn="{StaticResource CommonTextBlkStyle}"
+           TargetType="TextBlock">
+        <Setter Property="VerticalAlignment" Value="Top" />
+        <Setter Property="HorizontalAlignment" Value="Left" />
+        <Setter Property="FontSize" Value="{DynamicResource ResourceKey=FontSizeBranding}" />
+        <Setter Property="FontWeight" Value="ExtraBold" />
+        <Setter Property="Margin" Value="0,5,0,0" />
+    </Style>
+
+
+    <Style x:Key="LabelTextBlkStyle"
+           BasedOn="{StaticResource CommonTextBlkStyle}"
+           TargetType="TextBlock">
+        <Setter Property="HorizontalAlignment" Value="Left" />
+        <Setter Property="FontSize" Value="{DynamicResource FontSizeButton}" />
+        <Setter Property="FontWeight" Value="Bold" />
+        <Setter Property="TextAlignment" Value="Left" />
+        <Setter Property="Margin" Value="0,2,3,0" />
+    </Style>
+
+    <Style x:Key="DataTextBlkStyle"
+           BasedOn="{StaticResource CommonTextBlkStyle}"
+           TargetType="TextBlock">
+        <Setter Property="HorizontalAlignment" Value="Left" />
+        <Setter Property="FontSize" Value="{DynamicResource FontSizeMedium}" />
+        <Setter Property="TextAlignment" Value="Left" />
+        <Setter Property="Margin" Value="2,2,3,0" />
+    </Style>
+
+    <Style x:Key="StatusTextStyle"
+           BasedOn="{StaticResource CommonTextBlkStyle}"
+           TargetType="TextBlock">
+        <Setter Property="FontFamily" Value="{DynamicResource {x:Static SystemFonts.MessageFontFamilyKey}}" />
+        <Setter Property="FontSize" Value="{DynamicResource FontSizeMedium}" />
+        <Setter Property="Margin" Value="8" />
+        <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}" />
+        <Setter Property="VerticalAlignment" Value="Top" />
+        <Setter Property="HorizontalAlignment" Value="Left" />
+    </Style>
+
+    <Style x:Key="ActionButtonStyle" TargetType="Button">
+        <Setter Property="MinHeight" Value="30" />
+        <Setter Property="MinWidth" Value="100" />
+        <Setter Property="Margin" Value="5,0,0,0" />
+        <Setter Property="VerticalAlignment" Value="Center" />
+        <Setter Property="VerticalContentAlignment" Value="Center" />
+        <Setter Property="HorizontalAlignment" Value="Center" />
+        <Setter Property="HorizontalContentAlignment" Value="Center" />
+        <Setter Property="FontFamily" Value="{DynamicResource FontFamily}" />
+    </Style>
+
+    <Style x:Key="FinalActionButtonStyle"
+           BasedOn="{StaticResource ActionButtonStyle}"
+           TargetType="Button">
+        <Setter Property="Margin" Value="40,0,0,0" />
+    </Style>
+
+    <Style x:Key="HyperlinkedButtonStyle" TargetType="Button">
+        <Setter Property="Margin" Value="0,2,0,0" />
+        <Setter Property="Template" Value="{StaticResource HyperlinkedButtonTemplateKey}" />
+        <Setter Property="IsHitTestVisible" Value="True" />
+    </Style>
+
+    <Style x:Key="LogoStyle" TargetType="Image">
+        <Setter Property="Height" Value="65" />
+        <Setter Property="Width" Value="102" />
+        <Setter Property="VerticalAlignment" Value="Top" />
+        <Setter Property="IsHitTestVisible" Value="False" />
+        <Setter Property="Source" Value="{DynamicResource LogoOverLightBackground}" />
+        <Style.Triggers>
+            <DataTrigger Binding="{Binding Path=IsLightBackground, Source={x:Static ux:WindowProperties.Instance}}" Value="false">
+                <Setter Property="Source" Value="{DynamicResource LogoOverDarkBackground}" />
+            </DataTrigger>
+        </Style.Triggers>
+    </Style>
+
+    <Style x:Key="UpdateMarqueeStyle" TargetType="ProgressBar">
+        <Setter Property="Foreground" Value="{DynamicResource ProgressIndicatorBrush}" />
+        <Setter Property="BorderBrush" Value="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}" />
+        <Setter Property="BorderThickness" Value="1" />
+    </Style>
+
+    <Style x:Key="ActionProgressStyle" TargetType="ProgressBar">
+        <Setter Property="Foreground" Value="{DynamicResource ProgressIndicatorBrush}" />
+        <Setter Property="BorderBrush" Value="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}" />
+        <Setter Property="BorderThickness" Value="1" />
+        <Setter Property="Template" Value="{StaticResource ProgressBarTemplateKey}" />
+    </Style>
+</ResourceDictionary>
diff --git a/src/WixToolset.WixBA/UpdateViewModel.cs b/src/WixToolset.WixBA/UpdateViewModel.cs
new file mode 100644
index 00000000..6b60112c
--- /dev/null
+++ b/src/WixToolset.WixBA/UpdateViewModel.cs
@@ -0,0 +1,207 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.UX
+{
+    using System;
+    using System.ComponentModel;
+    using System.Windows.Input;
+    using WixToolset.Bootstrapper;
+
+    /// <summary>
+    /// The states of the update view model.
+    /// </summary>
+    public enum UpdateState
+    {
+        Unknown,
+        Initializing,
+        Checking,
+        Current,
+        Available,
+        Failed,
+    }
+
+    /// <summary>
+    /// The model of the update view.
+    /// </summary>
+    public class UpdateViewModel : PropertyNotifyBase
+    {
+        private RootViewModel root;
+        private UpdateState state;
+        private ICommand updateCommand;
+        private string updateVersion;
+        private string updateChanges;
+
+
+        public UpdateViewModel(RootViewModel root)
+        {
+            this.root = root;
+            WixBA.Model.Bootstrapper.DetectUpdateBegin += this.DetectUpdateBegin;
+            WixBA.Model.Bootstrapper.DetectUpdate += this.DetectUpdate;
+            WixBA.Model.Bootstrapper.DetectUpdateComplete += this.DetectUpdateComplete;
+
+            this.root.PropertyChanged += new PropertyChangedEventHandler(this.RootPropertyChanged);
+
+            this.State = UpdateState.Initializing;
+        }
+
+        void RootPropertyChanged(object sender, PropertyChangedEventArgs e)
+        {
+            if ("InstallState" == e.PropertyName)
+            {
+                base.OnPropertyChanged("CanUpdate");
+            }
+        }
+
+        public bool CheckingEnabled
+        {
+            get { return this.State == UpdateState.Initializing || this.State == UpdateState.Checking; }
+        }
+
+        public bool CanUpdate
+        {
+            get
+            {
+                switch(this.root.InstallState)
+                {
+                    case InstallationState.Waiting:
+                    case InstallationState.Applied:
+                    case InstallationState.Failed:
+                        return this.IsUpdateAvailable;
+                    default:
+                        return false;
+                }
+            }
+        }
+
+        public ICommand UpdateCommand
+        {
+            get
+            {
+                if (this.updateCommand == null)
+                {
+                    this.updateCommand = new RelayCommand(param => WixBA.Plan(LaunchAction.UpdateReplace), param => this.CanUpdate);
+                }
+
+                return this.updateCommand;
+            }
+        }
+
+        public bool IsUpdateAvailable
+        {
+            get { return this.State == UpdateState.Available; }
+        }
+
+        /// <summary>
+        /// Gets and sets the state of the update view model.
+        /// </summary>
+        public UpdateState State
+        {
+            get
+            {
+                return this.state;
+            }
+
+            set
+            {
+                if (this.state != value)
+                {
+                    this.state = value;
+                    base.OnPropertyChanged("State");
+                    base.OnPropertyChanged("CanUpdate");
+                    base.OnPropertyChanged("CheckingEnabled");
+                    base.OnPropertyChanged("IsUpdateAvailable");
+                }
+            }
+        }
+        /// <summary>
+        /// The version of an available update.
+        /// </summary>
+        public string UpdateVersion
+        {
+            get
+            {
+                return updateVersion;
+            }
+            set
+            {
+                if (this.updateVersion != value)
+                {
+                    this.updateVersion = value;
+                    base.OnPropertyChanged("UpdateVersion");
+                }
+            }
+        }
+
+        /// <summary>
+        /// The changes in the available update.
+        /// </summary>
+        public string UpdateChanges
+        {
+            get
+            {
+                return updateChanges;
+            }
+            set
+            {
+                if (this.updateChanges != value)
+                {
+                    this.updateChanges = value;
+                    base.OnPropertyChanged("UpdateChanges");
+                }
+            }
+        }
+
+        private void DetectUpdateBegin(object sender, Bootstrapper.DetectUpdateBeginEventArgs e)
+        {
+            // Don't check for updates if:
+            //   the first check failed (no retry)
+            //   if we are being run as an uninstall
+            //   if we are not under a full UI.
+            if ((UpdateState.Failed != this.State) && (LaunchAction.Uninstall != WixBA.Model.Command.Action) && (Display.Full == WixBA.Model.Command.Display))
+            {
+                this.State = UpdateState.Checking;
+                e.Skip = false;
+            }
+        }
+        
+        private void DetectUpdate(object sender, Bootstrapper.DetectUpdateEventArgs e)
+        {
+            // The list of updates is sorted in descending version, so the first callback should be the largest update available.
+            // This update should be either larger than ours (so we are out of date), the same as ours (so we are current)
+            // or smaller than ours (we have a private build). If we really wanted to, we could leave the e.StopProcessingUpdates alone and
+            // enumerate all of the updates.
+            WixBA.Model.Engine.Log(LogLevel.Verbose, String.Format("Potential update v{0} from '{1}'; current version: v{2}", e.Version, e.UpdateLocation, WixBA.Model.Version));
+            if (e.Version > WixBA.Model.Version)
+            {
+                WixBA.Model.Engine.SetUpdate(null, e.UpdateLocation, e.Size, UpdateHashType.None, null);
+                this.UpdateVersion = String.Concat("v", e.Version.ToString());
+                string changesFormat = @"<body style='overflow: auto;'>{0}</body>";
+                this.UpdateChanges = String.Format(changesFormat, e.Content);
+                this.State = UpdateState.Available;
+            }
+            else
+            {
+                this.State = UpdateState.Current;
+            }
+            e.StopProcessingUpdates = true;
+        }
+
+        private void DetectUpdateComplete(object sender, Bootstrapper.DetectUpdateCompleteEventArgs e)
+        {
+            // Failed to process an update, allow the existing bundle to still install.
+            if ((UpdateState.Failed != this.State) && !Hresult.Succeeded(e.Status))
+            {
+                this.State = UpdateState.Failed;
+                WixBA.Model.Engine.Log(LogLevel.Verbose, String.Format("Failed to locate an update, status of 0x{0:X8}, updates disabled.", e.Status));
+                e.IgnoreError = true;
+            }
+            // If we are uninstalling, we don't want to check or show an update
+            // If we are checking, then the feed didn't find any valid enclosures
+            // If we are initializing, we're either uninstalling or not a full UI
+            else if ((LaunchAction.Uninstall == WixBA.Model.Command.Action) || (UpdateState.Initializing == this.State) || (UpdateState.Checking == this.State))
+            {
+                this.State = UpdateState.Unknown;
+            }            
+        }
+    }
+}
diff --git a/src/WixToolset.WixBA/WindowProperties.cs b/src/WixToolset.WixBA/WindowProperties.cs
new file mode 100644
index 00000000..bead5cc1
--- /dev/null
+++ b/src/WixToolset.WixBA/WindowProperties.cs
@@ -0,0 +1,65 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.UX
+{
+    using System;
+    using System.Windows;
+    using System.Windows.Media;
+
+    /// <summary>
+    /// Dependency Properties associated with the main Window object.
+    /// </summary>
+    public class WindowProperties : DependencyObject
+    {
+        /// <summary>
+        /// Dependency Property to hold the result of detecting the relative luminosity (or brightness) of a Windows background.
+        /// </summary>
+        public static readonly DependencyProperty IsLightBackgroundProperty = DependencyProperty.Register(
+            "IsLightBackground", typeof(bool), typeof(WindowProperties), new PropertyMetadata( false ));
+
+        private static Lazy<WindowProperties> _instance = new Lazy<WindowProperties>(() =>
+        {
+            WindowProperties wp = new WindowProperties();
+            wp.CheckBackgroundBrightness();
+            return wp;
+        });
+
+        public static WindowProperties Instance
+        {
+            get
+            {
+                return _instance.Value;
+            }
+        }
+
+
+        public bool IsLightBackground
+        {
+            get { return (bool)GetValue(IsLightBackgroundProperty); }
+            private set { SetValue(IsLightBackgroundProperty, value); }
+        }
+
+        /// <summary>
+        /// Use the Luminosity parameter of the background color to detect light vs dark theme settings.
+        /// </summary>
+        /// <remarks>
+        /// This approach detects both the common High Contrast themes (White vs Black) and custom themes which may have relatively lighter backgrounds.
+        /// </remarks>
+        public void CheckBackgroundBrightness()
+        {
+            SolidColorBrush windowbrush = System.Windows.SystemColors.WindowBrush;
+            System.Drawing.Color dcolor = System.Drawing.Color.FromArgb(windowbrush.Color.A, windowbrush.Color.R, windowbrush.Color.G, windowbrush.Color.B);
+
+            var brightness = dcolor.GetBrightness();
+            // Test for 'Lightness' at an arbitrary point, approaching 1.0 (White).           
+            if (0.7 < brightness)
+            {
+                this.IsLightBackground = true;
+            }
+            else
+            {
+                this.IsLightBackground = false;
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.WixBA/WixBA.BootstrapperCore.config b/src/WixToolset.WixBA/WixBA.BootstrapperCore.config
new file mode 100644
index 00000000..8e1d4729
--- /dev/null
+++ b/src/WixToolset.WixBA/WixBA.BootstrapperCore.config
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!-- Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. -->
+
+<configuration>
+    <configSections>
+        <sectionGroup name="wix.bootstrapper" type="WixToolset.Bootstrapper.BootstrapperSectionGroup, BootstrapperCore">
+            <section name="host" type="WixToolset.Bootstrapper.HostSection, BootstrapperCore" />
+        </sectionGroup>
+    </configSections>
+    <startup useLegacyV2RuntimeActivationPolicy="true">
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
+    </startup>
+    <wix.bootstrapper>
+        <host assemblyName="WixBA" />
+    </wix.bootstrapper>
+</configuration>
diff --git a/src/WixToolset.WixBA/WixBA.cs b/src/WixToolset.WixBA/WixBA.cs
new file mode 100644
index 00000000..fb69a346
--- /dev/null
+++ b/src/WixToolset.WixBA/WixBA.cs
@@ -0,0 +1,216 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.UX
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.IO;
+    using System.Net;
+    using System.Text;
+    using System.Windows.Input;
+    using Threading = System.Windows.Threading;
+    using WinForms = System.Windows.Forms;
+
+    using WixToolset.Bootstrapper;
+
+    /// <summary>
+    /// The WiX toolset user experience.
+    /// </summary>
+    public class WixBA : BootstrapperApplication
+    {
+        /// <summary>
+        /// Gets the global model.
+        /// </summary>
+        static public Model Model { get; private set; }
+
+        /// <summary>
+        /// Gets the global view.
+        /// </summary>
+        static public RootView View { get; private set; }
+        // TODO: We should refactor things so we dont have a global View.
+
+        /// <summary>
+        /// Gets the global dispatcher.
+        /// </summary>
+        static public Threading.Dispatcher Dispatcher { get; private set; }
+
+        /// <summary>
+        /// Launches the default web browser to the provided URI.
+        /// </summary>
+        /// <param name="uri">URI to open the web browser.</param>
+        public static void LaunchUrl(string uri)
+        {
+            WixBA.UseShellExecute(uri);
+        }
+
+        /// <summary>
+        /// Open a log file.
+        /// </summary>
+        /// <param name="uri">URI to a log file.</param>
+        internal static void OpenLog(Uri uri)
+        {
+            WixBA.UseShellExecute(uri.ToString());
+        }
+
+        /// <summary>
+        /// Open a log folder.
+        /// </summary>
+        /// <param name="string">path to a log folder.</param>
+        internal static void OpenLogFolder(string logFolder)
+        {
+            WixBA.UseShellExecute(logFolder);
+        }
+
+        /// <summary>
+        /// Open a log folder.
+        /// </summary>
+        /// <param name="uri">path to a log folder.</param>
+        private static void UseShellExecute(string path)
+        {
+            // Switch the wait cursor since shellexec can take a second or so.
+            System.Windows.Input.Cursor cursor = WixBA.View.Cursor;
+            WixBA.View.Cursor = System.Windows.Input.Cursors.Wait;
+            Process process = null;
+            try
+            {
+                process = new Process();
+                process.StartInfo.FileName = path;
+                process.StartInfo.UseShellExecute = true;
+                process.StartInfo.Verb = "open";
+
+                process.Start();
+            }
+            finally
+            {
+                if (null != process)
+                {
+                    process.Dispose();
+                }
+                // back to the original cursor.
+                WixBA.View.Cursor = cursor;
+            }
+        }
+
+        /// <summary>
+        /// Starts planning the appropriate action.
+        /// </summary>
+        /// <param name="action">Action to plan.</param>
+        public static void Plan(LaunchAction action)
+        {
+            WixBA.Model.PlannedAction = action;
+            WixBA.Model.Engine.Plan(WixBA.Model.PlannedAction);
+        }
+
+        public static void PlanLayout()
+        {
+            // Either default or set the layout directory
+            if (String.IsNullOrEmpty(WixBA.Model.Command.LayoutDirectory))
+            {
+                WixBA.Model.LayoutDirectory = Directory.GetCurrentDirectory();
+
+                // Ask the user for layout folder if one wasn't provided and we're in full UI mode
+                if (WixBA.Model.Command.Display == Display.Full)
+                {
+                    WixBA.Dispatcher.Invoke((Action)delegate()
+                    {
+                        WinForms.FolderBrowserDialog browserDialog = new WinForms.FolderBrowserDialog();
+                        browserDialog.RootFolder = Environment.SpecialFolder.MyComputer;
+
+                        // Default to the current directory.
+                        browserDialog.SelectedPath = WixBA.Model.LayoutDirectory;
+                        WinForms.DialogResult result = browserDialog.ShowDialog();
+
+                        if (WinForms.DialogResult.OK == result)
+                        {
+                            WixBA.Model.LayoutDirectory = browserDialog.SelectedPath;
+                            WixBA.Plan(WixBA.Model.Command.Action);
+                        }
+                        else
+                        {
+                            WixBA.View.Close();
+                        }
+                    }
+                    );
+                }
+            }
+            else
+            {
+                WixBA.Model.LayoutDirectory = WixBA.Model.Command.LayoutDirectory;
+                WixBA.Plan(WixBA.Model.Command.Action);
+            }
+        }
+
+        /// <summary>
+        /// Thread entry point for WiX Toolset UX.
+        /// </summary>
+        protected override void Run()
+        {
+            this.Engine.Log(LogLevel.Verbose, "Running the WiX BA.");
+            WixBA.Model = new Model(this);
+            WixBA.Dispatcher = Threading.Dispatcher.CurrentDispatcher;
+            RootViewModel viewModel = new RootViewModel();
+
+            // Kick off detect which will populate the view models.
+            this.Engine.Detect();
+
+            // Create a Window to show UI.
+            if (WixBA.Model.Command.Display == Display.Passive ||
+                WixBA.Model.Command.Display == Display.Full)
+            {
+                this.Engine.Log(LogLevel.Verbose, "Creating a UI.");
+                WixBA.View = new RootView(viewModel);
+                WixBA.View.Show();
+            }
+
+            Threading.Dispatcher.Run();
+
+            this.PostTelemetry();
+            this.Engine.Quit(WixBA.Model.Result);
+        }
+
+        private void PostTelemetry()
+        {
+            string result = String.Concat("0x", WixBA.Model.Result.ToString("x"));
+
+            StringBuilder telemetryData = new StringBuilder();
+            foreach (KeyValuePair<string, string> kvp in WixBA.Model.Telemetry)
+            {
+                telemetryData.AppendFormat("{0}={1}+", kvp.Key, kvp.Value);
+            }
+            telemetryData.AppendFormat("Result={0}", result);
+
+            byte[] data = Encoding.UTF8.GetBytes(telemetryData.ToString());
+
+            try
+            {
+                HttpWebRequest post = WixBA.Model.CreateWebRequest(String.Format(WixDistribution.TelemetryUrlFormat, WixBA.Model.Version.ToString(), result));
+                post.Method = "POST";
+                post.ContentType = "application/x-www-form-urlencoded";
+                post.ContentLength = data.Length;
+
+                using (Stream postStream = post.GetRequestStream())
+                {
+                    postStream.Write(data, 0, data.Length);
+                }
+
+                HttpWebResponse response = (HttpWebResponse)post.GetResponse();
+            }
+            catch (ArgumentException)
+            {
+            }
+            catch (FormatException)
+            {
+            }
+            catch (OverflowException)
+            {
+            }
+            catch (ProtocolViolationException)
+            {
+            }
+            catch (WebException)
+            {
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.WixBA/WixBA.csproj b/src/WixToolset.WixBA/WixBA.csproj
new file mode 100644
index 00000000..6858b172
--- /dev/null
+++ b/src/WixToolset.WixBA/WixBA.csproj
@@ -0,0 +1,64 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. -->
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="12.0">
+  <PropertyGroup>
+    <ProjectGuid>{7C27518B-84AD-4679-8EF4-29DF552CF1AC}</ProjectGuid>
+    <AssemblyName>WixBA</AssemblyName>
+    <OutputType>Library</OutputType>
+    <RootNamespace>WixToolset.UX</RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="Hresult.cs" />
+    <Compile Include="Model.cs" />
+    <Compile Include="BrowserProperties.cs" />
+    <Compile Include="NewsItem.cs" />
+    <Compile Include="ProgressViewModel.cs" />
+    <Compile Include="RelayCommand.cs" />
+    <Compile Include="InstallationViewModel.cs" />
+    <Page Include="Styles.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
+    <Page Include="RootView.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
+    <Compile Include="PropertyNotifyBase.cs" />
+    <Compile Include="RootView.xaml.cs">
+      <DependentUpon>RootView.xaml</DependentUpon>
+    </Compile>
+    <Compile Include="RootViewModel.cs" />
+    <Compile Include="UpdateViewModel.cs" />
+    <Compile Include="WindowProperties.cs" />
+    <Compile Include="WixBA.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <None Include="WixBA.BootstrapperCore.config">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <SubType>Designer</SubType>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="PresentationCore" />
+    <Reference Include="PresentationFramework" />
+    <Reference Include="System" />
+    <Reference Include="System.ComponentModel.DataAnnotations" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="System.ServiceModel" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Xml" />
+    <Reference Include="System.Xaml" />
+    <Reference Include="WindowsBase" />
+    <ProjectReference Include="..\..\ext\BalExtension\mba\core\core.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <Resource Include="Resources\logo-white-hollow.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <Resource Include="Resources\logo-black-hollow.png" />
+  </ItemGroup>
+  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildProjectDirectory), wix.proj))\tools\WixBuild.targets" />
+</Project>
\ No newline at end of file