private void DetectComplete(object sender, DetectCompleteEventArgs e)
{
if (ba.Command.Action == LaunchAction.Uninstall)
{
ba.Engine.Log(LogLevel.Verbose, "Invoking automatic plan for uninstall");
Execute.OnUIThread(() =>
{
this.Plan(LaunchAction.Uninstall);
});
}
else if (HResultSucceeded(e.Status))
{
if (this.Downgrade)
{
// TODO: What behavior do we want for downgrade?
this.State = InstallationState.DetectedNewer;
}
// If we're not waiting for the user to click install, dispatch plan with the default action.
if (ba.Command.Display != Display.Full)
{
ba.Engine.Log(LogLevel.Verbose, "Invoking automatic plan for non-interactive mode.");
Execute.OnUIThread(() =>
{
this.Plan(ba.Command.Action);
});
}
}
else
{
this.State = InstallationState.Failed;
}
}
private void OnDetectComplete(object sender, DetectCompleteEventArgs e)
{
InstallState = InstallationState.Waiting;
if (_bootstrapper.Command.Action == LaunchAction.Uninstall)
{
Plan(LaunchAction.Uninstall);
}
else if (e.Status >= 0)
{
if (_downgrade)
{
DetectState = DetectionState.Newer;
}
if (_bootstrapper.Command.Display != Display.Full)
{
Plan(_bootstrapper.Command.Action);
}
}
else
{
InstallState = InstallationState.Failed;
}
// Force all commands to reevaluate CanExecute.
// InvalidateRequerySuggested must be run on the UI thread.
PicoBA.Dispatcher.Invoke(new Action(CommandManager.InvalidateRequerySuggested));
InstallModel.Refresh();
}
protected void DetectComplete(object sender, DetectCompleteEventArgs e)
{
this._model.LogMessage("DetectComplete event fired.");
this.InstallVisible = true;
this.UninstallVisible = true;
this.FinishVisible = false;
var commandLineArgs = this.ParseCommandLineArgs();
if (commandLineArgs != null)
{
//add the code here to handle any command line arguments
}
//When the /s or /silent switch is passed to the bootstrapper command prompt we do not want to display any UI
if (this.DisplayLevel == Display.None)
{
if (this.Action == LaunchAction.Install)
{
EnableAllInstallers();
this._model.PlanAction(LaunchAction.Install);
}
else if (this.Action == LaunchAction.Uninstall)
{
this._model.PlanAction(LaunchAction.Uninstall);
}
}
}
private void DetectComplete(object sender, DetectCompleteEventArgs e)
{
// Parse the command line string before any planning.
this.ParseCommandLine();
if (LaunchAction.Uninstall == WixBA.Model.Command.Action)
{
WixBA.Model.Engine.Log(LogLevel.Verbose, "Invoking automatic plan for uninstall");
WixBA.Plan(LaunchAction.Uninstall);
}
else if (Hresult.Succeeded(e.Status))
{
if (this.Downgrade)
{
// TODO: What behavior do we want for downgrade?
this.root.State = InstallationState.DetectedNewer;
}
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.State = InstallationState.Failed;
}
}
protected override void OnDetectComplete(DetectCompleteEventArgs args)
{
this.result = args.Status;
if (Hresult.Succeeded(this.result) &&
(this.UpdateAvailable || LaunchAction.UpdateReplaceEmbedded != this.action && LaunchAction.UpdateReplace != this.action))
{
if (this.redetectRemaining > 0)
{
this.Log("Completed detection phase: {0} re-runs remaining", this.redetectRemaining--);
}
else if (this.quitAfterDetect)
{
this.ShutdownUiThread();
}
else if (this.explicitlyElevateAndPlanFromOnElevateBegin)
{
this.Engine.Elevate(this.windowHandle);
}
else
{
this.Engine.Plan(this.action);
}
}
else
{
this.ShutdownUiThread();
}
}
private void DetectComplete(object sender, DetectCompleteEventArgs e)
{
if (this.State == UpdateState.Initializing || this.State == UpdateState.Checking)
{
this.State = UpdateState.Unknown;
}
}
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)
{
WixBA.Model.Engine.Log(LogLevel.Verbose, "Invoking automatic plan for uninstall");
WixBA.Plan(LaunchAction.Uninstall);
}
else if (Hresult.Succeeded(e.Status))
{
// block if CLR v2 isn't available; sorry, it's needed for the MSBuild tasks
if (WixBA.Model.Engine.EvaluateCondition("NETFRAMEWORK35_SP_LEVEL < 1"))
{
string message = "WiX Toolset requires the .NET Framework 3.5.1 Windows feature to be enabled.";
WixBA.Model.Engine.Log(LogLevel.Verbose, message);
if (Display.Full == WixBA.Model.Command.Display)
{
WixBA.Dispatcher.Invoke((Action) delegate()
{
MessageBox.Show(message, "WiX Toolset", MessageBoxButton.OK, MessageBoxImage.Error);
if (null != WixBA.View)
{
WixBA.View.Close();
}
}
);
}
this.root.InstallState = InstallationState.Failed;
return;
}
if (this.Downgrade)
{
// TODO: What behavior do we want for downgrade?
this.root.DetectState = DetectionState.Newer;
}
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;
}
}
private void OnDetectComplete(object sender, DetectCompleteEventArgs e)
{
if (_installer.Command.Action == LaunchAction.Uninstall)
{
_engine.Log(LogLevel.Verbose, Resources.InvokingAutomaticPlanForUninstall);
Uninstall = true;
_mainVmFactory.GetViewModelInstance().MoveNextCommand.Execute(null);
}
}
private void OnDetectComplete(object sender, DetectCompleteEventArgs e)
{
if (this.Command.Action == LaunchAction.Uninstall)
{
Engine.Log(LogLevel.Verbose, "Invoking automatic plan for uninstall");
Engine.Plan(LaunchAction.Uninstall);
//Engine.Quit(0); // Doesn't really required
}
}
private void Bootstrapper_DetectComplete(object sender, DetectCompleteEventArgs e)
{
Log(LogLevel.Standard, $"Detection complete. VersionStatus: {VersionStatus}");
if (VersionStatus == VersionStatus.Current)
{
BurnInstallationState = BurnInstallationState.Failed;
Log(LogLevel.Standard, "An attempt to reinstall the application was made.");
if (!IsInteractive)
{
if (Bootstrapper.Command.Action == LaunchAction.Uninstall)
{
PlanAction(Bootstrapper.Command.Action);
return;
}
ShutDownWithCancelCode();
}
}
if (VersionStatus == VersionStatus.NewerAlreadyInstalled)
{
BurnInstallationState = BurnInstallationState.DetectedNewer;
Log(LogLevel.Standard, "An attempt to downgrade the application was made.");
if (IsInteractive)
{
ErrorMessages.Add(string.Format(Resources.Common_NewerVersionInstalledMessage, Bootstrapper.BundleName));
NavigateToPage(PageType.FinishErrorPage);
}
}
else if (IsInteractive)
{
if (IsInstalled)
{
if (BootstrapperUpdateState == UpdateState.Available)
{
// update page
NavigateToPage(PageType.InstallPage);
}
else
{
NavigateToPage(PageType.MaintenancePage);
}
}
else
{
NavigateToPage(PageType.InstallPage);
}
}
else
{
PlanAction(Bootstrapper.Command.Action);
}
}
/// Fired when the detection phase has completed.
static void OnDetectComplete(object sender, DetectCompleteEventArgs e)
{
Logger.Instance.Trace("");
if (_bootstrapperApplication.Command.Action == LaunchAction.Uninstall &&
_bootstrapperApplication.Command.Display == Display.Embedded)
{
Logger.Instance.Trace("Schedule uninstall action when triggered from another bundle");
_bootstrapperApplication.Engine.Plan(LaunchAction.Uninstall);
}
}
protected override void OnDetectComplete(DetectCompleteEventArgs e)
{
base.OnDetectComplete(e);
this._installer.Status = Status.Detected;
if (e.Status >= 0 && this.Command.Display != Display.Full)
{
this.Engine.Log(LogLevel.Verbose, "Invoking automatic plan for non-interactive mode.");
this.Engine.Plan(this.Command.Action);
}
}
protected override void OnDetectComplete(DetectCompleteEventArgs args)
{
this.result = args.Status;
if (Hresult.Succeeded(this.result))
{
this.Engine.Plan(this.action);
}
else
{
this.wait.Set();
}
}
protected override void OnDetectComplete(DetectCompleteEventArgs e)
{
base.OnDetectComplete(e);
this._installer.Status = Status.Detected;
if (e.Status >= 0 && this.Command.Display != Display.Full)
{
this.Engine.Log(LogLevel.Verbose, "Invoking automatic plan for non-interactive mode.");
this.Engine.Plan(this.Command.Action);
}
}
protected override void OnDetectComplete(DetectCompleteEventArgs args)
{
this.result = args.Status;
if (Hresult.Succeeded(this.result) && (this.UpdateAvailable | (!((LaunchAction.UpdateReplaceEmbedded == this.action) | (LaunchAction.UpdateReplace == this.action)))))
{
this.Engine.Plan(this.action);
}
else
{
this.wait.Set();
}
}
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;
var relatedPackages = WixBA.Model.BAManifest.Bundle.Packages.Values.Where(p => p.Type == PackageType.UpgradeBundle);
var 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 SetupApplication_DetectComplete(object sender, DetectCompleteEventArgs e)
{
string logName = "Engine hook SetupApplication_DetectComplete: ";
this.DetectRelatedBundle -= SetupApplication_DetectRelatedBundle;
this.DetectComplete -= SetupApplication_DetectComplete;
if (this.IsInstalled && !this.HasRelatedBundle)
{
this.Log(logName + "Current bundle is already installed and no related bundle was found. Setting launch action to '" + LaunchAction.Uninstall.ToString() + "'");
this.launchAction = LaunchAction.Uninstall;
}
this.Log(logName + "Set DetectComplete WaitHandle");
this.detectCompleteHandle.Set();
}
/// <summary>
/// Fired when detection completes.
/// </summary>
/// <param name="eventArgs">
/// The <see cref="DetectCompleteEventArgs"/> instance containing the event data.
/// </param>
private void DetectComplete(DetectCompleteEventArgs eventArgs)
{
if (this.Installed)
{
if (this.UpgradeDetected)
{
this.ViewController.InstallStageChange(InstallerStage.StartupUpgrade);
}
else
{
this.ViewController.InstallStageChange(InstallerStage.StartupPresent);
}
}
else
{
this.ViewController.InstallStageChange(InstallerStage.StartupNotPresent);
}
}
private void DetectComplete(object sender, DetectCompleteEventArgs e)
{
if (App.Current.Command.Action == LaunchAction.Uninstall)
{
App.Current.Engine.Log(LogLevel.Verbose, "Invoking automatic plan for uninstall");
App.Current.Dispatcher.Invoke(() => Plan(LaunchAction.Uninstall));
}
else if (HResult.Succeeded(e.Status))
{
if (_downgrade)
{
State = InstallationState.DetectedNewer;
}
switch (App.Current.Command.Action)
{
case LaunchAction.Layout:
LayoutFolder = string.IsNullOrEmpty(App.Current.Command.LayoutDirectory)
? InstallFolder + @"\Setup\"
: App.Current.Command.LayoutDirectory;
if (App.Current.Command.Display == Display.Full)
{
State = InstallationState.Layout;
}
break;
case LaunchAction.Help:
State = InstallationState.Help;
break;
default:
if (App.Current.Command.Display != Display.Full)
{
App.Current.Engine.Log(LogLevel.Verbose, "Invoking automatic plan for non-interactive mode.");
App.Current.Dispatcher.Invoke(DispatcherPriority.Send, (Action)(() => Plan(App.Current.Command.Action)));
}
break;
}
}
else
{
State = InstallationState.Failed;
}
}
private void OnDetectComplete(object sender, DetectCompleteEventArgs e)
{
switch (Result)
{
case OperationResult.Downgrade:
_engine.Log(LogLevel.Error, Resources.Downgrade);
if (_installer.Command.Display != Display.Full)
{
_mainVmFactory.GetViewModelInstance().Shutdown((int)SystemErrorCodes.ERROR_INSTALL_PACKAGE_DOWNGRADE);
}
break;
case OperationResult.Cancelled:
Cancel();
break;
case OperationResult.Failed:
Fail();
break;
}
}
private void OnDetectComplete(object sender, DetectCompleteEventArgs e)
{
if (HResult.Succeeded(e.Status))
{
switch (_installer.Command.Action)
{
case LaunchAction.Layout:
Operation = Operation.Layout;
break;
case LaunchAction.Help:
Operation = Operation.Help;
OnUIThread(() =>
{
var helpNavigationItem = _navigationManager.GetNavigationItemByName(NavigationNames.Help);
_navigationManager.Navigate(helpNavigationItem);
});
break;
default:
if (_installer.Command.Display != Display.Full)
{
_engine.Log(LogLevel.Verbose, Resources.InvokingAutomaticPlanForNonInteractiveMode);
_engine.PlanAsync(_installer.Command.Action);
}
break;
}
}
else
{
Operation = Operation.Information;
_completedStepVmFactory.GetViewModelInstance().ExitCode = e.Status;
_completedStepVmFactory.GetViewModelInstance().Result = Cancelled ? OperationResult.Cancelled : OperationResult.Failed;
}
RegisterWizardSteps();
IsInitializing = false;
}
private void DetectComplete(object sender, DetectCompleteEventArgs e)
{
// If necessary, parse the command line string before any planning
// (e.g. detect installation folder)
if (LaunchAction.Uninstall == this.bootstrapper.Command.Action)
{
this.engine.Log(LogLevel.Verbose, "Invoking automatic plan for uninstall");
this.engine.Plan(LaunchAction.Uninstall);
}
else if (e.Status >= 0 /* Success */)
{
if (this.Downgrade)
{
// What do you want to do in case of downgrade?
// Here: Stop installation
string message = "Sorry, we do not support downgrades.";
this.engine.Log(LogLevel.Verbose, message);
if (this.bootstrapper.Command.Display == Display.Full)
{
this.interactionService.ShowMessageBox(message);
this.interactionService.CloseUIAndExit();
}
}
if (this.bootstrapper.Command.Action == LaunchAction.Layout)
{
// Copies all of the Bundle content to a specified directory
this.engine.Plan(LaunchAction.Layout);
}
else if (this.bootstrapper.Command.Display != Display.Full)
{
// If we're not waiting for the user to click install, dispatch plan with the default action.
this.engine.Log(LogLevel.Verbose, "Invoking automatic plan for non-interactive mode.");
this.engine.Plan(LaunchAction.Install);
}
}
}
private void App_DetectComplete(object sender, DetectCompleteEventArgs e)
{
Dispatcher.BeginInvoke(new Action(() => {
if (!WaitForOctgnToClose())
{
Result = ActionResult.UserExit;
Dispatcher.InvokeShutdown();
return;
}
var status = e.Status;
switch (RunMode)
{
case RunMode.Install:
_mainWindow.PageViewModel = new TermsPageViewModel();
break;
case RunMode.Uninstall:
_mainWindow.PageViewModel = new ProgressPageViewModel();
StartUninstall();
break;
case RunMode.Modify:
_mainWindow.PageViewModel = new DirectorySelectionPageViewModel();
break;
case RunMode.UninstallOrModify:
_mainWindow.PageViewModel = new UninstallOrModifyPageViewModel();
break;
default:
throw new NotImplementedException($"RunMode {RunMode} not implemented");;
}
}));
}
private void DetectComplete(object sender, DetectCompleteEventArgs e)
{
if (LaunchAction.Uninstall == CustomBootstrapperApplication.Model.Command.Action)
{
CustomBootstrapperApplication.Model.Engine.Log(LogLevel.Verbose, "Invoking automatic plan for uninstall");
// CustomBootstrapperApplication.Plan(LaunchAction.Uninstall);
}
//else if (Hresult.Succeeded(e.Status))
//{
// if (CustomBootstrapperApplication.Model.Engine.EvaluateCondition("NETFRAMEWORK35_SP_LEVEL < 1"))
// {
// string message = "WiX Toolset requires the .NET Framework 3.5.1 Windows feature to be enabled.";
// CustomBootstrapperApplication.Model.Engine.Log(LogLevel.Verbose, message);
// if (Display.Full == CustomBootstrapperApplication.Model.Command.Display)
// {
// CustomBootstrapperApplication.Dispatcher.Invoke((Action)delegate ()
// {
// MessageBox.Show(message, "DIAView", MessageBoxButton.OK, MessageBoxImage.Error);
// if (null != CustomBootstrapperApplication.View)
// {
// CustomBootstrapperApplication.View.Close();
// }
// }
// );
// }
// State = InstallState.Failed;
// return;
// }
//}
else
{
State = InstallState.Failed;
}
}
private void OnDetectComplete(object sender, DetectCompleteEventArgs e)
{
// Identify the logged in user here itself so that it can be consumed by custom actions later.
this.Bootstrapper.Engine.StringVariables["CURRENTLOGGEDINUSER"] = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
}
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))
{
// TODO: remove this when v4 really doesn't depend on .NET 3.5.
// block if CLR v2 isn't available; sorry, it's needed for the MSBuild tasks
if (WixBA.Model.Engine.EvaluateCondition("NOT NETFRAMEWORK35_SP_LEVEL"))
{
string message = "WiX Toolset requires the .NET Framework 3.5.1 Windows feature to be enabled.";
WixBA.Model.Engine.Log(LogLevel.Verbose, message);
if (Display.Full == WixBA.Model.Command.Display)
{
WixBA.Dispatcher.Invoke((Action) delegate()
{
MessageBox.Show(message, "WiX Toolset", MessageBoxButton.OK, MessageBoxImage.Error);
if (null != WixBA.View)
{
WixBA.View.Close();
}
}
);
}
this.root.InstallState = InstallationState.Failed;
return;
}
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 DetectCompleted(object sender, DetectCompleteEventArgs e)
{
this.model.LogMessage("Detecting has been completed for silent uninstallation.");
this.model.PlanAction(LaunchAction.Uninstall);
}
/// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private void Bootstrapper_DetectComplete(object sender, DetectCompleteEventArgs e)
{
this.ExecuteOnDispatcher(this.OnBootstrapperShouldGoToFirstPage);
}
