Пример #1
0
 /// <summary>
 /// Retourne la liste des positions des derniers caractères de chaque ligne (dans S).
 /// </summary>
 /// <remarks>Utilise <c>finDeLignes</c> comme cache.</remarks>
 /// <returns>La liste des positions des derniers caractères de chaque ligne (dans S)</returns>
 protected override List <int> GetLastLinesPos()
 {
     logger.ConditionalDebug("GetLastLinesPos");
     if (finsDeLigne == null)
     {
         logger.ConditionalTrace("txtRange.Start: {0}, txtRange.Length: {1}", txtRange.Start, txtRange.Length);
         finsDeLigne = new List <int>(7);
         int       i = 1;
         int       startColoredLine = 0;
         TextRange theLine          = txtRange.Lines(i);
         while ((theLine.Start > startColoredLine) && (theLine.Start + theLine.Length) <= (txtRange.Start + txtRange.Length))
         {
             logger.ConditionalTrace("i: {0}, theLine - Start: {1}, Length: {2}", i, theLine.Start, theLine.Length);
             if (theLine.Length > 0)
             {
                 int endFormattedLine = theLine.Start + theLine.Length - 1;
                 finsDeLigne.Add(endFormattedLine - txtRange.Start);
             }
             startColoredLine = theLine.Start;
             i++;
             theLine = txtRange.Lines(i);
         }
     }
     logger.ConditionalTrace("EXIT GetLastLinesPos");
     return(finsDeLigne);
 }
Пример #2
0
        // ****************************************************************************************
        // *                                     public methods                                   *
        // ****************************************************************************************

        public RTBText(RichTextBox theRTB)
            : base(theRTB.Text)
        {
            logger.ConditionalDebug("RTBText");
            rtb = theRTB;
            logger.ConditionalTrace(rtb.Text);
            finDeLignes = new List <int>();
            if (theRTB.Multiline)
            {
                int      lineStart = 0;
                string[] theLines  = theRTB.Lines;
                for (int i = 0; i < theLines.Length; i++)
                {
                    int eol = lineStart + theLines[i].Length - 1;
                    finDeLignes.Add(eol);
                    lineStart = eol + 2;
                }
            }
#if DEBUG
            for (int i = 0; i < finDeLignes.Count; i++)
            {
                logger.ConditionalTrace("finDeLignes[{0}] == {1}", i, finDeLignes[i]);
            }
#endif
        }
Пример #3
0
        /// <summary>
        /// Constructor of a FormatButton. The different <c>PictureBox</c>es must be at exactly the same possition. Their visibility is
        /// set according to the start status.
        /// </summary>
        /// <param name="inUnsetPict">The <c>PictureBox</c> that shows unset status.</param>
        /// <param name="inSetPict">The <c>PictureBox</c> that shows set status.</param>
        /// <param name="inPressedPict">The <c>PictureBox</c> that shows the status when the button is pressed.</param>
        /// <param name="inSetOverPict">The <c>PictureBox</c> that shows the status when the mouse is over the set button. This is typically a
        /// supplementary visible frame around the button</param>
        /// <param name="inSetAct">The method that must be called when the button is set</param>
        /// <param name="inUnsetAct">The method that must be called when the button is unset</param>
        /// <param name="startState"><c>true</c> means set, <c>false</c> means unset</param>
        public FormatButtonHandler2(PictureBox inPictBox,
                                    Image inUnsetPict,
                                    Image inSetPict,
                                    Image inPressedPict,
                                    Image inSetOverPict,
                                    Action inSetAct,
                                    Action inUnsetAct,
                                    bool startState)
        {
            logger.ConditionalTrace("Contructor FormatButtonHandler");
            picts  = new Image[(int)Pict.nrPict];
            theBox = inPictBox;
            picts[(int)Pict.pressedPict] = inPressedPict;
            picts[(int)Pict.setOverPict] = inSetOverPict;
            picts[(int)Pict.setPict]     = inSetPict;
            picts[(int)Pict.unsetPict]   = inUnsetPict;
            setFormat   = inSetAct;
            unsetFormat = inUnsetAct;
            activePict  = Pict.nrPict; // no picture displayed yet

            if (startState)
            {
                state = State.set;
            }
            else
            {
                state = State.unset;
            }
            ActivatePict(state);

            theBox.MouseDown  += new System.Windows.Forms.MouseEventHandler(this.pbx_MouseDown);
            theBox.MouseEnter += new System.EventHandler(this.pbx_MouseEnter);
            theBox.MouseLeave += new System.EventHandler(this.pbx_MouseLeave);
            theBox.MouseUp    += new System.Windows.Forms.MouseEventHandler(this.pbx_MouseUp);
        }
