/**
         * Splits this <CODE>PdfChunk</CODE> if it's too long for the given width.
         * <P>
         * Returns <VAR>null</VAR> if the <CODE>PdfChunk</CODE> wasn't truncated.
         *
         * @param       width       a given width
         * @return      the <CODE>PdfChunk</CODE> that doesn't fit into the width.
         */

        internal PdfChunk Split(float width)
        {
            newlineSplit = false;
            if (image != null)
            {
                if (image.ScaledWidth > width)
                {
                    PdfChunk pc = new PdfChunk(Chunk.OBJECT_REPLACEMENT_CHARACTER, this);
                    value      = "";
                    attributes = new Dictionary <string, object>();
                    image      = null;
                    font       = PdfFont.DefaultFont;
                    return(pc);
                }
                else
                {
                    return(null);
                }
            }
            IHyphenationEvent hyphenationEvent = null;

            if (noStroke.ContainsKey(Chunk.HYPHENATION))
            {
                hyphenationEvent = (IHyphenationEvent)noStroke[Chunk.HYPHENATION];
            }
            int   currentPosition = 0;
            int   splitPosition   = -1;
            float currentWidth    = 0;

            // loop over all the characters of a string
            // or until the totalWidth is reached
            int   lastSpace      = -1;
            float lastSpaceWidth = 0;
            int   length         = value.Length;

            char[]   valueArray = value.ToCharArray();
            char     character  = (char)0;
            BaseFont ft         = font.Font;
            bool     surrogate  = false;

            if (ft.FontType == BaseFont.FONT_TYPE_CJK && ft.GetUnicodeEquivalent(' ') != ' ')
            {
                while (currentPosition < length)
                {
                    // the width of every character is added to the currentWidth
                    char cidChar = valueArray[currentPosition];
                    character = (char)ft.GetUnicodeEquivalent(cidChar);
                    // if a newLine or carriageReturn is encountered
                    if (character == '\n')
                    {
                        newlineSplit = true;
                        string returnValue = value.Substring(currentPosition + 1);
                        value = value.Substring(0, currentPosition);
                        if (value.Length < 1)
                        {
                            value = "\u0001";
                        }
                        PdfChunk pc = new PdfChunk(returnValue, this);
                        return(pc);
                    }
                    currentWidth += GetCharWidth(cidChar);
                    if (character == ' ')
                    {
                        lastSpace      = currentPosition + 1;
                        lastSpaceWidth = currentWidth;
                    }
                    if (currentWidth > width)
                    {
                        break;
                    }
                    // if a split-character is encountered, the splitPosition is altered
                    if (splitCharacter.IsSplitCharacter(0, currentPosition, length, valueArray, new PdfChunk[] { this }))
                    {
                        splitPosition = currentPosition + 1;
                    }
                    currentPosition++;
                }
            }
            else
            {
                while (currentPosition < length)
                {
                    // the width of every character is added to the currentWidth
                    character = valueArray[currentPosition];
                    // if a newLine or carriageReturn is encountered
                    if (character == '\r' || character == '\n')
                    {
                        newlineSplit = true;
                        int inc = 1;
                        if (character == '\r' && currentPosition + 1 < length && valueArray[currentPosition + 1] == '\n')
                        {
                            inc = 2;
                        }
                        string returnValue = value.Substring(currentPosition + inc);
                        value = value.Substring(0, currentPosition);
                        if (value.Length < 1)
                        {
                            value = " ";
                        }
                        PdfChunk pc = new PdfChunk(returnValue, this);
                        return(pc);
                    }
                    surrogate = Utilities.IsSurrogatePair(valueArray, currentPosition);
                    if (surrogate)
                    {
                        currentWidth += GetCharWidth(Utilities.ConvertToUtf32(valueArray[currentPosition], valueArray[currentPosition + 1]));
                    }
                    else
                    {
                        currentWidth += GetCharWidth(character);
                    }
                    if (character == ' ')
                    {
                        lastSpace      = currentPosition + 1;
                        lastSpaceWidth = currentWidth;
                    }
                    if (surrogate)
                    {
                        currentPosition++;
                    }
                    if (currentWidth > width)
                    {
                        break;
                    }
                    // if a split-character is encountered, the splitPosition is altered
                    if (splitCharacter.IsSplitCharacter(0, currentPosition, length, valueArray, null))
                    {
                        splitPosition = currentPosition + 1;
                    }
                    currentPosition++;
                }
            }

            // if all the characters fit in the total width, null is returned (there is no overflow)
            if (currentPosition == length)
            {
                return(null);
            }
            // otherwise, the string has to be truncated
            if (splitPosition < 0)
            {
                string returnValue = value;
                value = "";
                PdfChunk pc = new PdfChunk(returnValue, this);
                return(pc);
            }
            if (lastSpace > splitPosition && splitCharacter.IsSplitCharacter(0, 0, 1, singleSpace, null))
            {
                splitPosition = lastSpace;
            }
            if (hyphenationEvent != null && lastSpace >= 0 && lastSpace < currentPosition)
            {
                int wordIdx = GetWord(value, lastSpace);
                if (wordIdx > lastSpace)
                {
                    string pre  = hyphenationEvent.GetHyphenatedWordPre(value.Substring(lastSpace, wordIdx - lastSpace), font.Font, font.Size, width - lastSpaceWidth);
                    string post = hyphenationEvent.HyphenatedWordPost;
                    if (pre.Length > 0)
                    {
                        string returnValue = post + value.Substring(wordIdx);
                        value = Trim(value.Substring(0, lastSpace) + pre);
                        PdfChunk pc = new PdfChunk(returnValue, this);
                        return(pc);
                    }
                }
            }
            string retVal = value.Substring(splitPosition);

            value = Trim(value.Substring(0, splitPosition));
            PdfChunk tmp = new PdfChunk(retVal, this);

            return(tmp);
        }
 internal bool IsExtSplitCharacter(int start, int current, int end, char[] cc, PdfChunk[] ck)
 {
     return(SplitCharacter.IsSplitCharacter(start, current, end, cc, ck));
 }