Example #1
0
        private static List <ReplaceExpression> LoadRules()
        {
            var list = new List <ReplaceExpression>();

            foreach (var setting in Configuration.Settings.MultipleSearchAndReplaceList)
            {
                var rule = new ReplaceExpression(setting.FindWhat, setting.ReplaceWith, EnglishSearchTypeToLocal(setting.SearchType));
                rule.Checked = setting.Enabled;
                list.Add(rule);
            }
            return(list);
        }
Example #2
0
 public void Visit(ReplaceExpression expression, CommonTree tree)
 {
     Parent(tree).Children.Add(expression);
     SetLine(expression, tree);
     VisitChildren(tree);
 }
Example #3
0
        private void GeneratePreview()
        {
            Cursor = Cursors.WaitCursor;
            FixedSubtitle = new Subtitle(_subtitle);
            DeleteIndices = new List<int>();
            FixCount = 0;
            listViewFixes.BeginUpdate();
            listViewFixes.Items.Clear();
            var replaceExpressions = new HashSet<ReplaceExpression>();
            foreach (ListViewItem item in listViewReplaceList.Items)
            {
                if (item.Checked)
                {
                    string findWhat = item.SubItems[1].Text;
                    if (!string.IsNullOrWhiteSpace(findWhat))
                    {
                        string replaceWith = item.SubItems[2].Text.Replace(@"\n", Environment.NewLine);
                        string searchType = item.SubItems[3].Text;
                        var mpi = new ReplaceExpression(findWhat, replaceWith, searchType);
                        replaceExpressions.Add(mpi);
                        if (mpi.SearchType == ReplaceExpression.SearchRegEx && !_compiledRegExList.ContainsKey(findWhat))
                        {
                            _compiledRegExList.Add(findWhat, new Regex(findWhat, RegexOptions.Compiled | RegexOptions.Multiline));
                        }
                    }
                }
            }

            foreach (Paragraph p in _subtitle.Paragraphs)
            {
                bool hit = false;
                string newText = p.Text;
                foreach (ReplaceExpression item in replaceExpressions)
                {
                    if (item.SearchType == ReplaceExpression.SearchCaseSensitive)
                    {
                        if (newText.Contains(item.FindWhat))
                        {
                            hit = true;
                            newText = newText.Replace(item.FindWhat, item.ReplaceWith);
                        }
                    }
                    else if (item.SearchType == ReplaceExpression.SearchRegEx)
                    {
                        Regex r = _compiledRegExList[item.FindWhat];
                        if (r.IsMatch(newText))
                        {
                            hit = true;
                            newText = r.Replace(newText, item.ReplaceWith);
                        }
                    }
                    else
                    {
                        int index = newText.IndexOf(item.FindWhat, StringComparison.OrdinalIgnoreCase);
                        if (index >= 0)
                        {
                            hit = true;
                            do
                            {
                                newText = newText.Remove(index, item.FindWhat.Length).Insert(index, item.ReplaceWith);
                                index = newText.IndexOf(item.FindWhat, index + item.ReplaceWith.Length, StringComparison.OrdinalIgnoreCase);
                            }
                            while (index >= 0);
                        }
                    }
                }
                if (hit && newText != p.Text)
                {
                    FixCount++;
                    AddToPreviewListView(p, newText);
                    int index = _subtitle.GetIndex(p);
                    FixedSubtitle.Paragraphs[index].Text = newText;
                    if (!string.IsNullOrWhiteSpace(p.Text) && (string.IsNullOrWhiteSpace(newText) || string.IsNullOrWhiteSpace(HtmlUtil.RemoveHtmlTags(newText, true))))
                    {
                        DeleteIndices.Add(index);
                    }
                }
            }
            listViewFixes.EndUpdate();
            groupBoxLinesFound.Text = string.Format(Configuration.Settings.Language.MultipleReplace.LinesFoundX, FixCount);
            Cursor = Cursors.Default;
            DeleteIndices.Reverse();
        }