Пример #4
0
 protected AutomLetter()
     : base(" ", 0)
 {
     logger.ConditionalTrace("AutomLetter");
     Letter    = '$';
     ruleOrder = null;
     rules     = null;
 }
        private TimeSpan DispatchTimers()
        {
            var now = GetTimestamp();

            if (timers.Count == 0)
            {
                Log.ConditionalTrace("Quick return 1");
                nextTimerDue = TimeSpan.MaxValue;
                return(Timeout.InfiniteTimeSpan);
            }
            // [Heuristic]
            // Problem: We don't want to recheck the list each time a new Task
            // is processed from the queue.
            // Idea: On very high load, when the queue is permanently full and
            //       the current cache is in 'inf' cache state starting timers
            //       will only add more load which won't be processed anyway.
            //       So we wait for that the queue is empty then we recheck.
            //       When we are not in 'inf' state we will just check like normal.
            if (queue.Count > 0 && now + CombineTimerThreshold < nextTimerDue && nextTimerDue != TimeSpan.MaxValue)
            {
                Log.ConditionalTrace("Quick return 2");
                return(nextTimerDue - now);
            }

            Log.ConditionalTrace("Recalc");

            var timeTillNextTimer = TimeSpan.MaxValue;

            foreach (var timer in timers)             // TODO might be modified
            {
                var      due = timer.Timestamp + timer.Interval;
                TimeSpan wait;
                if (due < now)
                {
                    _ = Invoke(timer.Method);
                    timer.Timestamp = GetTimestamp();
                    wait            = timer.Interval;
                }
                else
                {
                    wait = due - now;
                }

                if (wait < timeTillNextTimer)
                {
                    timeTillNextTimer = wait;
                }
            }

            Trace.Assert(timeTillNextTimer != TimeSpan.MaxValue);

            timeTillNextTimer = timeTillNextTimer.Max(CombineTimerThreshold);
            nextTimerDue      = now + timeTillNextTimer;
            return(timeTillNextTimer);
        }
Пример #6
0
 /// <summary>
 /// Permet de mettre le <see cref="CharFormatting"/> pour une famille de ponctuation
 /// sans que la situation du mâître soit impactée.
 /// </summary>
 /// <remarks>Devrait être <c>private</c>, mais doit être visible pour la gestion des
 /// annulations. NE PAS UTILISER DANS UN AUTRE CONTEXTE!</remarks>
 /// <param name="p">La famille de ponctuation.</param>
 /// <param name="toCF">Le nouveau <see cref="CharFormatting"/>.</param>
 public void SetCFwoState(Ponctuation p, CharFormatting toCF)
 {
     logger.ConditionalTrace("SetCFwoState, p: {0}, to: {1}", p, toCF.ToString());
     if (toCF != charFormats[p])
     {
         UndoFactory.ExceutingAction(new PonctAction("Format ponct.", this, "ponctCF",
                                                     p, charFormats[p], toCF));
         charFormats[p] = toCF;
         OnPonctFormattingModified(p);
     }
 }
