Exemplo n.º 1
0
        public void StartOfInput()
        {
            _lineParsingSession   = _lineParser.StartLineParsingSession();
            _extendedStreamReader = _fileHelper.GetExtendedStreamReader(_originalFilePath);
            _totalNumberOfLines   =
                _fileHelper.GetExtendedStreamReader(_originalFilePath)
                .GetLinesWithEofLine()
                .Count();

            var dependencyFileProperties = PropertiesFactory.CreateDependencyFileProperties(_fileConversionProperties.OriginalFilePath);

            dependencyFileProperties.PreferredLinkage = DependencyFileLinkOption.Embed;
            _fileConversionProperties.DependencyFiles.Add(dependencyFileProperties);

            ProgressInPercent = 0;
        }
        private void RecreateSyntaxFrame()
        {
            RemoveSyntaxFrame();
            var syntaxProps = _connection.ConnectionDescriptor.SyntaxProperties;

            if (syntaxProps == null)
            {
                return;
            }

            var container = PropertiesFactory.GetPropertiesContainer(syntaxProps);

            (pbSyntax as IPropertiesControl).SetProperties(container);

            cbLoadFromDefaultDatabase.Visibility = _connection.ConnectionDescriptor.SyntaxProvider.IsSupportDatabases() ? Visibility.Visible : Visibility.Hidden;
        }
        private FrameworkElement CreateSyntaxEditControl(BaseConnectionDescriptor connection)
        {
            var properties = connection.SyntaxProperties;

            if (properties == null)
            {
                return(null);
            }
            properties.PropertiesEditors.Clear();
            var propsContainer    = PropertiesFactory.GetPropertiesContainer(properties);
            var propertiesBar     = new PropertiesBar();
            var propertiesControl = (IPropertiesControl)propertiesBar;

            propertiesControl.SetProperties(propsContainer);
            return(propertiesBar);
        }
Exemplo n.º 4
0
        private IPlaceholderTag CreatePhTag(string tagContent, XmlNode item, int tagNo, bool source)
        {
            IPlaceholderTagProperties phTagProperties = PropertiesFactory.CreatePlaceholderTagProperties(tagContent);
            IPlaceholderTag           phTag           = ItemFactory.CreatePlaceholderTag(phTagProperties);

            phTagProperties.TagContent  = item.OuterXml;
            phTagProperties.DisplayText = string.Format("{{{0}}}", tagNo);
            phTagProperties.CanHide     = false;

            //determine tag id
            if (source)
            {
                var thisId =
                    new TagId(_totalTagCount.ToString(CultureInfo.InvariantCulture));

                phTagProperties.TagId = thisId;
                _totalTagCount       += 1;
                _tmpTotalTagCount    += 1;
                _srcSegmentTagCount  += 1;

                //check for source with the same Id and different properties
                if (CheckForIdAndPropertiesNotEqual(thisId, phTagProperties))
                {
                    _totalTagCount = CreatePlaceholderTagHelper(thisId, phTagProperties);
                }

                //check for source with the same Id and same properties
                if (!CheckForIdAndPropertiesEqual(thisId, phTagProperties))
                {
                    _dictionaryTags.Add(int.Parse(thisId.Id), phTagProperties);
                }
            }
            else
            {
                var thisId =
                    new TagId(_totalTagCount.ToString(CultureInfo.InvariantCulture));

                phTagProperties.TagId = thisId;

                if (CheckForIdAndPropertiesNotEqual(thisId, phTagProperties))
                {
                    _totalTagCount = CreatePlaceholderTagHelper(thisId, phTagProperties);
                }
            }

            return(phTag);
        }
