Ejemplo n.º 1
0
        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));
        }
Ejemplo n.º 2
0
        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);
        }
Ejemplo n.º 3
0
        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;
            }
        }
Ejemplo n.º 4
0
 /// <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);
 }
Ejemplo n.º 5
0
 /// <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));
     }
 }
Ejemplo n.º 6
0
 private ExcelErrorValue(eErrorType type)
 {
     if (type == default(eErrorType))
     {
         throw new ArgumentException($"{nameof(type)} must be a valid error type.");
     }
     this.Type = type;
 }
Ejemplo n.º 7
0
 /// <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));
 }
Ejemplo n.º 8
0
        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);
        }
Ejemplo n.º 9
0
    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);
        }
    }
Ejemplo n.º 10
0
        /// <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);
        }
Ejemplo n.º 11
0
 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();
 }
Ejemplo n.º 12
0
        /// <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);
        }
Ejemplo n.º 13
0
        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();
        }
Ejemplo n.º 14
0
        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);
        }
Ejemplo n.º 15
0
        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);
            }
        }
Ejemplo n.º 16
0
 public override bool TryValidateObjValueIsNotNaNOrinfinity(object obj, out eErrorType error)
 {
     error = eErrorType.Null;
     return(true);
 }
Ejemplo n.º 17
0
 private ExcelErrorValue(eErrorType type)
 {
     Type = type;
 }
Ejemplo n.º 18
0
 internal static ExcelErrorValue Create(eErrorType errorType)
 {
     return(new ExcelErrorValue(errorType));
 }
Ejemplo n.º 19
0
 /// <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));
 }
Ejemplo n.º 20
0
 /// <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);
 }
Ejemplo n.º 21
0
 public override void Read(ByteArray by)
 {
     base.Read(by);
     type   = (eErrorType)by.ReadUShort();
     action = (eErrorAction)by.ReadUShort();
 }
Ejemplo n.º 22
0
 internal static ExcelErrorValue Create(eErrorType errorType)
 {
     return new ExcelErrorValue(errorType);
 }
Ejemplo n.º 23
0
        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);
        }
Ejemplo n.º 24
0
 public ExcelErrorValueException(eErrorType errorType)
     : this(ExcelErrorValue.Create(errorType))
 {
     
 }
Ejemplo n.º 25
0
 /// <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));
 }
Ejemplo n.º 26
0
 public ExcelErrorValueException(eErrorType errorType)
     : this(ExcelErrorValue.Create(errorType))
 {
 }
Ejemplo n.º 27
0
 public CompileResult(eErrorType errorType)
 {
     Result = ExcelErrorValue.Create(errorType);
     DataType = DataType.ExcelError;
 }
Ejemplo n.º 28
0
 /// <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));
 }
Ejemplo n.º 29
0
 private ExcelErrorValue(eErrorType type)
 {
     Type=type; 
 }
Ejemplo n.º 30
0
 /// <summary>
 /// Checks for a validation error.
 /// </summary>
 public abstract bool TryValidateObjValueIsNotNaNOrinfinity(object obj, out eErrorType error);
Ejemplo n.º 31
0
 protected CompileResult CreateResult(eErrorType errorType)
 {
     return(CreateResult(ExcelErrorValue.Create(errorType), DataType.ExcelError));
 }
Ejemplo n.º 32
0
 /// <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;
 }
Ejemplo n.º 34
0
 public CompileResult(eErrorType errorType)
 {
     Result   = ExcelErrorValue.Create(errorType);
     DataType = DataType.ExcelError;
 }
Ejemplo n.º 35
0
        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;
            }
        }