Пример #7
0
        /// <summary>
        /// Cherche les phonèmes dans <c>pw</c> et complète <c>pw</c> pour qu'il contienne l'information.
        /// </summary>
        /// <param name="pw">Le <see cref="PhonWord"/> à analyser et à compléter avec ses phonèmes.</param>
        /// <param name="conf">La <see cref="Config"/> à utiliser au cours de cette analyse.</param>
        public void FindPhons(PhonWord pw, Config conf)
        {
            logger.ConditionalTrace("FindPhons");
            Debug.Assert(pw != null);

            if (!AutomDictionary.FindPhons(pw, conf))
            {
                int         pos = 0;
                string      w   = pw.GetWord();
                AutomLetter al;

                while (pos < w.Length)
                {
                    if (automLetters.TryGetValue(w[pos], out al))
                    {
                        al.FireRule(pw, ref pos, conf);
                    }
                    else if (automLetters.TryGetValue('*', out al))
                    {
                        // strange character encountered --> handle it as letter '*'
                        al.FireRule(pw, ref pos, conf);
                    }
                    else
                    {
                        // this should not happen!!
                        string message = String.Format(ConfigBase.cultF, "La règle générique n'existe pas et on en aurait besoin...");
                        throw new KeyNotFoundException(message);
                    }
                } // while
            }     // if
        }         // FindPhons
Пример #8
0
        private bool TryResolve(Module module, bool force)
        {
            var result = TryResolve(module.Obj, module.Status, force);

            if (result)
            {
                module.SetInitalized();
                Log.ConditionalTrace("Module {0} added", module);
            }
            else
            {
                Log.ConditionalTrace("Module {0} waiting for {1}", module,
                                     string.Join(", ", GetUnresolvedResolvable(module).Select(x => x.Name)));
            }

            return(result);
        }
Пример #9
0
 private void UpdateRichTextBox(object sender, EventArgs e)
 {
     logger.ConditionalTrace("UpdateRichTextBox");
     if (!resetting)
     {
         ProgressNotifier.thePN.Start();
         rTBText.MarkNoir(theConfCopy);
         rTBText.MarkDuo(theConfCopy);
         ProgressNotifier.thePN.Completed();
     }
 }
Пример #10
0
        /// <summary>
        /// Checks to ensure we haven't extracted too many bytes, or taken too long.
        /// This exists primarily to mitigate the risks of quines (archives that
        /// contain themselves) and zip bombs (specially constructed to expand to huge
        /// sizes).
        /// Ref: https://alf.nu/ZipQuine
        /// </summary>
        /// <param name="additionalBytes"></param>
        private void CheckResourceGovernor(long additionalBytes = 0)
        {
            Logger.ConditionalTrace("CheckResourceGovernor(duration={0}, bytes={1})", GovernorStopwatch.Elapsed.TotalMilliseconds, CurrentOperationProcessedBytesLeft);

            if (GovernorStopwatch.Elapsed > Timeout)
            {
                throw new TimeoutException(string.Format($"Processing timeout exceeded: {GovernorStopwatch.Elapsed.TotalMilliseconds} ms."));
            }

            if (CurrentOperationProcessedBytesLeft - additionalBytes <= 0)
            {
                throw new OverflowException(string.Format($"Too many bytes extracted, exceeding limit."));
            }
        }