Example #4
0
        public override void AwakeFromNib()
        {
            base.AwakeFromNib();

            InitializeRulesTable(_rulesTable);
            InitializePreviewTable(_previewTable);

            this.WillClose += (object sender, EventArgs e) =>
            {
                NSApplication.SharedApplication.StopModal();
            };
            var l = Configuration.Settings.Language.MultipleReplace;

            Title = l.Title;
            _findLabel.StringValue    = l.FindWhat;
            _replaceLabel.StringValue = l.ReplaceWith;

            _findType.RemoveAllItems();
            _findType.AddItem(Configuration.Settings.Language.MultipleReplace.Normal);
            _findType.AddItem(Configuration.Settings.Language.MultipleReplace.CaseSensitive);
            _findType.AddItem(Configuration.Settings.Language.MultipleReplace.RegularExpression);

            _buttonOk.Activated += (object sender, EventArgs e) =>
            {
                (WindowController as MultipleReplaceController).OkPressed();
                Close();
            };

            _buttonCancel.Activated += (object sender, EventArgs e) =>
            {
                Close();
            };

            _addButton.Activated += (object sender, EventArgs e) =>
            {
                string findText = _findText.StringValue.RemoveControlCharacters();
                if (findText.Length > 0)
                {
                    int searchType = (int)_findType.IndexOfSelectedItem;
                    if (searchType == SearchTypeRegularExpression)
                    {
                        if (!Utilities.IsValidRegex(findText))
                        {
                            MessageBox.Show(Configuration.Settings.Language.General.RegularExpressionIsNotValid);
                            _findText.BecomeFirstResponder();
                            return;
                        }
                    }
                    var rule = new ReplaceExpression(findText, _replaceText.StringValue.RemoveControlCharacters(), searchType)
                    {
                        Checked = true,
                    };
                    MultipleSearchAndReplaceList.Add(rule);
                    ShowRules(MultipleSearchAndReplaceList);
                    _findText.StringValue    = string.Empty;
                    _replaceText.StringValue = string.Empty;
                    (WindowController as MultipleReplaceController).GeneratePreview();
                    _findText.BecomeFirstResponder();
                    SaveReplaceList(false);
                }
            };

            _updateButton.Activated += (object sender, EventArgs e) =>
            {
                var index = (int)_rulesTable.SelectedRow;
                if (index >= 0 && index < MultipleSearchAndReplaceList.Count)
                {
                    var    item       = MultipleSearchAndReplaceList[index];
                    string findText   = _findText.StringValue.RemoveControlCharacters();
                    int    searchType = (int)_findType.IndexOfSelectedItem;
                    if (searchType == SearchTypeRegularExpression)
                    {
                        if (!Utilities.IsValidRegex(findText))
                        {
                            MessageBox.Show(Configuration.Settings.Language.General.RegularExpressionIsNotValid);
                            _findText.BecomeFirstResponder();
                            return;
                        }
                    }
                    item.FindWhat    = findText;
                    item.ReplaceWith = _replaceText.StringValue;
                    item.SearchType  = searchType;
                    ShowRules(MultipleSearchAndReplaceList);
                    _rulesTable.SelectRow((nint)index, false);
                }
            };

            MultipleSearchAndReplaceList = LoadRules();
            ShowRules(MultipleSearchAndReplaceList);
            (WindowController as MultipleReplaceController).GeneratePreview();
        }
        private void GeneratePreview()
        {
            Cursor        = Cursors.WaitCursor;
            FixedSubtitle = new Subtitle(_subtitle);
            DeleteIndices = new List <int>();
            FixCount      = 0;
            listViewFixes.BeginUpdate();
            listViewFixes.Items.Clear();
            var replaceExpressions = new HashSet <ReplaceExpression>();

            foreach (ListViewItem item in listViewReplaceList.Items)
            {
                if (item.Checked)
                {
                    string findWhat = item.SubItems[1].Text;
                    if (!string.IsNullOrWhiteSpace(findWhat))
                    {
                        string replaceWith = item.SubItems[2].Text.Replace(@"\n", Environment.NewLine);
                        string searchType  = item.SubItems[3].Text;
                        var    mpi         = new ReplaceExpression(findWhat, replaceWith, searchType);
                        replaceExpressions.Add(mpi);
                        if (mpi.SearchType == ReplaceExpression.SearchRegEx && !_compiledRegExList.ContainsKey(findWhat))
                        {
                            _compiledRegExList.Add(findWhat, new Regex(findWhat, RegexOptions.Compiled | RegexOptions.Multiline));
                        }
                    }
                }
            }

            foreach (Paragraph p in _subtitle.Paragraphs)
            {
                bool   hit     = false;
                string newText = p.Text;
                foreach (ReplaceExpression item in replaceExpressions)
                {
                    if (item.SearchType == ReplaceExpression.SearchCaseSensitive)
                    {
                        if (newText.Contains(item.FindWhat))
                        {
                            hit     = true;
                            newText = newText.Replace(item.FindWhat, item.ReplaceWith);
                        }
                    }
                    else if (item.SearchType == ReplaceExpression.SearchRegEx)
                    {
                        Regex r = _compiledRegExList[item.FindWhat];
                        if (r.IsMatch(newText))
                        {
                            hit     = true;
                            newText = r.Replace(newText, item.ReplaceWith);
                        }
                    }
                    else
                    {
                        int index = newText.IndexOf(item.FindWhat, StringComparison.OrdinalIgnoreCase);
                        if (index >= 0)
                        {
                            hit = true;
                            do
                            {
                                newText = newText.Remove(index, item.FindWhat.Length).Insert(index, item.ReplaceWith);
                                index   = newText.IndexOf(item.FindWhat, index + item.ReplaceWith.Length, StringComparison.OrdinalIgnoreCase);
                            }while (index >= 0);
                        }
                    }
                }
                if (hit && newText != p.Text)
                {
                    FixCount++;
                    AddToPreviewListView(p, newText);
                    int index = _subtitle.GetIndex(p);
                    FixedSubtitle.Paragraphs[index].Text = newText;
                    if (!string.IsNullOrWhiteSpace(p.Text) && (string.IsNullOrWhiteSpace(newText) || string.IsNullOrWhiteSpace(HtmlUtil.RemoveHtmlTags(newText, true))))
                    {
                        DeleteIndices.Add(index);
                    }
                }
            }
            listViewFixes.EndUpdate();
            groupBoxLinesFound.Text = string.Format(Configuration.Settings.Language.MultipleReplace.LinesFoundX, FixCount);
            Cursor = Cursors.Default;
            DeleteIndices.Reverse();
        }
        private void GeneratePreview()
        {
            Cursor        = Cursors.WaitCursor;
            FixedSubtitle = new Subtitle(_subtitle);
            DeleteIndices = new List <int>();
            FixCount      = 0;
            listViewFixes.BeginUpdate();
            listViewFixes.Items.Clear();
            var replaceExpressions = new HashSet <ReplaceExpression>();

            foreach (var group in Configuration.Settings.MultipleSearchAndReplaceGroups)
            {
                if (group.Enabled)
                {
                    foreach (var rule in group.Rules)
                    {
                        if (rule.Enabled)
                        {
                            string findWhat = rule.FindWhat;
                            if (!string.IsNullOrEmpty(findWhat)) // allow space or spaces
                            {
                                string replaceWith = RegexUtils.FixNewLine(rule.ReplaceWith);
                                findWhat = RegexUtils.FixNewLine(findWhat);
                                string searchType = rule.SearchType;
                                var    mpi        = new ReplaceExpression(findWhat, replaceWith, searchType);
                                replaceExpressions.Add(mpi);
                                if (mpi.SearchType == ReplaceExpression.SearchRegEx && !_compiledRegExList.ContainsKey(findWhat))
                                {
                                    _compiledRegExList.Add(findWhat, new Regex(findWhat, RegexOptions.Compiled | RegexOptions.Multiline));
                                }
                            }
                        }
                    }
                }
            }

            var fixes = new List <ListViewItem>();

            foreach (Paragraph p in _subtitle.Paragraphs)
            {
                bool   hit     = false;
                string newText = p.Text;
                foreach (ReplaceExpression item in replaceExpressions)
                {
                    if (item.SearchType == ReplaceExpression.SearchCaseSensitive)
                    {
                        if (newText.Contains(item.FindWhat))
                        {
                            hit     = true;
                            newText = newText.Replace(item.FindWhat, item.ReplaceWith);
                        }
                    }
                    else if (item.SearchType == ReplaceExpression.SearchRegEx)
                    {
                        Regex r = _compiledRegExList[item.FindWhat];
                        if (r.IsMatch(newText))
                        {
                            hit     = true;
                            newText = RegexUtils.ReplaceNewLineSafe(r, newText, item.ReplaceWith);
                        }
                    }
                    else
                    {
                        int index = newText.IndexOf(item.FindWhat, StringComparison.OrdinalIgnoreCase);
                        if (index >= 0)
                        {
                            hit = true;
                            do
                            {
                                newText = newText.Remove(index, item.FindWhat.Length).Insert(index, item.ReplaceWith);
                                index   = newText.IndexOf(item.FindWhat, index + item.ReplaceWith.Length, StringComparison.OrdinalIgnoreCase);
                            }while (index >= 0);
                        }
                    }
                }
                if (hit && newText != p.Text)
                {
                    FixCount++;
                    fixes.Add(MakePreviewListItem(p, newText));
                    int index = _subtitle.GetIndex(p);
                    FixedSubtitle.Paragraphs[index].Text = newText;
                    if (!string.IsNullOrWhiteSpace(p.Text) && (string.IsNullOrWhiteSpace(newText) || string.IsNullOrWhiteSpace(HtmlUtil.RemoveHtmlTags(newText, true))))
                    {
                        DeleteIndices.Add(index);
                    }
                }
            }
            listViewFixes.Items.AddRange(fixes.ToArray());
            listViewFixes.EndUpdate();
            groupBoxLinesFound.Text = string.Format(Configuration.Settings.Language.MultipleReplace.LinesFoundX, FixCount);
            Cursor = Cursors.Default;
            DeleteIndices.Reverse();
        }
 private static List<ReplaceExpression> LoadRules()
 {
     var list = new List<ReplaceExpression>();
     foreach (var setting in Configuration.Settings.MultipleSearchAndReplaceList)
     {
         var rule = new ReplaceExpression(setting.FindWhat, setting.ReplaceWith, EnglishSearchTypeToLocal(setting.SearchType));
         rule.Checked = setting.Enabled;
         list.Add(rule);
     }
     return list;
 }
        public override void AwakeFromNib()
        {
            base.AwakeFromNib();

            InitializeRulesTable(_rulesTable);
            InitializePreviewTable(_previewTable);

            this.WillClose += (object sender, EventArgs e) =>
            { 
                NSApplication.SharedApplication.StopModal(); 
            };
            var l = Configuration.Settings.Language.MultipleReplace;
            Title = l.Title;
            _findLabel.StringValue = l.FindWhat;
            _replaceLabel.StringValue = l.ReplaceWith;

            _findType.RemoveAllItems();
            _findType.AddItem(Configuration.Settings.Language.MultipleReplace.Normal);
            _findType.AddItem(Configuration.Settings.Language.MultipleReplace.CaseSensitive);
            _findType.AddItem(Configuration.Settings.Language.MultipleReplace.RegularExpression);
           
            _buttonOk.Activated += (object sender, EventArgs e) =>
            {
                (WindowController as MultipleReplaceController).OkPressed();
                Close();    
            };

            _buttonCancel.Activated += (object sender, EventArgs e) =>
            {
                Close();    
            };

            _addButton.Activated += (object sender, EventArgs e) =>
            {
                string findText = _findText.StringValue.RemoveControlCharacters();
                if (findText.Length > 0)
                {
                    int searchType = (int)_findType.IndexOfSelectedItem;
                    if (searchType == SearchTypeRegularExpression)
                    {
                        if (!Utilities.IsValidRegex(findText))
                        {                                
                            MessageBox.Show(Configuration.Settings.Language.General.RegularExpressionIsNotValid);
                            _findText.BecomeFirstResponder();
                            return;
                        }
                    }
                    var rule = new ReplaceExpression(findText, _replaceText.StringValue.RemoveControlCharacters(), searchType)
                    {
                        Checked = true,
                    };
                    MultipleSearchAndReplaceList.Add(rule);
                    ShowRules(MultipleSearchAndReplaceList);
                    _findText.StringValue = string.Empty;
                    _replaceText.StringValue = string.Empty;
                    (WindowController as MultipleReplaceController).GeneratePreview();
                    _findText.BecomeFirstResponder();
                    SaveReplaceList(false);
                }                
            };

            _updateButton.Activated += (object sender, EventArgs e) =>
            {
                var index = (int)_rulesTable.SelectedRow;
                if (index >= 0 && index < MultipleSearchAndReplaceList.Count)
                {
                    var item = MultipleSearchAndReplaceList[index];
                    string findText = _findText.StringValue.RemoveControlCharacters();
                    int searchType = (int)_findType.IndexOfSelectedItem;
                    if (searchType == SearchTypeRegularExpression)
                    {
                        if (!Utilities.IsValidRegex(findText))
                        {                                
                            MessageBox.Show(Configuration.Settings.Language.General.RegularExpressionIsNotValid);
                            _findText.BecomeFirstResponder();
                            return;
                        }
                    }
                    item.FindWhat = findText;
                    item.ReplaceWith = _replaceText.StringValue;
                    item.SearchType = searchType;
                    ShowRules(MultipleSearchAndReplaceList);
                    _rulesTable.SelectRow((nint)index, false);
                } 
            };

            MultipleSearchAndReplaceList = LoadRules();
            ShowRules(MultipleSearchAndReplaceList);
            (WindowController as MultipleReplaceController).GeneratePreview();           
        }