Esempio n. 1
0
        /// <summary>
        /// Dodaje do timingu napisów podaną wartość.
        /// </summary>
        /// <param name="timing">Wartość o jaką ma zostać zwiększony timing.</param>
        /// <param name="timingFrom">Wartość od której ma się rozpocząć zmiana.</param>
        /// <param name="timingTo">Wrtość do której ma zostać przeprowadzona zmiana.</param>
        public void AddTiming(long timing, long timingFrom, long timingTo)
        {
            IEditStrategy editStrategy = this.CreateStrategyForCurrentFormat();

            TimedEntry entry = null;

            while ((entry = editStrategy.NextTimedEntry()) != null)
            {
                bool needSave = false;
                if ((entry.TimingStart >= timingFrom) && (entry.TimingStart <= timingTo))
                {
                    entry.TimingStart += timing;
                    needSave           = true;
                }

                if (entry.UsesTimingEnd && (entry.TimingEnd >= timingFrom) && (entry.TimingEnd <= timingTo))
                {
                    entry.TimingEnd += timing;
                    needSave         = true;
                }

                if (needSave)
                {
                    editStrategy.SaveCurrentEntry();
                }
            }

            SetEditorContent(editStrategy.Content);
        }
Esempio n. 2
0
        /// <summary>
        /// Dodaje do timingu napisów podaną wartość.
        /// </summary>
        /// <param name="timing">Wartość o jaką ma zostać zwiększony timing.</param>
        public void AddTiming(long timing)
        {
            IEditStrategy editStrategy = this.CreateStrategyForCurrentFormat();

            TimedEntry entry = null;

            while ((entry = editStrategy.NextTimedEntry()) != null)
            {
                entry.TimingStart += timing;
                if (entry.UsesTimingEnd)
                {
                    entry.TimingEnd += timing;
                }

                editStrategy.SaveCurrentEntry();
            }

            SetEditorContent(editStrategy.Content);
        }
Esempio n. 3
0
        /// <summary>
        /// Rozstrzyga format pliku, w oparciu o jego zawartość i znane metody jej odczytwania.
        /// </summary>
        /// <exception cref=""></exception>
        /// <returns>Obiekt reprezentujący format rozsztrzyganego pliku.</returns>
        public virtual SubtitlesFileFormat Resolve()
        {
            var formatsWithMatchingExtension = from format in strategyRepository.RegisteredFormats
                                               where format.IsExtensionCorrect(file.Extension)
                                               select format;

            foreach (var format in formatsWithMatchingExtension)
            {
                Type          strategyType = strategyRepository.GetStrategyForFormat(format);
                IEditStrategy stategy      = (IEditStrategy)Activator.CreateInstance(strategyType, file.Content);

                //To do: zastanowić się czy to jest dobry sposób sprawdzania poprawności formatu.
                //To do: może lepiej stowrzyc jakies ogolne NextEntry bo nie koniecznie musi być zawsze czas.
                if (stategy.NextTimedEntry() != null)
                {
                    return(format);
                }
            }

            return(new UnresolvedFileFormat());
        }
Esempio n. 4
0
        /// <summary>
        /// Wykonuje operacje synchronizacji
        /// w oparciu o zawierane w kolekcji SynchronizationPoints, punkty synchronizacji.
        /// </summary>
        public void Synchronize()
        {
            var orderedSyncPoints = synchronizationPoints.OrderBy(point => point.OrginalTiming);
            var points            = (from p in orderedSyncPoints select(double) p.OrginalTiming).ToArray();
            var values            = (from p in orderedSyncPoints select(double) p.CorrectTiming).ToArray();
            var method            = Interpolate.LinearBetweenPoints(points, values);

            IEditStrategy editStrategy = this.CreateStrategyForCurrentFormat();

            TimedEntry entry = null;

            while ((entry = editStrategy.NextTimedEntry()) != null)
            {
                entry.TimingStart = (long)method.Interpolate(entry.TimingStart);
                if (entry.UsesTimingEnd)
                {
                    entry.TimingEnd = (long)method.Interpolate(entry.TimingEnd);
                }

                editStrategy.SaveCurrentEntry();
            }

            SetEditorContent(editStrategy.Content);
        }
