void FinishedRestore_PageLeave(object sender, PageChangedArgs args)
{
if (args.Direction == PageChangedDirection.Back)
{
return;
}
if (!RunInBackground.Checked)
{
try
{
m_waitdlg = new Duplicati.GUI.HelperControls.WaitForOperation();
m_waitdlg.Setup(new DoWorkEventHandler(Restore), Strings.FinishedRestore.RestoreWaitDialogTitle, true);
if (m_waitdlg.ShowDialog() != DialogResult.OK)
{
if (m_waitdlg.Error != null)
{
throw m_waitdlg.Error;
}
args.Cancel = true;
return;
}
m_owner.CancelButton.PerformClick();
m_waitdlg = null;
}
catch (Exception ex)
{
MessageBox.Show(this, string.Format(Strings.FinishedRestore.RestoreFailedError, ex.Message), Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
args.Cancel = true;
return;
}
}
void FinishedRestoreSetup_PageLeave(object sender, PageChangedArgs args)
{
if (args.Direction == PageChangedDirection.Back)
{
return;
}
try
{
HelperControls.WaitForOperation dlg = new Duplicati.GUI.HelperControls.WaitForOperation();
dlg.Setup(new DoWorkEventHandler(Restore), Strings.FinishedRestoreSetup.RestoreWaitDialogTitle, true);
if (dlg.ShowDialog() != DialogResult.OK)
{
if (dlg.Error != null)
{
throw dlg.Error;
}
args.Cancel = true;
return;
}
}
catch (Exception ex)
{
MessageBox.Show(this, string.Format(Strings.FinishedRestoreSetup.RestoreFailedError, ex.Message), Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
args.Cancel = true;
return;
}
}
void IncrementalSettings_PageEnter(object sender, PageChangedArgs args)
{
m_wrapper = new WizardSettingsWrapper(m_settings);
bool hasWarnedClean = m_wrapper.CleanupSettingsUI.HasWarnedClean;
if (!m_valuesAutoLoaded)
{
if (m_wrapper.MaxFullBackups > 0)
{
CleanFullBackupCount.Value = m_wrapper.MaxFullBackups;
EnableFullBackupClean.Checked = true;
}
else
{
CleanFullBackupCount.Value = 4;
EnableFullBackupClean.Checked = false;
}
CleanupDuration.Value = m_wrapper.BackupExpireInterval;
EnableCleanupDuration.Checked = !string.IsNullOrEmpty(m_wrapper.BackupExpireInterval);
if (!EnableCleanupDuration.Checked)
{
CleanupDuration.Value = m_wrapper.FullBackupInterval;
}
IgnoreTimestamps.Checked = m_wrapper.IgnoreFileTimestamps;
}
m_wrapper.CleanupSettingsUI.HasWarnedClean = hasWarnedClean;
}
void DeleteFinished_PageEnter(object sender, PageChangedArgs args)
{
m_wrapper = new WizardSettingsWrapper(m_settings);
Summary.Text = string.Format(Strings.DeleteFinished.SummaryText, m_wrapper.ScheduleName);
args.TreatAsLast = true;
}
protected virtual void GridContainer_PageEnter(object sender, PageChangedArgs args)
{
if (!OptionGrid.Unsupported)
{
if (!m_settings.ContainsKey(m_tablekey) || !m_settings.ContainsKey(m_cachekey))
{
Dictionary <string, string> switches = new Dictionary <string, string>();
foreach (KeyValuePair <string, string> p in m_options)
{
if (p.Key.StartsWith("--"))
{
switches.Add(p.Key.Substring(2), p.Value);
}
}
OptionGrid.Setup(m_commands, null, switches);
m_settings[m_tablekey] = OptionGrid.DataSet;
m_settings[m_cachekey] = OptionGrid.DataElementCache;
}
else
{
OptionGrid.DataSet = (DataSet)m_settings[m_tablekey];
OptionGrid.DataElementCache = (Dictionary <string, Library.Interface.ICommandLineArgument>)m_settings[m_cachekey];
}
}
}
protected override void GridContainer_PageEnter(object sender, PageChangedArgs args)
{
base.GridContainer_PageEnter(sender, args);
if (m_options.ContainsKey(GridContainer.DESTINATION_EXTENSION_KEY))
{
Destination.Text = m_options[GridContainer.DESTINATION_EXTENSION_KEY];
}
}
void TargetFolder_PageEnter(object sender, PageChangedArgs args)
{
m_wrapper = new WizardSettingsWrapper(m_settings);
if (PartialRestore.Checked)
{
PartialRestore_CheckedChanged(null, null);
}
}
void FinishedAdd_PageLeave(object sender, PageChangedArgs args)
{
if (args.Direction == PageChangedDirection.Back)
{
return;
}
m_wrapper.RunImmediately = RunNow.Checked;
}
void RunNowFinished_PageLeave(object sender, PageChangedArgs args)
{
if (args.Direction == PageChangedDirection.Back)
{
return;
}
m_wrapper.ForceFull = ForceFull.Checked;
}
void AdvancedOptions_PageEnter(object sender, PageChangedArgs args)
{
m_wrapper = new WizardSettingsWrapper(m_settings);
if (!m_valuesAutoLoaded)
{
IncludeDuplicatiSetup.Checked = m_wrapper.IncludeSetup;
EditOverrides.Checked = m_wrapper.Overrides.Count > 0;
}
}
private void OnPageChangedCommand(PageChangedArgs parameter)
{
if (LoadOptions == null || parameter == null)
{
return;
}
LoadOptions.FirstResult = parameter.Settings.PageIndex * parameter.Settings.ItemsPerPage;
LoadArtistsImpl();
}
private void SetPageChanged(int aPage)
{
this.mCurPage = aPage;
this.SetBtnEnabled();
if (PageChanged != null)
{
PageChangedArgs e = new PageChangedArgs(aPage);
PageChanged(this, e);
}
}
private void OnPageChangedCommand(PageChangedArgs parameter)
{
if (parameter == null)
{
return;
}
PageChangedEventArgs e = parameter.Settings;
if (LoadOptions != null && e != null)
{
LoadOptions.FirstResult = e.PageIndex * e.ItemsPerPage;
LoadAlbums();
}
}
void PasswordSettings_PageDisplay(object sender, PageChangedArgs args)
{
try
{
if (Password.AskToEnterNewPassword)
{
m_owner.NextButton.Focus();
}
else
{
Password.Focus();
}
}
catch { }
}
protected virtual void GridContainer_PageLeave(object sender, PageChangedArgs args)
{
m_options.Clear();
foreach (KeyValuePair <string, string> p in OptionGrid.GetConfiguration())
{
m_options.Add("--" + p.Key, p.Value);
}
if (args.Direction == PageChangedDirection.Back)
{
return;
}
args.NextPage = m_nextpage;
}
void SelectName_PageEnter(object sender, PageChangedArgs args)
{
m_wrapper = new WizardSettingsWrapper(m_settings);
BackupFolder.Setup(Program.DataConnection, true, true);
if (!m_valuesAutoLoaded)
{
BackupName.Text = m_wrapper.ScheduleName;
BackupFolder.SelectedFolder = m_wrapper.SchedulePath;
}
try { BackupName.Focus(); }
catch { }
}
void MainPage_PageLeave(object sender, PageChangedArgs args)
{
if (args.Direction == PageChangedDirection.Back)
{
return;
}
m_wrapper.DataConnection = Program.DataConnection;
if (CreateNew.Checked)
{
m_wrapper.PrimayAction = WizardSettingsWrapper.MainAction.Add;
}
else if (Edit.Checked)
{
m_wrapper.PrimayAction = WizardSettingsWrapper.MainAction.Edit;
}
else if (Restore.Checked)
{
m_wrapper.PrimayAction = WizardSettingsWrapper.MainAction.Restore;
}
else if (Backup.Checked)
{
m_wrapper.PrimayAction = WizardSettingsWrapper.MainAction.RunNow;
}
else if (Remove.Checked)
{
m_wrapper.PrimayAction = WizardSettingsWrapper.MainAction.Remove;
}
else
{
m_wrapper.PrimayAction = WizardSettingsWrapper.MainAction.Unknown;
args.NextPage = null;
args.Cancel = true;
return;
}
if (m_wrapper.PrimayAction == WizardSettingsWrapper.MainAction.Add)
{
args.NextPage = new Add_backup.SelectName();
m_wrapper.SetupDefaults();
m_wrapper.PrimayAction = WizardSettingsWrapper.MainAction.Add;
}
else
{
args.NextPage = new SelectBackup();
}
}
protected override void GridContainer_PageLeave(object sender, PageChangedArgs args)
{
base.GridContainer_PageLeave(sender, args);
m_options.Add(GridContainer.DESTINATION_EXTENSION_KEY, Destination.Text);
if (args.Direction == PageChangedDirection.Back || args.Cancel == true)
{
return;
}
if (string.IsNullOrEmpty(Destination.Text) || Destination.Text.Trim().Length == 0)
{
MessageBox.Show(this, Library.Interface.CommonStrings.EmptyServernameError, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information);
args.Cancel = true;
return;
}
}
void AdvancedOptions_PageLeave(object sender, PageChangedArgs args)
{
m_settings["Advanced:When"] = SelectWhen.Checked;
m_settings["Advanced:Incremental"] = SelectCleanup.Checked;
m_settings["Advanced:Throttle"] = LimitOptions.Checked;
m_settings["Advanced:Filters"] = EditFilters.Checked;
m_settings["Advanced:Overrides"] = EditOverrides.Checked;
if (args.Direction == PageChangedDirection.Back)
{
return;
}
m_wrapper.IncludeSetup = IncludeDuplicatiSetup.Checked;
List <IWizardControl> pages = new List <IWizardControl>();
if (SelectWhen.Checked)
{
pages.Add(new Wizard_pages.Add_backup.SelectWhen());
}
if (SelectCleanup.Checked)
{
pages.Add(new Wizard_pages.Add_backup.CleanupSettings());
}
if (LimitOptions.Checked)
{
pages.Add(new Wizard_pages.Add_backup.ThrottleOptions());
}
if (EditFilters.Checked)
{
pages.Add(new Wizard_pages.Add_backup.EditFilters());
}
if (EditOverrides.Checked)
{
pages.Add(new Wizard_pages.Add_backup.SettingOverrides());
}
pages.Add(new Wizard_pages.Add_backup.FinishedAdd());
m_owner.Pages.Clear();
m_owner.Pages.AddRange(pages);
args.NextPage = pages[0];
}
void MainPage_PageDisplay(object sender, PageChangedArgs args)
{
//Skip this, if there is only one valid option
if (Program.DataConnection.GetObjects <Datamodel.Schedule>().Length == 0)
{
m_isFirstShow = false;
if (args.Direction == PageChangedDirection.Next)
{
CreateNew.Checked = true;
try { m_owner.NextButton.PerformClick(); }
catch { }
}
else
{
try { m_owner.BackButton.PerformClick(); }
catch { }
}
}
}
void IncrementalSettings_PageLeave(object sender, PageChangedArgs args)
{
if (args.Direction == PageChangedDirection.Back)
{
return;
}
if (EnableCleanupDuration.Checked)
{
try
{
if (Timeparser.ParseTimeSpan(CleanupDuration.Value).TotalDays < 1)
{
MessageBox.Show(this, Strings.CleanupSettings.TooShortCleanupDurationDay, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
args.Cancel = true;
return;
}
}
catch (Exception ex)
{
MessageBox.Show(this, string.Format(GUI.Strings.Common.InvalidDuration, ex.Message), Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
args.Cancel = true;
return;
}
}
if (!m_wrapper.CleanupSettingsUI.HasWarnedClean && !(EnableCleanupDuration.Checked || EnableFullBackupClean.Checked))
{
if (MessageBox.Show(this, Strings.CleanupSettings.DisabledCleanupWarning, Application.ProductName, MessageBoxButtons.YesNoCancel, MessageBoxIcon.Warning) != DialogResult.Yes)
{
args.Cancel = true;
return;
}
m_wrapper.CleanupSettingsUI.HasWarnedClean = true;
}
m_wrapper.MaxFullBackups = EnableFullBackupClean.Checked ? (int)CleanFullBackupCount.Value : 0;
m_wrapper.BackupExpireInterval = EnableCleanupDuration.Checked ? CleanupDuration.Value : "";
m_wrapper.IgnoreFileTimestamps = IgnoreTimestamps.Checked;
//Don't set args.NextPage, it runs on a list
}
void SelectBackend_PageDisplay(object sender, PageChangedArgs args)
{
Item_CheckChanged(null, null);
//If there is just one backend, skip this page
if (BackendList.Controls.Count == 1)
{
if (args.Direction == PageChangedDirection.Next)
{
((RadioButton)BackendList.Controls[0]).Checked = true;
try { m_owner.NextButton.PerformClick(); }
catch { }
}
else
{
try { m_owner.BackButton.PerformClick(); }
catch { }
}
}
}
void SelectBackend_PageEnter(object sender, PageChangedArgs args)
{
m_wrapper = new WizardSettingsWrapper(m_settings);
int top = 0;
BackendList.Controls.Clear();
//Sort backends by display name
SortedList <string, Library.Interface.IBackend> lst = new SortedList <string, Duplicati.Library.Interface.IBackend>();
foreach (Library.Interface.IBackend backend in Library.DynamicLoader.BackendLoader.Backends)
{
lst.Add(backend.DisplayName.Trim().ToLower(), backend);
}
foreach (Library.Interface.IBackend backend in lst.Values)
{
DoubleClickRadioButton button = new DoubleClickRadioButton();
button.AutoSize = true;
button.Text = backend.DisplayName;
toolTips.SetToolTip(button, backend.Description);
button.Left = 0;
button.Top = top;
button.Tag = backend;
button.CheckedChanged += new EventHandler(Item_CheckChanged);
button.DoubleClick += new EventHandler(button_DoubleClick);
button.Checked = (backend.ProtocolKey == m_wrapper.Backend);
top += button.Height + 5;
BackendList.Controls.Add(button);
}
Item_CheckChanged(null, null);
if (m_wrapper.PrimayAction == WizardSettingsWrapper.MainAction.RestoreSetup || m_wrapper.PrimayAction == WizardSettingsWrapper.MainAction.Restore)
{
Question.Text = Strings.SelectBackend.RestoreSetupTitle;
}
}
void FinishedRestore_PageEnter(object sender, PageChangedArgs args)
{
m_wrapper = new WizardSettingsWrapper(m_settings);
Summary.Text = string.Format(
Strings.FinishedRestore.SummaryText,
m_wrapper.ScheduleName,
(m_wrapper.RestoreTime.Ticks == 0 ? Strings.FinishedRestore.MostRecent : m_wrapper.RestoreTime.ToString()),
m_wrapper.DisplayRestorePath
);
args.TreatAsLast = true;
Schedule schedule = m_wrapper.DataConnection.GetObjectById <Schedule>(m_wrapper.ScheduleID);
if (!schedule.ExistsInDb)
{
RunInBackground.Checked = false;
RunInBackground.Visible = false;
}
}
void SelectBackupVersion_PageLeave(object sender, PageChangedArgs args)
{
if (args.Direction == PageChangedDirection.Back)
{
BackupList.Abort();
return;
}
if (BackupList.SelectedItem.Ticks == 0)
{
MessageBox.Show(this, Strings.SelectBackupVersion.NoBackupSelectedError, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information);
args.Cancel = true;
return;
}
m_selectedDate = new DateTime();
m_selectedDate = BackupList.SelectedItem;
m_wrapper.RestoreTime = m_selectedDate;
args.NextPage = new TargetFolder();
}
void SelectBackup_PageEnter(object sender, PageChangedArgs args)
{
BackupList.Setup(Program.DataConnection, true, false);
m_wrapper = new WizardSettingsWrapper(m_settings);
if (m_action != null)
{
m_wrapper.PrimayAction = m_action.Value;
}
if (m_wrapper.PrimayAction == WizardSettingsWrapper.MainAction.RunNow && m_wrapper.DataConnection == null)
{
m_wrapper.DataConnection = Program.DataConnection;
}
if (m_wrapper.ScheduleID > 0)
{
BackupList.SelectedBackup = (m_wrapper.DataConnection ?? Program.DataConnection).GetObjectById <Schedule>(m_wrapper.ScheduleID);
}
if (m_wrapper.PrimayAction == WizardSettingsWrapper.MainAction.Restore)
{
topLabel.Visible = false;
RestoreOptions.Visible = true;
}
else
{
topLabel.Visible = true;
RestoreOptions.Visible = false;
ShowAdvancedPanel.Visible = false;
topLabel.Text = this.Title;
}
if (m_valuesAutoLoaded)
{
m_skipFirstEvent = true;
}
args.TreatAsLast = false;
}
void GUIContainer_PageLeave(object sender, PageChangedArgs args)
{
m_interface.Leave(m_control);
if (args.Direction == PageChangedDirection.Back)
{
return;
}
if (!m_interface.Validate(m_control))
{
args.Cancel = true;
return;
}
//Make sure we don't save it in the DB
if (m_backendOptions.ContainsKey(ACTION_MARKER))
{
m_backendOptions.Remove(ACTION_MARKER);
}
args.NextPage = m_nextpage;
}
void SelectName_PageLeave(object sender, PageChangedArgs args)
{
if (args.Direction == PageChangedDirection.Back)
{
return;
}
if (BackupName.Text.Trim().Length <= 0)
{
MessageBox.Show(this, Strings.SelectName.NoNameEnteredError, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information);
args.Cancel = true;
return;
}
try
{
Schedule[] tmp = Program.DataConnection.GetObjects <Schedule>("Name LIKE ? AND Path LIKE ?", BackupName.Text, BackupFolder.SelectedFolder);
if ((tmp.Length == 1 && tmp[0].ID != m_wrapper.ScheduleID) || tmp.Length > 1)
{
MessageBox.Show(this, Strings.SelectName.DuplicateNameEnteredError, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information);
args.Cancel = true;
return;
}
}
catch (Exception ex)
{
MessageBox.Show(this, string.Format(Strings.SelectName.InvalidNameEnteredError, ex.Message), Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information);
args.Cancel = true;
return;
}
m_wrapper.ScheduleName = BackupName.Text;
m_wrapper.SchedulePath = BackupFolder.SelectedFolder;
args.NextPage = new SelectFiles();
}
void GUIContainer_PageEnter(object sender, PageChangedArgs args)
{
m_wrapper = new WizardSettingsWrapper(m_settings);
m_backendOptions = m_wrapper.BackendSettings;
//We inject a marker option here so the backend can make
// intelligent testing based on the current action
string marker;
switch (m_wrapper.PrimayAction)
{
case WizardSettingsWrapper.MainAction.Add:
marker = "add";
break;
case WizardSettingsWrapper.MainAction.Edit:
marker = "edit";
break;
case WizardSettingsWrapper.MainAction.Restore:
case WizardSettingsWrapper.MainAction.RestoreSetup:
marker = "restore";
break;
default:
marker = "unknown";
break;
}
m_backendOptions[ACTION_MARKER] = marker;
m_control = m_interface.GetControl(m_wrapper.ApplicationSettings, m_backendOptions);
m_control.SetBounds(0, 0, this.Width, this.Height);
m_control.Visible = true;
this.Controls.Clear();
this.Controls.Add(m_control);
}
void SelectFiles_PageEnter(object sender, PageChangedArgs args)
{
m_wrapper = new WizardSettingsWrapper(m_settings);
m_owner.Cancelled += new CancelEventHandler(m_owner_Cancelled);
if (m_settings.ContainsKey("Files:Sizes"))
{
m_sizes = (Dictionary <string, long>)m_settings["Files:Sizes"];
}
if (!m_valuesAutoLoaded)
{
if (m_wrapper.SelectFilesUI.Version < 2)
{
//Either upgrade or fresh copy
if (string.IsNullOrEmpty(m_wrapper.SourcePath))
{
//Set defaults
DocumentsRadio.Checked = true;
IncludeDocuments.Checked = true;
IncludeImages.Checked = true;
IncludeMusic.Checked = false;
IncludeDesktop.Checked = true;
IncludeSettings.Checked = false;
}
else
{
UpgradeFromVersionOne();
}
}
else
{
//Multifolder version
if (m_wrapper.SelectFilesUI.UseSimpleMode)
{
IncludeDocuments.Checked = m_wrapper.SelectFilesUI.IncludeDocuments;
IncludeImages.Checked = m_wrapper.SelectFilesUI.IncludeImages;
IncludeMusic.Checked = m_wrapper.SelectFilesUI.IncludeMusic;
IncludeDesktop.Checked = m_wrapper.SelectFilesUI.IncludeDesktop;
IncludeSettings.Checked = m_wrapper.SelectFilesUI.IncludeSettings;
DocumentsRadio.Checked = true;
}
else
{
FolderRadio.Checked = true;
}
}
}
//Always populate the list
InnerControlContainer.Controls.Clear();
if (!string.IsNullOrEmpty(m_wrapper.SourcePath))
{
foreach (string s in m_wrapper.SourcePath.Split(System.IO.Path.PathSeparator))
{
if (!string.IsNullOrEmpty(s))
{
AddFolderControl().SelectedPath = s;
}
}
}
Rescan();
//Make sure we resize correctly
TargetType_CheckedChanged(null, null);
}