Exemplo n.º 5
0
        private void RecreateSyntaxFrame()
        {
            pbSyntax.ClearProperties();
            var syntxProps = _connection.ConnectionDescriptor.SyntaxProperties;

            if (syntxProps == null)
            {
                pbSyntax.Visibility = Visibility.Collapsed;
                return;
            }

            pbSyntax.Visibility = Visibility.Visible;
            ClearProperties(syntxProps);
            var container = PropertiesFactory.GetPropertiesContainer(syntxProps);

            (pbSyntax as IPropertiesControl).SetProperties(container);
        }
        private UserControl CreateConnectionEditControl(BaseConnectionDescriptor connection)
        {
            _metadataProperties = connection.MetadataProperties;
            if (_metadataProperties != null)
            {
                _metadataProperties.PropertiesEditors.Clear();
                var propsContainer = PropertiesFactory.GetPropertiesContainer(_metadataProperties);
                var propertiesBar  = new PropertiesBar();
                propertiesBar.EditorsOptions.NarrowEditControlsMinWidth = 160;
                propertiesBar.EditorsOptions.MultiLineEditorsMaxWidth   = 570;
                var propertiesControl = (IPropertiesControl)propertiesBar;
                propertiesControl.SetProperties(propsContainer);
                return(propertiesBar);
            }

            return(null);
        }
        private void RecreateSyntaxFrame()
        {
            RemoveSyntaxFrame();
            var syntxProps = _connection.ConnectionDescriptor.SyntaxProperties;

            if (syntxProps == null)
            {
                pbSyntax.Height = 0;
                return;
            }

            ClearProperties(syntxProps);
            var container = PropertiesFactory.GetPropertiesContainer(syntxProps);

            (pbSyntax as IPropertiesControl).SetProperties(container);

            pbSyntax.Height = pbSyntax.Controls[0].Bottom + 5;
        }
        private ITagPair CreateTagPair(XmlNode item)
        {
            // create the start and the end tag
            IStartTagProperties startTag = PropertiesFactory.CreateStartTagProperties(item.Name);

            #region "formatting"
            // apply character formatting to the start tag
            IFormattingGroup formattingGroup = PropertiesFactory.FormattingItemFactory.CreateFormatting();
            startTag.Formatting = new FormattingGroup();
            switch (item.Name)
            {
            case "b":
                formattingGroup.Add(new Bold(true));
                break;

            case "i":
                formattingGroup.Add(new Italic(true));
                break;

            case "u":
                formattingGroup.Add(new Underline(true));
                break;

            default:
                break;
            }
            startTag.Formatting = formattingGroup;
            #endregion

            startTag.DisplayText = item.Name;
            startTag.CanHide     = true;
            IEndTagProperties endTag = PropertiesFactory.CreateEndTagProperties(item.Name);
            endTag.DisplayText = item.Name;
            endTag.CanHide     = true;

            // create a tag pair out of the start and the end tag
            ITagPair tagPair = ItemFactory.CreateTagPair(startTag, endTag);

            // add text enclosed in the tag pair
            tagPair.Add(CreateText(item.InnerText));

            return(tagPair);
        }
Exemplo n.º 9
0
        private void RecreateSyntaxFrame()
        {
            RemoveSyntaxFrame();
            var syntxProps = _connection.SyntaxProperties;

            if (syntxProps == null)
            {
                pbSyntax.Height = 0;
                return;
            }

            ClearProperties(syntxProps);
            var container = PropertiesFactory.GetPropertiesContainer(syntxProps);

            (pbSyntax as IPropertiesControl).SetProperties(container);

            cbLoadFromDefaultDatabase.Visible = _connection.SyntaxProvider.IsSupportDatabases();
            pbSyntax.Height = pbSyntax.Controls[0].Bottom + 5;
        }
Exemplo n.º 10
0
        public IAbstractMarkupData CreateTagPair(string tagId, string tagContent)
        {
            var tagName = GetStartTagName(tagContent, out var refId);

            // Dev Notes: the tagContent is switched with the Display text to align with how the tags are
            // recreated by the XLIFF 1.2 parser from the framework

            var startTagProperties = PropertiesFactory.CreateStartTagProperties("<bpt id=\"" + tagId + "\">");

            startTagProperties.DisplayText = tagContent;
            startTagProperties.SetMetaData("localName", "bpt");
            startTagProperties.SetMetaData("displayText", tagContent);
            startTagProperties.SetMetaData("attribute:id", tagId);

            if (ExistingTagIds.Contains(startTagProperties.TagId.Id))
            {
                startTagProperties.TagId = !ExistingTagIds.Contains(tagId)
                                        ? new TagId(tagId)
                                        : new TagId(GetUniqueTagPairId());
            }

            if (!ExistingTagIds.Contains(startTagProperties.TagId.Id))
            {
                ExistingTagIds.Add(startTagProperties.TagId.Id);
            }

            var endTagProperties = PropertiesFactory.CreateEndTagProperties("<ept id=\"" + tagId + "\">");

            endTagProperties.DisplayText = "</" + tagName + ">";
            endTagProperties.SetMetaData("localName", "ept");
            endTagProperties.SetMetaData("displayText", "</" + tagName + ">");
            endTagProperties.SetMetaData("attribute:id", tagId);


            //TODO formatting example
            //var xItem = _formattingFactory.CreateFormattingItem("italic", "True");
            //x.Formatting = _formattingFactory.CreateFormatting();
            //x.Formatting.Add(xItem);

            var tagPair = ItemFactory.CreateTagPair(startTagProperties, endTagProperties);

            return(tagPair);
        }