Esempio n. 5
0
        /// <summary>
        ///  Odejmuje od timingu napisów podaną wartość.
        /// </summary>
        /// <param name="timing">Wartość o jaką ma zostać zmniejszony timing.</param>
        /// <param name="selectionStart">Indeks określający początek zaznaczenia.</param>
        /// <param name="selectionLength">Długość zazanaczenia wyrażona poprzez liczbę znaków.</param>
        /// <param name="selectionIncludesLastNewLine">Określa czy zaznaczenie sięgające do końca lini, będzie zawierać znak nowej lini.</param>
        public void SubstractTiming(long timing, int selectionStart, int selectionLength, bool selectionIncludesLastNewLine = false)
        {
            IEditStrategy editStrategy = this.CreateStrategyForCurrentFormat();

            //Wartość korekcji długości zaznaczenia, mająca zachować początkowy obszat zaznaczenia pomimow ewentualnych zmian długości tekstu
            //wynikłych ze zmiany wartości timingów.
            int selectionLengthAdjustment = 0;

            TimedEntry entry = null;

            while ((entry = editStrategy.NextTimedEntry()) != null)
            {
                int entryStart         = entry.Start;
                int entryEnd           = entry.Start + entry.Length;
                int entryInitialLength = entry.Length;
                int selectionEnd       = selectionStart + selectionLength + selectionLengthAdjustment;

                //Zaznaczenie nie obejmuje znaku nowej lini dla ostatniego wpisu, więc w sytuacji kiedy sięga ono końca wpisu
                //istnieje konieczność zwiększenia jego długości o znak nowej lini, tak aby jego indeks końca nie mniejszy
                //niż indeks końca wpisu.
                if ((!selectionIncludesLastNewLine) &&
                    (entryEnd == selectionEnd + 2) &&
                    entry.Content.EndsWith(Environment.NewLine))
                {
                    selectionEnd += 2;
                }


                //Wpis znajduje się przed zaznaczeniem;
                if (entryEnd < selectionStart)
                {
                    continue;
                }
                //Wpis znajduje sie w całości w zaznaczeniu.
                else if ((entryStart >= selectionStart) && (entryEnd <= selectionEnd))
                {
                    entry.TimingStart = entry.TimingStart - timing < 0 ? 0 : entry.TimingStart - timing;
                    if (entry.UsesTimingEnd)
                    {
                        entry.TimingEnd = entry.TimingEnd - timing < 0 ? 0 : entry.TimingEnd - timing;
                    }

                    editStrategy.SaveCurrentEntry();

                    selectionLengthAdjustment += entry.Length - entryInitialLength;
                }
                //Wpis przecina się z zaznaczeniem.
                else if (((entryStart < selectionStart) && (entryEnd <= selectionEnd)) ||
                         ((entryStart < selectionStart) && (entryEnd > selectionEnd)) ||
                         ((entryStart >= selectionStart) && (entryEnd < selectionEnd)))
                {
                    if (IsTimingStartInSelection(entry, selectionStart, selectionEnd))
                    {
                        entry.TimingStart = entry.TimingStart - timing < 0 ? 0 : entry.TimingStart - timing;
                    }

                    if ((entry.UsesTimingEnd) && (IsTimingEndInSelection(entry, selectionStart, selectionEnd)))
                    {
                        entry.TimingEnd = entry.TimingEnd - timing < 0 ? 0 : entry.TimingEnd - timing;
                    }

                    editStrategy.SaveCurrentEntry();

                    selectionLengthAdjustment += entry.Length - entryInitialLength;
                }
                //Wpis znajduje się za zaznaczeniem
                else if (entryStart > selectionEnd)
                {
                    break;
                }
            }

            SetEditorContent(editStrategy.Content);
        }