public static ExcelErrorValue Create(eErrorType errorType)
{
switch (errorType)
{
case eErrorType.Div0:
return(Div0);
case eErrorType.NA:
return(NA);
case eErrorType.Name:
return(Name);
case eErrorType.Null:
return(Null);
case eErrorType.Num:
return(Num);
case eErrorType.Ref:
return(Ref);
case eErrorType.Value:
return(Value);
case eErrorType.GettingData:
return(GettingData);
}
return(new ExcelErrorValue(errorType));
}
private eErrorType isFormValid()
{
eErrorType result = eErrorType.OK;
if (string.IsNullOrEmpty(locationTextBox.Text))
{
result = eErrorType.emptyLocation;
}
if (string.IsNullOrEmpty(descriptionTextBox.Text))
{
result = eErrorType.emptyDescription;
}
if (string.IsNullOrEmpty(nameTextBox.Text))
{
result = eErrorType.emptyName;
}
if (endMonthCalender.SelectionStart < startMonthCalendar.SelectionStart)
{
result = eErrorType.endSmallerThanStart;
}
return(result);
}
private void OkBtn_Click(object sender, EventArgs e)
{
eErrorType result = isFormValid();
switch (result)
{
case eErrorType.OK:
m_eventToEdit.Name = nameTextBox.Text;
m_eventToEdit.Location = locationTextBox.Text;
m_eventToEdit.Description = descriptionTextBox.Text;
m_eventToEdit.StartTime = startMonthCalendar.SelectionStart;
m_eventToEdit.EndTime = endMonthCalender.SelectionStart;
this.Close();
break;
case eErrorType.endSmallerThanStart:
MessageBox.Show("End date has to be after start date");
break;
case eErrorType.emptyName:
MessageBox.Show("Name field is empty");
break;
case eErrorType.emptyLocation:
MessageBox.Show("Location field is empty");
break;
case eErrorType.emptyDescription:
MessageBox.Show("Description field is empty");
break;
}
}
/// <summary>
/// This functions validates that the supplied <paramref name="arguments"/> contains at least
/// (the value of) <paramref name="minLength"/> elements. If one of the arguments is an
/// <see cref="ExcelDataProvider.IRangeInfo">Excel range</see> the number of cells in
/// that range will be counted as well.
/// </summary>
/// <param name="arguments"></param>
/// <param name="minLength"></param>
/// <param name="errorTypeToThrow">The <see cref="eErrorType"/> of the <see cref="ExcelErrorValueException"/> that will be thrown if <paramref name="minLength"/> is not met.</param>
protected void ValidateArguments(IEnumerable <FunctionArgument> arguments, int minLength,
eErrorType errorTypeToThrow)
{
Require.That(arguments).Named("arguments").IsNotNull();
ThrowExcelErrorValueExceptionIf(() =>
{
var nArgs = 0;
if (arguments.Any())
{
foreach (var arg in arguments)
{
nArgs++;
if (nArgs >= minLength)
{
return(false);
}
if (arg.IsExcelRange)
{
nArgs += arg.ValueAsRangeInfo.GetNCells();
if (nArgs >= minLength)
{
return(false);
}
}
}
}
return(true);
}, errorTypeToThrow);
}
/// <summary>
/// Throws an <see cref="ArgumentException"/> if <paramref name="condition"/> evaluates to true.
/// </summary>
/// <param name="condition"></param>
/// <param name="errorType"></param>
/// <exception cref="ExcelErrorValueException"></exception>
protected void ThrowExcelErrorValueExceptionIf(Func <bool> condition, eErrorType errorType)
{
if (condition())
{
throw new ExcelErrorValueException("An excel function error occurred", ExcelErrorValue.Create(errorType));
}
}
private ExcelErrorValue(eErrorType type)
{
if (type == default(eErrorType))
{
throw new ArgumentException($"{nameof(type)} must be a valid error type.");
}
this.Type = type;
}
/// <summary>
/// Tries to convert a string to an <see cref="eErrorType"/>.
/// </summary>
/// <param name="candidate">The string to convert to an error value.</param>
/// <param name="eErrorType">The converted <see cref="eErrorType"/>.</param>
/// <returns>True if succesfully converted, otherwise false.</returns>
public static bool TryGetErrorType(string candidate, out eErrorType eErrorType)
{
eErrorType = eErrorType.Value;
if (candidate == null)
{
return(false);
}
return(_values.TryGetValue(candidate, out eErrorType));
}
static public eErrorType sendFile(XboxConsole console, string localName, string remoteName, bool createDir, bool onlyIfNewer)
{
if (console == null)
{
return(eErrorType.cNotConnected);
}
eErrorType res = eErrorType.c*K;
try
{
if (createDir)
{
string path = remoteName;
int i = path.LastIndexOf('\\');
if (i >= 0)
{
path = path.Substring(0, i);
}
createDirectory(console, path);
}
bool gotLocalDateTime = false;
DateTime localDateTime = DateTime.Now;
try
{
localDateTime = File.GetLastWriteTime(localName);
gotLocalDateTime = true;
}
catch { }
if (onlyIfNewer && gotLocalDateTime)
{
IXboxFile fileObject = null;
try
{
fileObject = console.GetFileObject(remoteName);
}
catch { }
if (fileObject != null)
{
DateTime remoteDateTime = (DateTime)fileObject.ChangeTime;
if (localDateTime <= remoteDateTime)
{
return(res);
}
}
}
console.SendFile(localName, remoteName);
}
catch (Exception e)
{
res = errorCatch(e);
}
return(res);
}
static public void ResponseError(eErrorType type)
{
string message = null;
switch (type)
{
case eErrorType.None:
message = "Error";
break;
case eErrorType.Login:
message = "Error";
break;
case eErrorType.Null:
message = "Error";
break;
case eErrorType.getAllStages:
message = "Error";
break;
case eErrorType.doSaveStage:
message = "Error";
break;
case eErrorType.doPlay:
message = "Error";
break;
case eErrorType.getRank:
message = "Error";
break;
case eErrorType.doFavoriteStage:
message = "Error";
break;
case eErrorType.clearStage:
message = "Error";
break;
case eErrorType.failedStage:
message = "Error";
break;
default:
message = "Error";
break;
}
if (App.Instance != null)
{
App.Instance.ShowMessage(message);
}
}
/// <summary>
/// Checks for a #Num Excel error.
/// </summary>
/// <param name="obj">The excel object to check for a num error.</param>
/// <param name="error">Sends out the eErrorType type.</param>
/// <returns>Returns false if the value of obj is either Nan or Infinity. Otherwise It returns true and the program continues like normal.</returns>
public override bool TryValidateObjValueIsNotNaNOrinfinity(object obj, out eErrorType error)
{
var num = ConvertUtil.GetValueDouble(obj);
if (double.IsNaN(num) || double.IsInfinity(num))
{
error = eErrorType.Num;
return(false);
}
//If this returns true ignore the out eError
error = eErrorType.Null;
return(true);
}
public static void mngError(Exception ex,
string function,
string module,
string infoAdd,
string title,
eErrorLevel level,
eErrorType varType,
object connection)
{
// TODO: implement function
fErrors f = new fErrors();
f.setErrorIcon();
f.setDetails(ex.Message);
f.ShowDialog();
}
/// <summary>
/// This functions validates that the supplied <paramref name="arguments"/> contains at least
/// (the value of) <paramref name="minLength"/> elements. If one of the arguments is an
/// <see cref="ExcelDataProvider.IRangeInfo">Excel range</see> the number of cells in
/// that range will be counted as well. Additionally, if any of the given arguments are an
/// <see cref="ExcelErrorValue"/>, that error value will be passed back in <paramref name="errorValue"/>.
/// </summary>
/// <param name="arguments">The arguments to validate.</param>
/// <param name="minLength">The expected minimum number of elements in <paramref name="arguments"/>.</param>
/// <param name="errorValue">The <see cref="eErrorType"/> contained in the first <see cref="ExcelErrorValue"/> encountered
/// if this method returns false. The default value is the value given for <paramref name="errorOnInvalidCount"/>.</param>
/// <param name="errorOnInvalidCount">The desired <see cref="eErrorType"/> to receive if this method returns false.</param>
/// <returns>Returns true if there are at least the <paramref name="minLength"/> number of arguments present
/// and none of the arguments contain an <see cref="ExcelErrorValue"/>, and returns false if otherwise.</returns>
protected bool ArgumentsAreValid(IEnumerable <FunctionArgument> arguments, int minLength, out eErrorType errorValue, eErrorType errorOnInvalidCount = eErrorType.Value)
{
errorValue = errorOnInvalidCount;
if (!this.ArgumentCountIsValid(arguments, minLength))
{
return(false);
}
var argumentContainingError = arguments.FirstOrDefault(arg => arg.ValueIsExcelError);
if (argumentContainingError != null)
{
errorValue = argumentContainingError.ValueAsExcelErrorValue.Type;
return(false);
}
return(true);
}
public static void mngError(Exception ex,
string function,
string module,
string infoAdd,
string title,
eErrorLevel level,
eErrorType varType,
object connection)
{
// TODO: implement function
fErrors f = new fErrors();
f.setErrorIcon();
f.setDetails(ex.Message);
f.ShowDialog();
}
public void AverageShouldThrowDivByZeroExcelErrorValueIfEmptyArgs()
{
eErrorType errorType = eErrorType.Value;
var func = new Average();
var args = new FunctionArgument[0];
try
{
func.Execute(args, _parsingContext);
}
catch (ExcelErrorValueException e)
{
errorType = e.ErrorValue.Type;
}
Assert.AreEqual(eErrorType.Div0, errorType);
}
static public void sendCommand(string cmd, out string resp)
{
resp = "";
eErrorType res = eErrorType.cConnectionLost;
try
{
closeConnection();
openConnection();
mDefaultConsole.SendTextCommand(mCommandConnectionID, mCommandStringHandle + "!" + cmd, out resp);
res = eErrorType.c*K;
}
catch (Exception e)
{
res = errorCatch(e);
}
}
public override bool TryValidateObjValueIsNotNaNOrinfinity(object obj, out eErrorType error)
{
error = eErrorType.Null;
return(true);
}
private ExcelErrorValue(eErrorType type)
{
Type = type;
}
internal static ExcelErrorValue Create(eErrorType errorType)
{
return(new ExcelErrorValue(errorType));
}
/// <summary>
/// Throws an <see cref="ExcelErrorValueException"/> with the given <paramref name="errorType"/> set.
/// </summary>
/// <param name="errorType"></param>
protected void ThrowExcelErrorValueException(eErrorType errorType)
{
throw new ExcelErrorValueException("An excel function error occurred", ExcelErrorValue.Create(errorType));
}
/// <summary>
/// This functions validates that the supplied <paramref name="arguments"/> contains at least
/// (the value of) <paramref name="minLength"/> elements. If one of the arguments is an
/// <see cref="ExcelDataProvider.IRangeInfo">Excel range</see> the number of cells in
/// that range will be counted as well.
/// </summary>
/// <param name="arguments"></param>
/// <param name="minLength"></param>
/// <param name="errorTypeToThrow">The <see cref="eErrorType"/> of the <see cref="ExcelErrorValueException"/> that will be thrown if <paramref name="minLength"/> is not met.</param>
protected void ValidateArguments(IEnumerable<FunctionArgument> arguments, int minLength,
eErrorType errorTypeToThrow)
{
Require.That(arguments).Named("arguments").IsNotNull();
ThrowExcelErrorValueExceptionIf(() =>
{
var nArgs = 0;
if (arguments.Any())
{
foreach (var arg in arguments)
{
nArgs++;
if (nArgs >= minLength) return false;
if (arg.IsExcelRange)
{
nArgs += arg.ValueAsRangeInfo.GetNCells();
if (nArgs >= minLength) return false;
}
}
}
return true;
}, errorTypeToThrow);
}
public override void Read(ByteArray by)
{
base.Read(by);
type = (eErrorType)by.ReadUShort();
action = (eErrorAction)by.ReadUShort();
}
internal static ExcelErrorValue Create(eErrorType errorType)
{
return new ExcelErrorValue(errorType);
}
public override void DrawWindow()
{
base.DrawWindow();
Dialog DInstance = DialogEditor.Instance.currentDialog;
hasBeenClicked = false;
newName = EditorGUILayout.TextField(newName);
if (showError)
{
EditorGUILayout.HelpBox(error[(int)errorType], MessageType.Error);
if (windowRect.height < 105)
{
windowRect.height = 105;
}
}
/*else
* {
* EditorGUILayout.LabelField("");
* }*/
//follow target node
Vector2 topRPos = targetNode.GetTopRightCornerPos();
windowRect.x = topRPos.x;
windowRect.y = topRPos.y;
GUILayout.BeginHorizontal();
if (GUILayout.Button("Apply"))
{
hasBeenClicked = true;
bool isAcceptable = true;
if (newName != "")
{
foreach (BaseNode node in DInstance.NodeList)
{
if (node.windowTitle == newName)
{
isAcceptable = false;
errorType = eErrorType.Used;
break;
}
}
}
else
{
isAcceptable = false;
errorType = eErrorType.NoName;
}
if (isAcceptable)
{
foreach (BaseNode node in DInstance.ActionNodeList)
{
//rename dialogText attached
if (node is DialogText)
{
if ((node as DialogText).targetNode == targetNode)
{
(node as DialogText).windowTitle = "Text from:" + newName;
}
}
//rename AnswerText attached
else if (node is AnswerText)
{
if ((node as AnswerText).targetNode == targetNode)
{
string prevTitle = (node as AnswerText).windowTitle;
int posString = prevTitle.IndexOf(":") + 1;
prevTitle = prevTitle.Substring(0, posString);
(node as AnswerText).windowTitle = prevTitle + newName;
}
}
}
DInstance.DECtrlZInstance.Add(new CtrlZNodeRenamed(targetNode, DInstance, targetNode.windowTitle, newName));
targetNode.windowTitle = newName;
DInstance.RemoveRenameNode(targetNode);
}
else
{
showError = true;
}
}
if (GUILayout.Button("Cancel"))
{
hasBeenClicked = true;
DInstance.RemoveRenameNode(this);
}
GUILayout.EndHorizontal();
if (hasBeenClicked)
{
DInstance.SetNodeToFront(this);
}
DInstance.SetLastDrawnWindow(this);
}
public ExcelErrorValueException(eErrorType errorType)
: this(ExcelErrorValue.Create(errorType))
{
}
/// <summary>
/// Tries to convert a string to an <see cref="eErrorType"/>.
/// </summary>
/// <param name="candidate">The string to convert to an error value.</param>
/// <param name="eErrorType">The converted <see cref="eErrorType"/>.</param>
/// <returns>True if succesfully converted, otherwise false.</returns>
public static bool TryGetErrorType(string candidate, out eErrorType eErrorType)
{
return(_values.TryGetValue(candidate, out eErrorType));
}
public ExcelErrorValueException(eErrorType errorType)
: this(ExcelErrorValue.Create(errorType))
{
}
public CompileResult(eErrorType errorType)
{
Result = ExcelErrorValue.Create(errorType);
DataType = DataType.ExcelError;
}
/// <summary>
/// Throws an <see cref="ExcelErrorValueException"/> with the given <paramref name="errorType"/> set.
/// </summary>
/// <param name="errorType"></param>
protected void ThrowExcelErrorValueException(eErrorType errorType)
{
throw new ExcelErrorValueException("An excel function error occurred", ExcelErrorValue.Create(errorType));
}
private ExcelErrorValue(eErrorType type)
{
Type=type;
}
/// <summary> /// Checks for a validation error. /// </summary> public abstract bool TryValidateObjValueIsNotNaNOrinfinity(object obj, out eErrorType error);
protected CompileResult CreateResult(eErrorType errorType)
{
return(CreateResult(ExcelErrorValue.Create(errorType), DataType.ExcelError));
}
/// <summary>
/// Throws an <see cref="ArgumentException"/> if <paramref name="condition"/> evaluates to true.
/// </summary>
/// <param name="condition"></param>
/// <param name="errorType"></param>
/// <exception cref="ExcelErrorValueException"></exception>
protected void ThrowExcelErrorValueExceptionIf(Func<bool> condition, eErrorType errorType)
{
if (condition())
{
throw new ExcelErrorValueException("An excel function error occurred", ExcelErrorValue.Create(errorType));
}
}
public FinanceCalcResult(eErrorType error)
{
HasError = true;
ExcelErrorType = error;
}
public CompileResult(eErrorType errorType)
{
Result = ExcelErrorValue.Create(errorType);
DataType = DataType.ExcelError;
}
public override void DrawWindow()
{
base.DrawWindow();
Dialog DInstance = DialogEditor.Instance.currentDialog;
windowTitle = "SubDialog:" + dialog.dialogName;
bool isAcceptable = true;
if (dialog.dialogName != "")
{
foreach (SubDialogNode sdNode in DInstance.SubDialogNodeList)
{
if (sdNode != this && sdNode.dialog.dialogName == dialog.dialogName)
{
isAcceptable = false;
errorType = eErrorType.Used;
break;
}
}
foreach (Dialog dialog in DialogEditor.Instance.loadedDialogs)
{
if (dialog != this.dialog && dialog.dialogName == this.dialog.dialogName)
{
isAcceptable = false;
errorType = eErrorType.Used;
break;
}
}
}
else
{
isAcceptable = false;
errorType = eErrorType.NoName;
}
showError = !isAcceptable;
EditorGUILayout.LabelField("Dialog name");
EditorGUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
dialog.dialogName = EditorGUILayout.TextField(dialog.dialogName, GUILayout.MinWidth(130.0f));
if (GUILayout.Button("L", GUILayout.Width(19), GUILayout.Height(15)))
{
connection = null;
DInstance.connectNodeClick = true;
DInstance.selectedNodeAnswer = -1;
DInstance.selectedNodeToLink = this;
}
EditorGUILayout.EndHorizontal();
if (showError)
{
EditorGUILayout.HelpBox(error[(int)errorType], MessageType.Error);
if (windowRect.height < 105)
{
windowRect.height = 105;
}
}
else
{
windowRect.height = 60;
}
}