Exemplo n.º 11
0
        private IContextProperties CreateContext(string unitId)
        {
            IContextProperties contextProperties = PropertiesFactory.CreateContextProperties();
            IContextInfo       contextInfo       = PropertiesFactory.CreateContextInfo(StandardContextTypes.Paragraph);

            contextInfo.Purpose = ContextPurpose.Information;

            // add unit id as metadata
            IContextInfo contextId = PropertiesFactory.CreateContextInfo("UnitId");

            contextId.SetMetaData("UnitID", unitId);
            contextId.Description = "Original paragraph unit id";
            contextId.DisplayCode = "ID";

            contextProperties.Contexts.Add(contextInfo);
            contextProperties.Contexts.Add(contextId);

            return(contextProperties);
        }
Exemplo n.º 12
0
        private ICommentProperties CreateComment(XmlNode item)
        {
            ICommentProperties commentProperties = PropertiesFactory.CreateCommentProperties();

            var xmlNodeList = item.SelectNodes("comment");

            if (xmlNodeList != null)
            {
                foreach (XmlNode commentNode in xmlNodeList)
                {
                    var commentSeverity = Severity.Undefined;

                    var selectSingleNode = commentNode.SelectSingleNode("./@type");
                    if (selectSingleNode != null)
                    {
                        if (selectSingleNode.InnerText == "text")
                        {
                            commentSeverity = Severity.Low;
                        }
                        if (selectSingleNode.InnerText == "question")
                        {
                            commentSeverity = Severity.Medium;
                        }
                        if (selectSingleNode.InnerText == "important")
                        {
                            commentSeverity = Severity.High;
                        }
                    }

                    var singleNode = commentNode.SelectSingleNode("./@creationid");
                    if (singleNode != null)
                    {
                        IComment comment = PropertiesFactory.CreateComment(commentNode.InnerText,
                                                                           singleNode.InnerText, commentSeverity);
                        commentProperties.Add(comment);
                    }
                }
            }

            return(commentProperties);
        }
Exemplo n.º 13
0
        private IContextProperties CreateContext(string id, string paraId)
        {
            IContextProperties contextProperties = PropertiesFactory.CreateContextProperties();

            IContextInfo contextId = PropertiesFactory.CreateContextInfo("id");

            contextId.SetMetaData("ID", id);
            contextId.Description = "Trans-unit id";
            contextId.DisplayCode = "ID";

            IContextInfo contextParaId = PropertiesFactory.CreateContextInfo("para-id");

            contextParaId.SetMetaData("PARA ID", paraId);
            contextParaId.Description = "Para-id";
            contextParaId.DisplayCode = "PARA ID";

            contextProperties.Contexts.Add(contextId);
            contextProperties.Contexts.Add(contextParaId);

            return(contextProperties);
        }