Пример #11
0
        /************************       CONSTRUCTOR          ******************************************
         * Create an AutomRule Object
         * s:               the string containing the specification of the automata
         * pos:             on entry, the position of the first character of the Rule (should be ')
         *                  on exit the position of the last character of the Rule (should be ']')
         * SortedRuleNames: The valid RuleNames in a sorted array where BinarySearch can be executed.
         *
         * if s is not a valid Rule specification, an ArgumentException is thrown.
         * The RuleName can be read in the correpsonding Property.
         ***********************************************************************************************/
        public AutomRule(string s, ref int pos, List <string> SortedRuleNames)
            : base(s, pos)
        {
            logger.ConditionalTrace("AutomRule");

            /* A Rule has the Syntax
             * 'ruleName' : [{list of DirectionRegex separated by ','}, 'phoneme', pas]
             * where
             *    regexRule is '+|-':/regEx/i
             *    phoneme is a string
             *    pas is an integer
             *
             *    ruleName has to be part of ruleNames
             */

            // Let's parse the ruleName
            Debug.Assert(s[pos] == '\'', String.Format(ConfigBase.cultF, "La pos {0} de {1} n'est pas un AutomRule, il ne commence pas par \'.",
                                                       pos - start, s.Substring(start, (pos + 1) - start)));
            pos = GetNextChar(pos + 1);
            var endOfRuleNameApostrophyPos = s.IndexOf('\'', pos);

            Debug.Assert(endOfRuleNameApostrophyPos > pos, String.Format(ConfigBase.cultF, "La pos {0} de {1} n'est pas un AutomRule, le nom de la règle ne se termine pas par \'.",
                                                                         pos - start, s.Substring(start, (pos + 1) - start)));
            RuleName = s.Substring(pos, endOfRuleNameApostrophyPos - pos).Trim();
            // check that ruleName is in ruleNames
            Debug.Assert(SortedRuleNames.BinarySearch(RuleName) >= 0, String.Format(ConfigBase.cultF, "AutomRule: {0} ne se trouve pas dans la liste des noms de règles.", RuleName));
            pos = endOfRuleNameApostrophyPos;

            // Let's find the colon
            pos = GetNextChar(pos + 1);
            Debug.Assert(s[pos] == ':', String.Format(ConfigBase.cultF, "La pos {0} de {1} n'est pas un AutomRule, on attend un \':\'",
                                                      pos - start, s.Substring(start, (pos + 1) - start)));

            // let's find the [
            pos = GetNextChar(pos + 1);
            Debug.Assert(s[pos] == '[', String.Format(ConfigBase.cultF, "La pos {0} de {1} n'est pas un AutomRule, on attend un \'[\'",
                                                      pos - start, s.Substring(start, (pos + 1) - start)));

            // let's find the RuleFilter
            pos = GetNextChar(pos + 1);
            rf  = new AutomRuleFilter(s, ref pos);

            // let's find the comma
            pos = GetNextChar(pos + 1);
            Debug.Assert(s[pos] == ',', String.Format(ConfigBase.cultF, "La pos {0} de {1} n'est pas un AutomRule, on attend une \',\' avant le phonème.",
                                                      pos - start, s.Substring(start, (pos + 1) - start)));

            // let's find the phoneme
            pos = GetNextChar(pos + 1);
            Debug.Assert(s[pos] == '\'', String.Format(ConfigBase.cultF, "La pos {0} de {1} n'est pas un AutomRule, on attend \' au début du phonème.",
                                                       pos - start, s.Substring(start, (pos + 1) - start)));

            // let's find the phoneme name
            pos = GetNextChar(pos + 1);
            var endOfPhonemeApostrophyPos = s.IndexOf('\'', pos);

            Debug.Assert(endOfPhonemeApostrophyPos > pos, String.Format(ConfigBase.cultF, "La pos {0} de {1} n'est pas un AutomRule, le nom du phonème ne se termine pas par \'.",
                                                                        pos - start, s.Substring(start, (pos + 1) - start)));
            var phonemeName = s.Substring(pos, endOfPhonemeApostrophyPos - pos).Trim();

            p   = (Phonemes)Enum.Parse(typeof(Phonemes), phonemeName);
            pos = endOfPhonemeApostrophyPos;

            // let's find the comma
            pos = GetNextChar(pos + 1);
            Debug.Assert(s[pos] == ',', String.Format(ConfigBase.cultF, "La pos {0} de {1} n'est pas un AutomRule, on attend une \',\' avant le pas.",
                                                      pos - start, s.Substring(start, (pos + 1) - start)));

            // let's find the increment i.e. le pas
            pos = GetNextChar(pos + 1);
            var endOfNumberPos = s.IndexOfAny("],".ToCharArray(), pos);

            Debug.Assert(endOfNumberPos > pos, String.Format(ConfigBase.cultF,
                                                             "La pos {0} de {1} n'est pas un AutomRule, on attend \']\' ou \',\' après le pas.",
                                                             pos - start, s.Substring(start, (pos + 1) - start)));
            var theIntString = s.Substring(pos, endOfNumberPos - pos).Trim();

            incr = int.Parse(theIntString, ConfigBase.cultF);
            pos  = endOfNumberPos;

            // if we are on a coma, there is an identifier to load.
            if (s[pos] == ',')
            {
                pos = GetNextChar(pos + 1);
                var endOfFlagName = s.IndexOf(']', pos);
                Debug.Assert(endOfFlagName > pos, String.Format(ConfigBase.cultF,
                                                                "La pos {0} de {1} n'est pas un AutomRule, on attend \']\' après le nom de flag.",
                                                                pos - start, s.Substring(start, (pos + 1) - start)));
                var flagName = s.Substring(pos, endOfFlagName - pos).Trim();
                flag = (ColConfWin.RuleFlag)Enum.Parse(typeof(ColConfWin.RuleFlag), flagName);
                pos  = endOfFlagName;
            }
            else
            {
                flag = ColConfWin.RuleFlag.undefined;
            }

            end = pos;
        } // constructor AutomRule
