VixenModules.SequenceType.Vixen2x.Vixen2xSequenceImporterForm.importSequenceData C# (CSharp) Method

importSequenceData() private method

private importSequenceData ( List mappings ) : void
mappings List
return void
        private void importSequenceData(List<ChannelMapping> mappings)
        {
            int startEventPosition = resetEventPosition;
            var endEventPosition = resetEventPosition;
            var priorEventNum = resetEventPosition;

            var startEventValue = zeroEventValue;
            var endEventValue = zeroEventValue;
            var priorEventValue = zeroEventValue;
            var currentEventValue = zeroEventValue;

            var pbImportValue = 0;

            // These flags are here just to make the code below easier to read, at least for me.
            var patternFound = false;
            var processingSingleEvents = false;
            var processingGroupEvents = false;
            var processingRamps = false;
            var processingFades = false;
            var currentEventIsZero = true;
            var currentEventIsNotZero = false;
            var priorEventisNotZero = false;

            foreach (patternType pattern in Enum.GetValues(typeof(patternType))) {
                processingSingleEvents = pattern == patternType.SingleSetLevel;
                processingGroupEvents = pattern == patternType.SetLevelTrend;
                processingRamps = pattern == patternType.PulseRampTrend;
                processingFades = pattern == patternType.PulseFadeTrend;

                var patternText = ((DescriptionAttribute)((pattern.GetType().GetMember(pattern.ToString()))[0]
                            .GetCustomAttributes(typeof(DescriptionAttribute), false)[0])).Description;

                currentEventValue = zeroEventValue;
                for (var currentElementNum = 0; currentElementNum < parsedV2Sequence.ElementCount; currentElementNum++) {
                    lblStatusLine.Text = String.Format("Finding {0} on Element {1}", patternText, currentElementNum + 1);
                    pbImport.Value = ++pbImportValue;

                    patternFound = false;
                    priorEventValue = zeroEventValue;
                    priorEventNum = resetEventPosition;

                    for (var currentEventNum = 0; currentEventNum < parsedV2Sequence.EventsPerElement; currentEventNum++) {
                        // To keep the progress bar looking snappy
                        if ((currentEventNum % 10) == 0) {
                            Application.DoEvents();
                        }
                        currentEventValue = parsedV2Sequence.EventData[currentElementNum * parsedV2Sequence.EventsPerElement + currentEventNum];

                        currentEventIsZero = currentEventValue == zeroEventValue;
                        currentEventIsNotZero = !currentEventIsZero;
                        priorEventisNotZero = priorEventValue != zeroEventValue;

                        // Add a non zero single set level event.
                        if (processingSingleEvents && currentEventIsNotZero) {
                            addEvent(pattern, currentElementNum, currentEventNum, currentEventValue, currentEventNum);

                            startEventPosition = resetEventPosition;
                            endEventPosition = resetEventPosition;
                        }
                        // Add a ramp, fade or multi set level event since it just ended (a zero event was found)
                        else if (patternFound && !processingSingleEvents && currentEventIsZero && endEventPosition != resetEventPosition) {
                            addEvent(pattern, currentElementNum, startEventPosition, startEventValue, endEventPosition, endEventValue);

                            patternFound = false;
                            startEventPosition = resetEventPosition;
                            endEventPosition = resetEventPosition;
                        }
                        // Beggining of a pattern found, set flag and start event postion and value
                        else if (!patternFound && currentEventNum > resetEventPosition
                                    && ((processingGroupEvents && currentEventIsNotZero && currentEventValue == priorEventValue)
                                        || (processingFades && currentEventIsNotZero && currentEventValue < priorEventValue)
                                        || (processingRamps && priorEventisNotZero && currentEventValue > priorEventValue))) {

                            patternFound = true;
                            startEventPosition = currentEventNum - 1;
                            startEventValue = priorEventValue;
                            endEventPosition = currentEventNum;
                            endEventValue = currentEventValue;
                        }
                        // Pattern continuing, update the end event postion and value.
                        else if (patternFound
                                    && ((processingGroupEvents && currentEventValue == priorEventValue)
                                        || (processingFades && currentEventValue < priorEventValue)
                                        || (processingRamps && priorEventisNotZero && currentEventValue > priorEventValue))) {

                            endEventPosition = currentEventNum;
                            endEventValue = currentEventValue;
                        }
                        // End of a pattern because none of the other conditions were met.
                        else if (patternFound) {
                            addEvent(pattern, currentElementNum, startEventPosition, startEventValue, priorEventNum, priorEventValue);

                            patternFound = false;
                            startEventPosition = resetEventPosition;
                            endEventPosition = resetEventPosition;
                        }
                        priorEventValue = currentEventValue;
                        priorEventNum = currentEventNum;
                    } // for currentEvent

                    // End of the Element, so process any existing patterns.
                    if (patternFound) {
                        addEvent(pattern, currentElementNum, startEventPosition, priorEventValue, priorEventNum);
                    }

                } // for currentElementNum
            } // foreach patternType
        }