Exemplo n.º 14
0
        public ITagPair CreateTagPair(string tagId, string tagContent, ref List <string> existingTagIds)
        {
            var tagName            = GetStartTagName(tagContent, out var refId);
            var startTagProperties = PropertiesFactory.CreateStartTagProperties("<" + tagName + " id=\"" + tagId + "\">");

            startTagProperties.DisplayText = tagContent;
            startTagProperties.SetMetaData("localName", tagName);
            startTagProperties.SetMetaData("displayText", tagContent);
            startTagProperties.SetMetaData("attribute:id", tagId);

            if (existingTagIds.Contains(startTagProperties.TagId.Id))
            {
                startTagProperties.TagId = !existingTagIds.Contains(tagId)
                                        ? new TagId(tagId)
                                        : new TagId(GetUniqueTagPairId(existingTagIds));
            }

            if (!existingTagIds.Contains(startTagProperties.TagId.Id))
            {
                existingTagIds.Add(startTagProperties.TagId.Id);
            }

            var endTagProperties = PropertiesFactory.CreateEndTagProperties("</" + tagName + ">");

            endTagProperties.DisplayText = "</" + tagName + ">";
            endTagProperties.SetMetaData("localName", tagName);
            endTagProperties.SetMetaData("displayText", "</" + tagName + ">");
            endTagProperties.SetMetaData("attribute:id", tagId);


            //TODO formatting example
            //var xItem = _formattingFactory.CreateFormattingItem("italic", "True");
            //x.Formatting = _formattingFactory.CreateFormatting();
            //x.Formatting.Add(xItem);

            var tagPair = ItemFactory.CreateTagPair(startTagProperties, endTagProperties);


            return(tagPair);
        }
        private IContextProperties CreateContext(string spec, string unitID)
        {
            // context info for type information, e.g. heading, paragraph, etc.
            IContextProperties contextProperties = PropertiesFactory.CreateContextProperties();
            IContextInfo       contextInfo       = PropertiesFactory.CreateContextInfo(StandardContextTypes.Paragraph);

            contextInfo.Purpose = ContextPurpose.Information;

            // add unit id as metadata
            IContextInfo contextId = PropertiesFactory.CreateContextInfo("UnitId");

            contextId.SetMetaData("UnitID", unitID);

            switch (spec)
            {
            case "Heading":
                contextInfo = PropertiesFactory.CreateContextInfo(StandardContextTypes.Topic);
                contextInfo.DisplayColor = Color.Green;
                break;

            case "Box":
                contextInfo = PropertiesFactory.CreateContextInfo(StandardContextTypes.TextBox);
                contextInfo.DisplayColor = Color.Gold;
                break;

            case "Paragraph":
                contextInfo = PropertiesFactory.CreateContextInfo(StandardContextTypes.Paragraph);
                contextInfo.DisplayColor = Color.Silver;
                break;

            default:
                break;
            }

            contextProperties.Contexts.Add(contextInfo);
            contextProperties.Contexts.Add(contextId);

            return(contextProperties);
        }
Exemplo n.º 16
0
        private IPlaceholderTag CreatePhTag(string tagContent, XmlNode item, int tagNo)
        {
            IPlaceholderTagProperties phTagProperties = PropertiesFactory.CreatePlaceholderTagProperties(tagContent);
            IPlaceholderTag           phTag           = ItemFactory.CreatePlaceholderTag(phTagProperties);

            string cont;

            if (item.NextSibling == null)
            {
                cont = "";
            }
            else
            {
                cont = item.NextSibling.Value;
            }

            phTagProperties.TagContent  = item.OuterXml;
            phTagProperties.DisplayText = item.Name;
            phTagProperties.CanHide     = false;

            return(phTag);
        }
Exemplo n.º 17
0
        private IPlaceholderTag CreatePhTag(string tagContent, XmlNode item, bool source)
        {
            var phTagProperties = PropertiesFactory.CreatePlaceholderTagProperties(tagContent);
            var phTag           = ItemFactory.CreatePlaceholderTag(phTagProperties);

            var cont = item.NextSibling != null ? item.NextSibling.Value : string.Empty;

            phTagProperties.SegmentationHint = SegmentationHint.IncludeWithText;
            phTagProperties.TagContent       = item.OuterXml;
            phTagProperties.DisplayText      = item.Name;
            phTagProperties.CanHide          = false;

            //determine tag id
            if (source)
            {
                _totalTagCount      += 1;
                _tmpTotalTagCount   += 1;
                _srcSegmentTagCount += 1;
            }

            return(phTag);
        }
