protected override void Initialize()
{
base.Initialize();
var exceptionDialog = new ExceptionDialog();
try
{
var menuCommandService = (IMenuCommandService) GetService(typeof (IMenuCommandService));
var errorListProvider = new ErrorListProvider(ServiceProvider.GlobalProvider);
var currentProjectFinder = new CurrentProjectFinder();
var contentsFinder = new ContentsFinder();
var configureMenuCallback = new ConfigureMenuCallback(currentProjectFinder, contentsFinder, exceptionDialog);
var messageDisplayer = new MessageDisplayer(errorListProvider);
var disableMenuConfigure = new DisableMenuConfigure(currentProjectFinder, messageDisplayer, exceptionDialog);
var containsFodyChecker = new ContainsFodyChecker();
var menuStatusChecker = new MenuStatusChecker(currentProjectFinder, exceptionDialog, containsFodyChecker);
new MenuConfigure(configureMenuCallback, disableMenuConfigure, menuCommandService, menuStatusChecker).RegisterMenus();
var taskFileReplacer = new TaskFileReplacer(messageDisplayer, contentsFinder);
var taskFileProcessor = new TaskFileProcessor(taskFileReplacer, messageDisplayer);
var msBuildKiller = new MSBuildKiller();
new SolutionEvents(taskFileProcessor, exceptionDialog, msBuildKiller).RegisterSolutionEvents();
new TaskFileReplacer(messageDisplayer, contentsFinder).CheckForFilesToUpdate();
}
catch (Exception exception)
{
exceptionDialog.HandleException(exception);
}
}
/// <summary>
/// Default constructor.
/// </summary>
public ModifyPriority(MessageDisplayer Value)
{
InitializeComponent();
m_MessageDisplayer = Value;
m_TraceSwitch = new TraceSwitch("ModifyPriorityTrace", "Trace switch for OS Table modifier form.");
}
public void Reconciliate()
{
ReconciliationData reco = new ReconciliationData();
decimal credit = dialog.ReconciliationGrid.LeftAmount;
decimal debit = dialog.ReconciliationGrid.RightAmount;
decimal balance = dialog.ReconciliationGrid.BalanceAmount;
if (balance != 0 && this.EditedObject.acceptWriteOff)
{
if (!dialog.WriteOffBlock.Validate())
{
return;
}
reco.writeOffFields = dialog.WriteOffBlock.Fill();
reco.writeOffAmount = balance;
}
reco.ids = dialog.ReconciliationGrid.GridBrowser.GetSelectedOis();
reco.recoType = this.EditedObject.reconciliationType;
WriteOffFieldValueType type = this.EditedObject.writeoffDefaultMeasureTypeEnum;
if (type == WriteOffFieldValueType.CUSTOM)
{
reco.writeOffMeasure = this.EditedObject.writeoffMeasure;
}
else if (type == WriteOffFieldValueType.LEFT_SIDE)
{
reco.writeOffMeasure = this.EditedObject.leftMeasure;
}
else if (type == WriteOffFieldValueType.RIGHT_SIDE)
{
reco.writeOffMeasure = this.EditedObject.rightMeasure;
}
try
{
bool result = this.Service.reconciliate(reco);
if (result)
{
this.LeftGrid.Search(this.LeftGrid.EditedObject.GrilleFilter != null ? this.LeftGrid.EditedObject.GrilleFilter.page : 1);
this.RightGrid.Search(this.RightGrid.EditedObject.GrilleFilter != null ? this.RightGrid.EditedObject.GrilleFilter.page : 1);
this.BottomGrid.Clear();
this.BottomGrid.ReconciliateButton.IsEnabled = false;
this.BottomGrid.ResetButton.IsEnabled = false;
this.BottomGrid.ClearButton.IsEnabled = false;
dialog.ReconciliateButton.Click -= OnDialogReconciliate;
dialog.CancelButton.Click -= OnDialogCancel;
this.dialog.Close();
dialog = null;
BuildBalance(this.LeftGrid);
BuildBalance(this.RightGrid);
}
}
catch (Exception)
{
MessageDisplayer.DisplayWarning("Reconciliation Error", "An error occurred while trying to reconciliate!");
}
}
private bool ValidateTimeout(bool quiet)
{
if (cboTimeout.SelectedItem != null)
{
return(true);
}
MessageDisplayer.ShowValidationError(@"The field ""Timeout"" cannot be empty.", Text, quiet);
return(false);
}
public bool Validate()
{
if (ExcelFilesGrid.SelectedItem == null)
{
MessageDisplayer.DisplayWarning("Select files to upload", "You have to select at least one file to upload!");
return(false);
}
return(true);
}
private bool ValidateSequenceNumber(bool quiet)
{
if (int.TryParse(txtNumber.Text, NumberStyles.Any, CultureInfo.CurrentCulture, out _))
{
return(true);
}
MessageDisplayer.ShowValidationError(@"The field ""Sequence number"" must be an integer.", Text, quiet);
return(false);
}
private bool ValidateProgram(bool quiet)
{
txtProgram.Text = txtProgram.Text.Trim();
if (!string.IsNullOrWhiteSpace(txtProgram.Text))
{
return(true);
}
MessageDisplayer.ShowValidationError(@"The field ""Program to run"" cannot be empty.", Text, quiet);
return(false);
}
private bool ValidateJobName(bool quiet)
{
txtName.Text = txtName.Text.Trim();
if (!string.IsNullOrWhiteSpace(txtName.Text))
{
return(true);
}
MessageDisplayer.ShowValidationError(@"The field ""Job name"" cannot be empty.", Text, quiet);
return(false);
}
private void MainWindow_Shown(object sender, EventArgs e)
{
if (!Config.Validate())
{
Close();
return;
}
Refresh();
Jobs.Load();
Variables.Load();
if (!Jobs.LoadSuccess)
{
Cursor = Cursors.Default;
lblStatus.Text = @"Load failed.";
var failMessage = string.IsNullOrWhiteSpace(Jobs.LoadFailedMessage)
? "An unknown error has occured."
: Jobs.LoadFailedMessage;
var t = new StringBuilder();
t.Append(failMessage);
t.AppendLine();
t.AppendLine();
if (!Config.IsAdministrator)
{
t.Append("The application will close.");
t.AppendLine();
t.AppendLine();
t.AppendLine("To be able to edit the job list, start JobRunner as administrator.");
}
MessageBox.Show(t.ToString(), Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
if (!Config.IsAdministrator)
{
Close();
}
}
if (Config.IsAdministrator && !string.IsNullOrWhiteSpace(Jobs.LoadFailedMessage))
{
MessageDisplayer.Yell(Jobs.LoadFailedMessage, Text);
}
grid1.Initialize(Jobs);
if (Config.IsAdministrator)
{
Text = @"JobRunner (Administrator)";
lblStatus.Text = @"Done.";
}
else
{
Text = @"JobRunner";
lblStatus.Text = @"Done (read only).";
}
Cursor = Cursors.Default;
if (Config.AutoStart && AutoActionDialog.CheckAutoStart(this))
{
runToolStripMenuItem_Click(this, new EventArgs());
}
}
public void AddOrUpdateExcelShape(String excelFilePath, int reportOid, PowerPoint.Shape shape = null)
{
PowerPoint.Slide activeSlide = (PowerPoint.Slide)GetActiveSlide();
if (activeSlide == null)
{
return;
}
if (shape == null)
{
shape = GetActiveShape();
}
if (shape == null || shape.Type != MsoShapeType.msoEmbeddedOLEObject || !shape.OLEFormat.ProgID.StartsWith("Excel.Sheet."))
{
try
{
shape = activeSlide.Shapes.AddOLEObject(100, 100, -1f, -1f,
"", excelFilePath, Core.MsoTriState.msoFalse, "", 0,
"", Core.MsoTriState.msoFalse);
shape.Name = "" + reportOid;
if (ShapeAdded != null)
{
ShapeAdded(activeSlide.SlideNumber, activeSlide.Name, shape.Id, "" + reportOid, SlideItemType.REPORT, "");
}
}
catch (Exception)
{
MessageDisplayer.DisplayError("Insert Report", "Problem while adding report");
}
}
else
{
float left = shape.Left;
float top = shape.Top;
float width = -1f;
float height = -1f;
String name = shape.Name;
int position = shape.Id;
shape.Delete();
if (ShapeDeleted != null)
{
ShapeDeleted(activeSlide.SlideNumber, name, position, "" + reportOid, SlideItemType.REPORT, "");
}
shape = activeSlide.Shapes.AddOLEObject(left, top, width, height,
"", excelFilePath, Core.MsoTriState.msoFalse, "", 0,
"", Core.MsoTriState.msoFalse);
shape.Name = "" + reportOid;
if (ShapeAdded != null)
{
ShapeAdded(activeSlide.SlideNumber, activeSlide.Name, shape.Id, "" + reportOid, SlideItemType.REPORT, "");
}
}
}
private void btnCopy_Click(object sender, EventArgs e)
{
if (listView1.SelectedItems.Count <= 0)
{
return;
}
var valueToCopy = listView1.SelectedItems[0].Tag as string ?? "";
Clipboard.SetText(valueToCopy);
MessageDisplayer.Tell($"Copied to clipboard: {valueToCopy}", Text);
}
/// <summary>
/// Supprime les objets sélectionnés
/// </summary>
/// <returns></returns>
public override OperationState Delete()
{
System.Collections.IList items = GetBrowser().Form.Grid.SelectedItems;
if (items == null || items.Count == 0)
{
return(OperationState.STOP);
}
int count = items.Count;
string message = "You are about to delete " + count + " items.\nDo you want to continue?";
if (count == 1)
{
object item = GetBrowser().Form.Grid.SelectedItem;
if (item != null)
{
message = "You are about to delete " + item.ToString() + " .\nDo you want to continue?";
}
}
MessageBoxResult result = Kernel.Util.MessageDisplayer.DisplayYesNoQuestion("Delete", message);
if (result == MessageBoxResult.Yes)
{
action = new BusyAction(false)
{
DoWork = () =>
{
try
{
action.ReportProgress(0, message);
if (!Service.Delete(items))
{
Kernel.Util.MessageDisplayer.DisplayError("Delete", "Delete fail!");
}
else
{
System.Windows.Application.Current.Dispatcher.Invoke((Action)(() => Search()));
}
action.ReportProgress(100, message);
}
catch (BcephalException e)
{
MessageDisplayer.DisplayError("Error", e.Message);
action = null;
return(OperationState.STOP);
}
return(OperationState.CONTINUE);
}
};
action.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(ApplicationManager.MainWindow.OnBusyPropertyChanged);
action.Run();
}
return(OperationState.CONTINUE);
}
private void timer1_Tick(object sender, EventArgs e)
{
if (MessageDisplayer.todisplay.Count != 0)
{
try
{
foreach (string s in MessageDisplayer.todisplay)
{
if (s.Contains("connecté") && s.Contains("admin"))
{
logConsole.SelectionColor = Color.Coral;
}
else if (s.Contains("contrô"))
{
logConsole.SelectionColor = Color.Cyan;
}
else if (s.Contains("Chargement"))
{
logConsole.SelectionColor = Color.White;
}
else if (s.Contains("Utilisateur") && s.Contains("connecté"))
{
logConsole.SelectionColor = Color.White;
}
else if (s.Contains("envoye"))
{
logConsole.SelectionColor = Color.Magenta;
}
logConsole.AppendText("\r\n" + s);
logConsole.ScrollToCaret();
}
}
catch
{
}
MessageDisplayer.todisplay.Clear();
}
if (UserList.Items.Count != User.users.Count)
{
UserList.Items.Clear();
foreach (User u in User.users)
{
var item = new ListViewItem(u.username);
item.SubItems.Add(u.poste);
item.SubItems.Add(u.admin);
item.SubItems.Add(u.ip);
UserList.Items.Add(item);
}
}
MessageDisplayer.hour = MessageDisplayer.GetHour();
Network.RefreshVar();
}
private bool stopProcess()
{
MessageBoxResult response = MessageDisplayer.DisplayYesNoQuestion("Stop tree execution", "You are about to stop the tree execution.\nDo You want to stop?");
if (response == MessageBoxResult.Yes)
{
LoopUserTemplateData = new LoopUserDialogTemplateData();
LoopUserTemplateData.stop = true;
return(true);
}
isNotCloseAction = false;
return(false);
}
private void OnDeleteRows(object obj)
{
String message = "You are about to delete " + ((List <long>)obj).Count + " row(s).\nDo you want to continue?";
if (MessageDisplayer.DisplayYesNoQuestion("Delete", message) == MessageBoxResult.Yes)
{
if (this.GetInputGridService().deleteGridRows((List <long>)obj))
{
InputGridEditorItem page = (InputGridEditorItem)getEditor().getActivePage();
Search(page.getInputGridForm().GridForm.toolBar.current);
}
}
}
private void OnDeleteRows(object obj)
{
String message = "You are about to delete " + ((List <long>)obj).Count + " row(s).\nDo you want to continue?";
if (MessageDisplayer.DisplayYesNoQuestion("Delete", message) == MessageBoxResult.Yes)
{
LinkedAttributeGridEditorItem page = (LinkedAttributeGridEditorItem)getEditor().getActivePage();
if (this.GetLinkedAttributeGridService().deleteRows(page.EditedObject.oid.Value, (List <long>)obj))
{
Search(page.getLinkedAttributeGridForm().Toolbar.current);
}
}
}
protected virtual bool validateColumns(AutomaticSourcingEditorItem page)
{
List <String> columns = new List <string>(0);
foreach (AutomaticSourcingSheet sheet in page.EditedObject.automaticSourcingSheetListChangeHandler.Items)
{
bool?hasPrimaryKey = null;
if (sheet.firstRowColumn)
{
FillAutomaticSourcingColumn();
}
foreach (AutomaticSourcingColumn column in sheet.automaticSourcingColumnListChangeHandler.Items)
{
if (!hasPrimaryKey.HasValue)
{
hasPrimaryKey = false;
}
if (column.primary)
{
hasPrimaryKey = true;
}
if (!column.isValid())
{
columns.Add(column.ToString());
}
}
if (hasPrimaryKey.HasValue && !hasPrimaryKey.Value)
{
MessageDisplayer.DisplayWarning("Automatic Enrichment Table Run", "There is no primary column in sheet : '" + sheet.Name + "'!\nYou have to set at least one column as primary.");
return(false);
}
}
if (columns.Count > 0)
{
String message = "There is columns with no definition : ";
String coma = "";
foreach (String column in columns)
{
message += coma + "\"" + column + "\"";
coma = ", ";
}
message += "\nDo you want to continue?";
MessageBoxResult response = MessageDisplayer.DisplayYesNoQuestion("Automatic Enrichment Table Run", message);
if (response == MessageBoxResult.Yes)
{
return(true);
}
return(false);
}
return(true);
}
private void OnDuplicateRows(object obj)
{
String message = "You are about to duplicate " + ((List <long>)obj).Count + " row(s).\nDo you want to continue?";
if (MessageDisplayer.DisplayYesNoQuestion("Duplicate", message) == MessageBoxResult.Yes)
{
var list = ((List <long>)obj).ConvertAll(i => (int)i).ToList();
if (this.GetInputGridService().duplicateGridRows(list))
{
InputGridEditorItem page = (InputGridEditorItem)getEditor().getActivePage();
Search(page.getInputGridForm().GridForm.toolBar.total + 1);
}
}
}
public override void Bind(Entity entity, Main main, bool creating = false)
{
entity.CannotSuspend = true;
Transform transform = entity.GetOrCreate <Transform>("Transform");
MessageDisplayer message = entity.GetOrCreate <MessageDisplayer>("MessageDisplayer");
base.Bind(entity, main, creating);
entity.Add("Message", message.Message, "The message to display");
entity.Add("Display Time", message.DisplayLength, "The time to display the message. If 0, the message will stay until Hide is called.");
entity.Add("Display", message.Display);
entity.Add("One Time Only", message.OneTimeOnly, "If true, the message will only display once (resets on map reload)");
entity.Add("Hide", message.Hide);
}
private void OkButton_Click(object sender, RoutedEventArgs e)
{
string current = UserPreferencesUtil.GetMultipleFileUploadRepository();
if (!UserPreferencesUtil.SetMultipleFileUploadRepository(this.folderField.Text))
{
MessageDisplayer.DisplayWarning("Upload Multiple File Repository", "Attempt to save an empty repository!");
setFolderName(UserPreferencesUtil.GetMultipleFileUploadRepository());
}
else
{
this.Close();
}
}
/// <summary>
/// methode appelé lorsqu'on supprime un group node
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OndeleteNode(object sender, RoutedEventArgs e)
{
BGroup group = GetSelectedGroup();
var response = MessageDisplayer.DisplayYesNoQuestion("Suppression du Groupe", " Do you really want to delete? ");
if (response == MessageBoxResult.Yes)
{
BGroup parent = group.parent;
DeleteGroup(group);
parent.RemoveChild(group);
parent.UpdateParents();
((ObservableCollection <BGroup>)tree.ItemsSource).Remove(group);
}
}
public TaskFileReplacer(MessageDisplayer messageDisplayer, ContentsFinder contentsFinder)
{
this.messageDisplayer = messageDisplayer;
this.contentsFinder = contentsFinder;
var appData = Environment.GetEnvironmentVariable("appdata");
Directory.CreateDirectory(Path.Combine(appData, "PepitaGet"));
TaskFilePath = Path.Combine(appData, "PepitaGet", "TaskAssembliesToUpdate.txt");
if (!File.Exists(TaskFilePath))
{
using (File.Create(TaskFilePath))
{
}
}
}
/// <summary>
/// Sauve les objets en cours d'édition sur la page.
/// </summary>
/// <returns>
/// OperationState.CONTINUE si l'opération a réussi
/// OperationState.STOP sinon
/// </returns>
public override OperationState Save(EditorItem <Presentation> page)
{
if (page.IsModify)
{
if (!page.validateEdition())
{
return(OperationState.STOP);
}
try
{
Mask(true);
PresentationEditorItem currentPage = (PresentationEditorItem)page;
if (currentPage.getPresentationForm().SlideView != null)
{
String name = currentPage.getPresentationForm().PresentationPropertiesPanel.nameTextBox.Text;
Rename(name);
String savingFolder = currentPage.getPresentationForm().PresentationPropertiesPanel.savingFolderTextBox.Text;
String filePath = buildPowerPointFilePath(page.EditedObject.name);
String tempFolder = GetPresentationService().FileService.GetFileDirs().TempPresentationFolder;
page.EditedObject.userSavingDir = buildPowerPointSavingFolderPath(savingFolder, page.EditedObject.oid);
page.EditedObject.slideFileName = Path.GetFileName(filePath);
page.EditedObject.slideFileExtension = Path.GetExtension(filePath);
filePath = tempFolder + Path.DirectorySeparatorChar + Path.GetFileName(filePath);
if (currentPage.getPresentationForm().SlideView.SaveAs(filePath) != OperationState.CONTINUE)
{
MessageDisplayer.DisplayError("Unable to save " + page.EditedObject.name, "Unable to save file :\n" + filePath);
OnChange();
Mask(false);
return(OperationState.STOP);
}
String fileName = currentPage.getPresentationForm().SlideView.DocumentName + Path.GetExtension(filePath);
String path = currentPage.getPresentationForm().SlideView.DocumentUrl;
GetPresentationService().FileService.FileTransferService.uploadPresentation(fileName, tempFolder);
page.EditedObject.slideFileName = fileName;
}
GetPresentationService().SavePresentationHandler += UpdateSaveInfo;
GetPresentationService().Save(page.EditedObject);
}
catch (Exception)
{
DisplayError("Unable to save " + page.EditedObject.name, "Unable to save " + page.EditedObject.name + " named : " + page.EditedObject.name);
OnChange();
Mask(false);
return(OperationState.STOP);
}
}
return(OperationState.CONTINUE);
}
public TaskFileReplacer(MessageDisplayer messageDisplayer, ContentsFinder contentsFinder)
{
this.messageDisplayer = messageDisplayer;
this.contentsFinder = contentsFinder;
var appData = Environment.GetEnvironmentVariable("appdata");
Directory.CreateDirectory(Path.Combine(appData, "Fody"));
TaskFilePath = Path.Combine(appData, "Fody", "TaskAssembliesToUpdate.txt");
if (!File.Exists(TaskFilePath))
{
using (File.Create(TaskFilePath))
{
}
}
}
protected override void Rename(string name)
{
PresentationEditorItem page = (PresentationEditorItem)getEditor().getActivePage();
if (!Kernel.Util.FileUtil.isValidFileName(name))
{
MessageDisplayer.DisplayInfo("Presentation", "The slide name " + name + " is not valid");
return;
}
if (validateName(page, name))
{
ChangePowerPointFileName(name, page, page.EditedObject);
base.Rename(name);
}
}
public bool Validate()
{
if (TableGrid.SelectedItem == null)
{
MessageDisplayer.DisplayWarning("Select input table template", "You have to select an input table template before continue!");
return(false);
}
if (TableGrid.SelectedItems != null && TableGrid.SelectedItems.Count > 1)
{
MessageDisplayer.DisplayWarning("Select input table template", "you cannot select more than one table template!");
return(false);
}
return(true);
}
/// <summary>
/// Cette methode permet d'exporter le fichier excel ouvert dans la page active.
/// On ouvre le dialogue pour permettre à l'utilisateur d'indiquer le répertoire et le nom
/// sous lequel il faut exporter le fichier.
/// </summary>
/// <returns>
/// OperationState.CONTINUE si l'opération a réussi
/// OperationState.STOP sinon
/// </returns>
public virtual OperationState Clear(System.Collections.IList items)
{
OperationState state = OperationState.CONTINUE;
string message = "You are about to clear selected grids and tables.\n Do you want to continue ?";
MessageBoxResult response = MessageDisplayer.DisplayYesNoQuestion("Clear load", message);
if (response == MessageBoxResult.Yes)
{
Mask(true);
TableActionData data = new TableActionData(items);
Service.ClearAllocationTableHandler += updateClearAllocationProgress;
Service.ClearAllocationTable(data);
}
return(state);
}
private void UploadFilesDialog_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
bool cannotClose = false;
if (this.currentInfo != null && !this.currentInfo.isEnd)
{
cannotClose = true;
}
if (cannotClose)
{
e.Cancel = cannotClose;
MessageDisplayer.ShowAutoClosingMessageBox(this, "Please wait until the process ends", "Load multiple Table");
return;
}
}
void Start()
{
lives = startingLives;
shake = Camera.main.GetComponent <CameraShake>();
rb = GetComponent <Rigidbody2D>();
audioSrc = GetComponent <AudioSource>();
livesDisplay = FindObjectOfType <LivesDisplay>();
msgDisplayer = FindObjectOfType <MessageDisplayer>();
if (!livesDisplay)
{
throw new UnityException("Can't find livesDisplay");
}
livesDisplay.DisplayLives(lives);
}
private void displayTransformationSlide(String name)
{
Process process = Kernel.Ui.Office.PowerpointLoader.GetRunningPowerPointProcess();
while (process != null)
{
PowerPoint.Application PowerPointApplication = new PowerPoint.Application();
if (PowerPointApplication.Visible != MsoTriState.msoTrue)
{
Kernel.Ui.Office.PowerpointLoader.KillProcess(process);
}
if (MessageDisplayer.DisplayYesNoQuestion("Transformation Tree - Powerpoint ", "You need to close opened Powerpoint application before use this functionnality!\n Do you want B-Cephal to close Powerpoint ?")
== MessageBoxResult.Yes)
{
Kernel.Ui.Office.PowerpointLoader.KillProcess(process);
}
else
{
return;
}
process = null;
}
if (this.TransformationSlideDialog == null)
{
this.TransformationSlideDialog = new TransformationSlideDialog();
this.TransformationSlideDialog.SaveButton.Click += OnTransformationSlideDialogSave;
this.TransformationSlideDialog.CancelButton.Click += OnTransformationSlideDialogCancel;
this.TransformationSlideDialog.Closing += OnTransformationSlideDialogClosing;
this.TransformationSlideDialog.Owner = ApplicationManager.Instance.MainWindow;
}
Kernel.Domain.Presentation slide = !string.IsNullOrEmpty(name) ?
this.TransformationSlideDialog.PresentationEditorController.GetPresentationService().getByName(name) : null;
if (slide == null)
{
slide = new Kernel.Domain.Presentation();
slide.name = name;
slide.group = ApplicationManager.Instance.ControllerFactory.ServiceFactory.GetGroupService().getDefaultGroup();
}
this.TransformationSlideDialog.TransformationSlide = slide;
this.TransformationSlideDialog.initializeSideBarData(new ObservableCollection <TransformationTreeItem>(BlockPanel.Loops));
this.TransformationSlideDialog.DisplayTransformationSlide();
this.TransformationSlideDialog.ShowDialog();
}
public bool Validate()
{
if (writeOffField.mandatory)
{
if (writeOffField.isAttribute() && this.valueCombobox.SelectedItem == null)
{
MessageDisplayer.DisplayWarning("Write off", "The field '" + this.writeOffField.attributeField.name + "' is mandatory!");
return(false);
}
else if (writeOffField.isPeriod() && !this.valueDatePicker.SelectedDate.HasValue)
{
MessageDisplayer.DisplayWarning("Write off", "The field '" + this.writeOffField.periodField.name + "' is mandatory!");
return(false);
}
}
return(true);
}
private void SaveVariables()
{
Cursor = Cursors.WaitCursor;
try
{
using var sw = new StreamWriter(Config.GetVariableFilePath(), false, Encoding.UTF8);
sw.Write(Variables.GetXml());
sw.Flush();
sw.Close();
Cursor = Cursors.Default;
}
catch
{
Cursor = Cursors.Default;
MessageDisplayer.Yell($@"Failed to save the file ""{Config.GetVariableFilePath()}"".", Text);
}
}
public DisableMenuCallback(CurrentProjectFinder currentProjectFinder, MessageDisplayer messageDisplayer, ExceptionDialog exceptionDialog)
{
this.exceptionDialog = exceptionDialog;
this.messageDisplayer = messageDisplayer;
this.currentProjectFinder = currentProjectFinder;
}
public TaskFileProcessor(TaskFileReplacer taskFileReplacer, MessageDisplayer messageDisplayer)
{
this.taskFileReplacer = taskFileReplacer;
this.messageDisplayer = messageDisplayer;
}