Пример #12
0
        /// <summary>
        /// Cherche une ou plusieurs diérèses dans le vers, transforme les mots correspondants
        /// jusqu'à ce que le nombre de pieds voulu soit atteint ou qu'il n'y ait plus de diérèse
        /// détectable.
        /// </summary>
        /// <param name="conf">La <c>Config</c> à utiliser pour l'identification des pieds.</param>
        /// <param name="nbrPiedsVoulu">Le nombre de pieds souhaité après la mise en évidence des
        /// diérèses. </param>
        /// <exception cref="ArgumentOutOfRangeException">Si <c>nbrPiedsVoulu</c> n'est pas
        /// plus grand que zéro.</exception>
        public void ChercheDierese(int nbrPiedsVoulu)
        {
            logger.ConditionalDebug("ChercheDierese, nrPiedsVoulu: {0}, vers; {1}", nbrPiedsVoulu, ToString());
            if (nbrPiedsVoulu > MaxNrPieds)
            {
                logger.Info(
                    "Chercher diérèse pour vers de plus de [0] pieds. Non exécuté. nrPiedsVoulu: {1}",
                    MaxNrPieds, nbrPiedsVoulu);
                return;
            }
            if (nbrPiedsVoulu <= 0)
            {
                logger.Fatal("nbrPiedsVoulu == {0}", nbrPiedsVoulu);
                throw new ArgumentOutOfRangeException(nameof(nbrPiedsVoulu), "doit être plus grand que 0");
            }
            // traitement spécial pour les nombres de pieds pairs, parcequ'ils le valent bien!
            if (nbrPiedsVoulu % 2 == 0)
            {
                // nombre pair de pieds
                // Y a-t-il un hémistiche à la moitié du vers ou juste avant?
                int             demiVers = nbrPiedsVoulu / 2;
                List <PhonWord> moitie1  = new List <PhonWord>(5);
                int             i        = 0;
                int             piedsM1  = 0;
                while (i < pWordList.Count && piedsM1 < demiVers - 1)
                {
                    moitie1.Add(pWordList[i]);
                    piedsM1 = ComptePieds(moitie1);
                    i++;
                }

                // En prenant les cas dans cet ordre, on favorise légèrement la recherche de la
                // diérèse dans la première partie du vers. Il y a au moins un exemple dans le
                // poème de référence où cette approche est justifiée:
                // "D'affreux bohémiens, des vainqueurs de charnier"
                // Faut-il rallonger "bohémines" ou "charnier"? Il y a certainement des cas
                // qui demanderaient l'approche opposée. Je ne vois pas comment les distinguer
                // sans tenir compte du sens ou d'éléments que j'ignore jusqu'ici comme la
                // virgule dans le vers de V. Hugo.

                if (piedsM1 == demiVers - 1)
                {
                    List <PhonWord> moitie2 = new List <PhonWord>(5);
                    while (i < pWordList.Count)
                    {
                        moitie2.Add(pWordList[i]);
                        i++;
                    }
                    ChercherDierese(moitie1, demiVers);
                    if (ComptePieds(pWordList) < nbrPiedsVoulu)
                    {
                        ChercherDierese(moitie2, demiVers);
                    }
                    if (ComptePieds(pWordList) < nbrPiedsVoulu)
                    {
                        ChercherDierese(pWordList, nbrPiedsVoulu);
                    }
                }
                else if (piedsM1 == demiVers)
                {
                    // hypothèse: on a trouvé l'hémistiche
                    List <PhonWord> moitie2 = new List <PhonWord>(5);
                    while (i < pWordList.Count)
                    {
                        moitie2.Add(pWordList[i]);
                        i++;
                    }
                    ChercherDierese(moitie2, demiVers);
                    if (ComptePieds(pWordList) < nbrPiedsVoulu)
                    {
                        ChercherDierese(moitie1, demiVers);
                    }
                    if (ComptePieds(pWordList) < nbrPiedsVoulu)
                    {
                        ChercherDierese(pWordList, nbrPiedsVoulu);
                    }
                }
                else if (piedsM1 > demiVers)
                {
                    // On est allés trop loin.
                    // on n'a pas réussi à trouver d'hémistiche.
                    ChercherDierese(pWordList, nbrPiedsVoulu);
                }
                else
                {
                    // Bizarre: le vers entier semble faire moins de la moitié des pieds voulus...
                    logger.Info("On demande {0} pieds pour le vers {1}.", nbrPiedsVoulu, ToString());
                    ChercherDierese(pWordList, nbrPiedsVoulu); // ça ne devrait pas marcher...
                }
            }
            else
            {
                // nombre impair de pieds voulu.
                logger.ConditionalDebug("Nombre impair ({0}) de pieds voulus pour {1}",
                                        nbrPiedsVoulu, ToString());
                ChercherDierese(pWordList, nbrPiedsVoulu);
            }
            nrPieds = ComptePieds(pWordList);
            if (nrPieds != nbrPiedsVoulu)
            {
                logger.ConditionalTrace(
                    "!! Diérèse pas trouvée. nbrPiedsVoulu: {0}, nrPieds: {1}, vers: \'{2}\'," +
                    "syls: \'{3}\'", nbrPiedsVoulu, nrPieds, ToString(), Syllabes());
            }
        }
Пример #13
0
 /// <summary>
 /// Indique la progression de la tâche.
 /// </summary>
 /// <remarks>Autant que possible, ne pas appeler cette méthode plus d'une fois par pourcent.</remarks>
 /// <param name="progression">en pourcents (0 - 100) l'état de progression de la tâche.</param>
 public void InProgress(int progression)
 {
     logger.ConditionalTrace(ConfigBase.cultF, "InProgress {0}%", progression);
     OnProgressEvent(progression);
 }
Пример #14
0
 /// <summary>
 /// Empêche que les actions soient enregistrées pour pouvoir ensuite être annulées.
 /// Fonctionne en paire avec <see cref="EnableUndoRegistration"/> qui doit être appelé
 /// quand les actions peuvent à nouveau être enregistrées.
 /// </summary>
 /// <remarks>Les appels de cette méthode peuvent être imbriqués. Mais un
 /// <see cref="EnableUndoRegistration"/> doit correspondre à un <c>Disable</c></remarks>
 public static void DisableUndoRegistration()
 {
     logger.ConditionalTrace("DisableUndoRegistration");
     disableRegistering++;
 }