Exemplo n.º 18
0
        public override void ProcessParagraphUnit(IParagraphUnit paragraphUnit)
        {
            // ignore structure segment
            if (!paragraphUnit.IsStructure)
            {
                foreach (var segmentPair in paragraphUnit.SegmentPairs)
                {
                    if (IsTargetEmpty(segmentPair))
                    {
                        // copy source
                        if (Settings.CopyTargetContent.Value)
                        {
                            Implementation.SourceToTargetCopy.Copy(segmentPair, ItemFactory);
                        }
                        else // generate random text
                        {
                            Implementation.RandomTargetGenerator.Generate(segmentPair, ItemFactory);
                        }
                        SetConformationLevel(segmentPair);
                    }

                    if (!string.IsNullOrEmpty(Settings.AppendStart.Value))
                    {
                        segmentPair.Target.Insert(0,
                                                  ItemFactory.CreateText(
                                                      PropertiesFactory.CreateTextProperties(Settings.AppendStart.Value)));
                    }

                    if (!string.IsNullOrEmpty(Settings.AppendEnd.Value))
                    {
                        segmentPair.Target.Insert(segmentPair.Target.Count,
                                                  ItemFactory.CreateText(
                                                      PropertiesFactory.CreateTextProperties(Settings.AppendEnd.Value)));
                    }
                }
            }
            base.ProcessParagraphUnit(paragraphUnit);
        }
        private void RegisterPropertyPage(Control link, ObjectProperties propertiesObject)
        {
            var propertiesContainer = PropertiesFactory.GetPropertiesContainer(propertiesObject);

            // create property page control
            var propertyPage = new PropertiesBar
            {
                EditorsOptions =
                {
                    WideEditControlsMaxWidth = 225,
                    WideEditControlsMinWidth = 100,
                    ShowDescriptions         = true
                }
            };

            // set properties to property page
            var propertiesControl = (IPropertiesControl)propertyPage;

            propertiesControl.SetProperties(propertiesContainer);

            // register link -> propertyPage mapping
            _linkToPage1.Add(link, propertyPage);
        }
        // this function outputs an opening or a closing <b> tag
        // and applies bold character formatting to the strings
        // that the tags enclose
        private void WriteInlineTag(string tagContent, bool isStart)
        {
            _fBold = new FormattingGroup();
            _fBold.Add(new Bold(true));

            if (isStart)
            {
                IStartTagProperties startTag = PropertiesFactory.CreateStartTagProperties(tagContent);
                startTag.DisplayText = "b";
                startTag.TagContent  = tagContent;
                startTag.Formatting  = _fBold;
                startTag.CanHide     = true;
                Output.InlineStartTag(startTag);
            }
            else
            {
                IEndTagProperties endTag = PropertiesFactory.CreateEndTagProperties(tagContent);
                endTag.DisplayText = "b";
                endTag.TagContent  = tagContent;
                endTag.CanHide     = true;
                Output.InlineEndTag(endTag);
            }
        }
Exemplo n.º 21
0
        private IPlaceholderTag CreatePhTag(string tagContent, XmlNode item, bool source)
        {
            IPlaceholderTagProperties phTagProperties = PropertiesFactory.CreatePlaceholderTagProperties(tagContent);
            IPlaceholderTag           phTag           = ItemFactory.CreatePlaceholderTag(phTagProperties);

            string cont;

            if (item.NextSibling == null)
            {
                cont = "";
            }
            else
            {
                cont = item.NextSibling.Value;
            }

            phTagProperties.SegmentationHint = SegmentationHint.IncludeWithText;
            phTagProperties.TagContent       = item.OuterXml;
            phTagProperties.DisplayText      = item.Name;
            phTagProperties.CanHide          = false;


            //determine tag id
            if (source)
            {
                /*Sdl.FileTypeSupport.Framework.NativeApi.TagId thisId =
                 *  new Sdl.FileTypeSupport.Framework.NativeApi.TagId(totalTagCount.ToString());
                 *
                 * phTagProperties.TagId = thisId;*/
                totalTagCount      += 1;
                tmpTotalTagCount   += 1;
                srcSegmentTagCount += 1;
            }

            return(phTag);
        }
        private FrameworkElement CreateConnectionEditControl(BaseConnectionDescriptor connection)
        {
            _metadataProperties = connection.MetadataProperties;

            if (_metadataProperties == null)
            {
                return(null);
            }

            _metadataProperties.PropertiesEditors.Clear();
            var propsContainer = PropertiesFactory.GetPropertiesContainer(_metadataProperties);
            var propertiesBar  = new PropertiesBar
            {
                EditorsOptions =
                {
                    NarrowEditControlsMinWidth = 160,
                    MultiLineEditorsMaxWidth   = 570
                }
            };
            var propertiesControl = (IPropertiesControl)propertiesBar;

            propertiesControl.SetProperties(propsContainer);
            return(propertiesBar);
        }
        // output translatable text
        private void WriteText(string TextContent)
        {
            ITextProperties textProperties = PropertiesFactory.CreateTextProperties(TextContent);

            Output.Text(textProperties);
        }
Exemplo n.º 24
0
        public IAbstractMarkupData Text(string text)
        {
            var textProperties = PropertiesFactory.CreateTextProperties(text);

            return(ItemFactory.CreateText(textProperties));
        }
Exemplo n.º 25
0
        private ICommentProperties CreateComment(XmlNode item)
        {
            ICommentProperties commentProperties = PropertiesFactory.CreateCommentProperties();

            return(commentProperties);
        }
Exemplo n.º 26
0
        public ISegment GetUpdatedSegment(ISegment targetSegment, IEnumerable <Token> tokens, ISegment sourceSegment)
        {
            var vector          = new List <int>();
            var lockedContentId = 0;

            //store original segment
            var originalSegment = (ISegment)targetSegment.Clone();

            //remove old content
            targetSegment.Clear();

            foreach (var item in tokens)
            {
                switch (item.Type)
                {
                case Token.TokenType.TagOpen:
                    var tagPairOpen = (IAbstractMarkupDataContainer)GetElement(
                        GetTagID(item.Content), originalSegment, sourceSegment, item.Type);
                    tagPairOpen.Clear();
                    InsertItemOnLocation(vector, ref targetSegment,
                                         (IAbstractMarkupData)tagPairOpen);
                    vector.Add(((ITagPair)tagPairOpen).IndexInParent);
                    break;

                case Token.TokenType.TagClose:
                    vector.RemoveAt(vector.Count - 1);
                    break;

                case Token.TokenType.TagPlaceholder:
                    InsertItemOnLocation(vector, ref targetSegment,
                                         GetElement(GetTagID(item.Content), originalSegment, sourceSegment,
                                                    item.Type));
                    break;

                case Token.TokenType.Text:
                    InsertItemOnLocation(vector, ref targetSegment, ItemFactory.CreateText(
                                             PropertiesFactory.CreateTextProperties(item.Content)));
                    break;

                case Token.TokenType.LockedContent:
                    InsertItemOnLocation(vector, ref targetSegment,
                                         GetElement(lockedContentId.ToString(), originalSegment, sourceSegment,
                                                    item.Type));
                    lockedContentId++;
                    break;

                case Token.TokenType.CommentStart:
                    var commentContainer = GetComment(item);
                    InsertItemOnLocation(vector, ref targetSegment,
                                         (IAbstractMarkupData)commentContainer);
                    vector.Add(((ICommentMarker)commentContainer).IndexInParent);
                    break;

                case Token.TokenType.CommentEnd:
                    if (vector.Count > 0)
                    {
                        vector.RemoveAt(vector.Count - 1);
                    }

                    break;

                case Token.TokenType.RevisionMarker:
                    //hasTrackedChanges = true;
                    if (item.RevisionType == Token.RevisionMarkerType.InsertStart)
                    {
                        var insertContainer = GetRevisionMarker(item, RevisionType.Insert);
                        InsertItemOnLocation(vector, ref targetSegment,
                                             (IAbstractMarkupData)insertContainer);
                        vector.Add(((IRevisionMarker)insertContainer).IndexInParent);
                    }
                    else if (item.RevisionType == Token.RevisionMarkerType.DeleteStart)
                    {
                        var insertContainer = GetRevisionMarker(item, RevisionType.Delete);
                        InsertItemOnLocation(vector, ref targetSegment,
                                             (IAbstractMarkupData)insertContainer);
                        vector.Add(((IRevisionMarker)insertContainer).IndexInParent);
                    }
                    else
                    {
                        if (vector.Count > 0)
                        {
                            vector.RemoveAt(vector.Count - 1);
                        }
                    }

                    break;
                }
            }

            return(targetSegment);
        }
        private int PerformReplaceIterator(Location textLocation, int textIndexStart, int textLength, ref int textIndex)
        {
            bool isWarning = false;

            _lockedCharactersCount = 0;
            TextCharacterCountingIterator iterator = new TextCharacterCountingIterator(textLocation);

            do
            {
                // if (iterator.CharacterCount + iterator.CharactersToNextLocation > textIndexStart)
                if (iterator.CharacterCount + iterator.CharactersToNextLocation + _charactersShift > textIndexStart)
                {
                    // text with tags - do not replace, report warning
                    //if (iterator.CharacterCount + iterator.CharactersToNextLocation < textIndexStart + textLength)
                    if (iterator.CharacterCount + iterator.CharactersToNextLocation + _charactersShift < textIndexStart + textLength)
                    {
                        //textIndex = (iterator.CharacterCount + iterator.CharactersToNextLocation) - (textIndexStart + textLength);
                        textIndex = (iterator.CharacterCount + iterator.CharactersToNextLocation + _charactersShift) - (textIndexStart + textLength);
                        isWarning = true;
                    }

                    #region IText
                    IText text = iterator.CurrentLocation.ItemAtLocation as IText;
                    if (text != null && !isWarning)
                    {
                        // real index in IText
                        textIndex = textIndexStart - (iterator.CharacterCount + _charactersShift);

                        // replace the text of IText
                        string replacedText = TextReplace(text.Properties.Text, textIndex, textLength);
                        iterator.CurrentLocation.ItemAtLocation.Parent[iterator.CurrentLocation.ItemAtLocation.IndexInParent] =
                            ItemFactory.CreateText(PropertiesFactory.CreateTextProperties(replacedText));
                        return(0);
                    }
                    #endregion

                    #region Tags
                    if (isWarning)
                    {
                        IPlaceholderTag phTag   = iterator.CurrentLocation.ItemAtLocation as IPlaceholderTag;
                        ITagPair        tagPair = iterator.CurrentLocation.ItemAtLocation as ITagPair;
                        if (phTag != null || tagPair != null)
                        {
                            return(-1);
                        }
                        tagPair = iterator.CurrentLocation.BottomLevel.Parent as ITagPair;
                        if (iterator.CurrentLocation.BottomLevel.IsAtEndOfParent && tagPair != null)
                        {
                            return(-1);
                        }
                    }
                    #endregion

                    #region Comment
                    if (isWarning)
                    {
                        ICommentMarker comment = iterator.CurrentLocation.ItemAtLocation as ICommentMarker;
                        if (comment != null)
                        {
                            return(-3);
                        }
                        comment = iterator.CurrentLocation.BottomLevel.Parent as ICommentMarker;
                        if (iterator.CurrentLocation.BottomLevel.IsAtEndOfParent && comment != null)
                        {
                            return(-3);
                        }
                    }
                    #endregion
                }

                #region LockedContent
                ILockedContent content = iterator.CurrentLocation.ItemAtLocation as ILockedContent;
                if (content != null)
                {
                    if (isWarning)
                    {
                        return(-2);
                    }
                    // real index in ILockedContent
                    textIndex = textIndexStart - (iterator.CharacterCount + _charactersShift);

                    // call the iterator for Locked Content
                    Location lockedLocation = new Location((IAbstractMarkupDataContainer)content.Content, true);
                    int      sts            = PerformReplaceIterator(lockedLocation, textIndex, textLength, ref textIndex);

                    // CODE TO FIX TextCharacterCountingIterator BUG !!! >>
                    // if TextCharacterCountingIterator failed to get CharactersToNextLocation,
                    // we calculate it manually and save as _charactersShift
                    if (iterator.CharactersToNextLocation == 0)
                    {
                        _charactersShift += _lockedCharactersCount;
                    }
                    if (sts != -4)
                    {
                        return(sts);
                    }
                }
                content = iterator.CurrentLocation.BottomLevel.Parent as ILockedContent;
                if (iterator.CurrentLocation.BottomLevel.IsAtEndOfParent && content != null)
                {
                    if (isWarning)
                    {
                        return(-1);
                    }
                }
                #endregion
            } while (iterator.MoveNext());

            _lockedCharactersCount = iterator.CharacterCount;

            return(-4);
        }