C# pdf.PdfChunk类代码示例

 /**
  * Returns the current character
  * @param current current position in the array
  * @param	cc		the character array that has to be checked
  * @param ck chunk array
  * @return	the current character
  */
 protected char GetCurrentCharacter(int current, char[] cc, PdfChunk[] ck)
 {
     if (ck == null)
     {
         return (char)cc[current];
     }
     return (char)ck[Math.Min(current, ck.Length - 1)].GetUnicodeEquivalent(cc[current]);
 }

// ===========================================================================
    /**
     * @see com.itextpdf.text.SplitCharacter#isSplitCharacter(int, int, int, char[],
     *      com.itextpdf.text.pdf.PdfChunk[])
     */
    public bool IsSplitCharacter(
      int start, int current, int end, char[] cc, PdfChunk[] ck) 
    {
      char c = ck == null
        ? cc[current]
        : (char) ck[Math.Min(current, ck.Length - 1)]
            .GetUnicodeEquivalent(cc[current])
      ;
      return (c == '|' || c <= ' ' || c == '-');
    }

 /**
  * Checks if a character can be used to split a <CODE>PdfString</CODE>.
  * <P>
  * for the moment every character less than or equal to SPACE, the character '-'
  * and some specific unicode ranges are 'splitCharacters'.
  * 
  * @param start start position in the array
  * @param current current position in the array
  * @param end end position in the array
  * @param	cc		the character array that has to be checked
  * @param ck chunk array
  * @return	<CODE>true</CODE> if the character can be used to split a string, <CODE>false</CODE> otherwise
  */
 public bool IsSplitCharacter(int start, int current, int end, char[] cc, PdfChunk[] ck) {
     char c = GetCurrentCharacter(current, cc, ck);
     if (c <= ' ' || c == '-' || c == '\u2010') {
         return true;
     }
     if (c < 0x2002)
         return false;
     return ((c >= 0x2002 && c <= 0x200b)
         || (c >= 0x2e80 && c < 0xd7a0)
         || (c >= 0xf900 && c < 0xfb00)
         || (c >= 0xfe30 && c < 0xfe50)
         || (c >= 0xff61 && c < 0xffa0));
 }

        /**
        * Signals that an <CODE>Element</CODE> was added to the <CODE>Document</CODE>.
        *
        * @param element the element to add
        * @return <CODE>true</CODE> if the element was added, <CODE>false</CODE> if not.
        * @throws DocumentException when a document isn't open yet, or has been closed
        */
        public override bool Add(IElement element)
        {
            if (writer != null && writer.IsPaused()) {
                return false;
            }
            switch (element.Type) {

                // Information (headers)
                case Element.HEADER:
                    info.Addkey(((Meta)element).Name, ((Meta)element).Content);
                    break;
                case Element.TITLE:
                    info.AddTitle(((Meta)element).Content);
                    break;
                case Element.SUBJECT:
                    info.AddSubject(((Meta)element).Content);
                    break;
                case Element.KEYWORDS:
                    info.AddKeywords(((Meta)element).Content);
                    break;
                case Element.AUTHOR:
                    info.AddAuthor(((Meta)element).Content);
                    break;
                case Element.CREATOR:
                    info.AddCreator(((Meta)element).Content);
                    break;
                case Element.PRODUCER:
                    // you can not change the name of the producer
                    info.AddProducer();
                    break;
                case Element.CREATIONDATE:
                    // you can not set the creation date, only reset it
                    info.AddCreationDate();
                    break;

                    // content (text)
                case Element.CHUNK: {
                    // if there isn't a current line available, we make one
                    if (line == null) {
                        CarriageReturn();
                    }

                    // we cast the element to a chunk
                    PdfChunk chunk = new PdfChunk((Chunk) element, anchorAction);
                    // we try to add the chunk to the line, until we succeed
                    {
                        PdfChunk overflow;
                        while ((overflow = line.Add(chunk)) != null) {
                            CarriageReturn();
                            chunk = overflow;
                            chunk.TrimFirstSpace();
                        }
                    }
                    pageEmpty = false;
                    if (chunk.IsAttribute(Chunk.NEWPAGE)) {
                        NewPage();
                    }
                    break;
                }
                case Element.ANCHOR: {
                    Anchor anchor = (Anchor) element;
                    String url = anchor.Reference;
                    leading = anchor.Leading;
                    if (url != null) {
                        anchorAction = new PdfAction(url);
                    }

                    // we process the element
                    element.Process(this);
                    anchorAction = null;
                    break;
                }
                case Element.ANNOTATION: {
                    if (line == null) {
                        CarriageReturn();
                    }
                    Annotation annot = (Annotation) element;
                    Rectangle rect = new Rectangle(0, 0);
                    if (line != null)
                        rect = new Rectangle(annot.GetLlx(IndentRight - line.WidthLeft), annot.GetLly(IndentTop - currentHeight), annot.GetUrx(IndentRight - line.WidthLeft + 20), annot.GetUry(IndentTop - currentHeight - 20));
                    PdfAnnotation an = PdfAnnotationsImp.ConvertAnnotation(writer, annot, rect);
                    annotationsImp.AddPlainAnnotation(an);
                    pageEmpty = false;
                    break;
                }
                case Element.PHRASE: {
                    // we cast the element to a phrase and set the leading of the document
                    leading = ((Phrase) element).Leading;
                    // we process the element
                    element.Process(this);
                    break;
                }
                case Element.PARAGRAPH: {
//.........这里部分代码省略.........

     /**
      * Truncates 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 Truncate(float width) {
         if (image != null) {
             if (image.ScaledWidth > width) {
                 PdfChunk pc = new PdfChunk("", this);
                 value = "";
                 attributes.Remove(Chunk.IMAGE);
                 image = null;
                 font = PdfFont.DefaultFont;
                 return pc;
             }
             else
                 return null;
         }
     
         int currentPosition = 0;
         float currentWidth = 0;
     
         // it's no use trying to split if there isn't even enough place for a space
         if (width < font.Width()) {
             string returnValue = value.Substring(1);
             value = value.Substring(0, 1);
             PdfChunk pc = new PdfChunk(returnValue, this);
             return pc;
         }
     
         // loop over all the characters of a string
         // or until the totalWidth is reached
         int length = value.Length;
         bool surrogate = false;
         while (currentPosition < length) {
             // the width of every character is added to the currentWidth
             surrogate = Utilities.IsSurrogatePair(value, currentPosition);
             if (surrogate)
                 currentWidth += GetCharWidth(Utilities.ConvertToUtf32(value, currentPosition));
             else
                 currentWidth += GetCharWidth(value[currentPosition]);
             if (currentWidth > width)
                 break;
             if (surrogate)
                 currentPosition++;
             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
         //currentPosition -= 2;
         // we have to chop off minimum 1 character from the chunk
         if (currentPosition == 0) {
             currentPosition = 1;
             if (surrogate)
                 ++currentPosition;
         }
         string retVal = value.Substring(currentPosition);
         value = value.Substring(0, currentPosition);
         PdfChunk tmp = new PdfChunk(retVal, this);
         return tmp;
     }

     // constructors
 
     /**
      * Constructs a <CODE>PdfChunk</CODE>-object.
      *
      * @param string the content of the <CODE>PdfChunk</CODE>-object
      * @param font the <CODE>PdfFont</CODE>
      * @param attributes the metrics attributes
      * @param noStroke the non metric attributes
      */
 
     internal PdfChunk(string str, PdfChunk other) {
         thisChunk[0] = this;
         value = str;
         this.font = other.font;
         this.attributes = other.attributes;
         this.noStroke = other.noStroke;
         this.baseFont = other.baseFont;
         Object[] obj = null;
         if (attributes.ContainsKey(Chunk.IMAGE))
             obj = (Object[])attributes[Chunk.IMAGE];
         if (obj == null)
             image = null;
         else {
             image = (Image)obj[0];
             offsetX = (float)obj[1];
             offsetY = (float)obj[2];
             changeLeading = (bool)obj[3];
         }
         encoding = font.Font.Encoding;
         if (noStroke.ContainsKey(Chunk.SPLITCHARACTER))
             splitCharacter = (ISplitCharacter)noStroke[Chunk.SPLITCHARACTER];
         else
             splitCharacter = DefaultSplitCharacter.DEFAULT;
     }

        /**
        * Signals that an <CODE>Element</CODE> was added to the <CODE>Document</CODE>.
        *
        * @param element the element to add
        * @return <CODE>true</CODE> if the element was added, <CODE>false</CODE> if not.
        * @throws DocumentException when a document isn't open yet, or has been closed
        */
        public override bool Add(IElement element) {
            if (writer != null && writer.IsPaused()) {
                return false;
            }
            if (element.Type != Element.DIV) {
                FlushFloatingElements();
            }
            switch (element.Type) {
                
                // Information (headers)
                case Element.HEADER:
                    info.Addkey(((Meta)element).Name, ((Meta)element).Content);
                    break;
                case Element.TITLE:
                    info.AddTitle(((Meta)element).Content);
                    break;
                case Element.SUBJECT:
                    info.AddSubject(((Meta)element).Content);
                    break;
                case Element.KEYWORDS:
                    info.AddKeywords(((Meta)element).Content);
                    break;
                case Element.AUTHOR:
                    info.AddAuthor(((Meta)element).Content);
                    break;
                case Element.CREATOR:
                    info.AddCreator(((Meta)element).Content);
                    break;
                case Element.LANGUAGE:
                    SetLanguage(((Meta)element).Content);
                    break;
                case Element.PRODUCER:
                    // you can not change the name of the producer
                    info.AddProducer();
                    break;
                case Element.CREATIONDATE:
                    // you can not set the creation date, only reset it
                    info.AddCreationDate();
                    break;
                    
                    // content (text)
                case Element.CHUNK: {
                    // if there isn't a current line available, we make one
                    if (line == null) {
                        CarriageReturn();
                    }
                    
                    // we cast the element to a chunk
                    PdfChunk chunk = new PdfChunk((Chunk) element, anchorAction, tabSettings);
                    // we try to add the chunk to the line, until we succeed
                    {
                        PdfChunk overflow;
                        while ((overflow = line.Add(chunk)) != null) {
                            CarriageReturn();
                            bool newlineSplit = chunk.IsNewlineSplit();
                            chunk = overflow;
                            if (!newlineSplit)
                                chunk.TrimFirstSpace();
                        }
                    }
                    pageEmpty = false;
                    if (chunk.IsAttribute(Chunk.NEWPAGE)) {
                        NewPage();
                    }
                    break;
                }
                case Element.ANCHOR: {
                    Anchor anchor = (Anchor) element;
                    String url = anchor.Reference;
                    leading = anchor.Leading;
                    PushLeading();
                    if (url != null) {
                        anchorAction = new PdfAction(url);
                    }
                    
                    // we process the element
                    element.Process(this);
                    anchorAction = null;
                    PopLeading();
                    break;
                }
                case Element.ANNOTATION: {
                    if (line == null) {
                        CarriageReturn();
                    }
                    Annotation annot = (Annotation) element;
                    Rectangle rect = new Rectangle(0, 0);
                    if (line != null)
                        rect = new Rectangle(annot.GetLlx(IndentRight - line.WidthLeft), annot.GetUry(IndentTop - currentHeight - 20), annot.GetUrx(IndentRight - line.WidthLeft + 20), annot.GetLly(IndentTop - currentHeight));
                    PdfAnnotation an = PdfAnnotationsImp.ConvertAnnotation(writer, annot, rect);
                    annotationsImp.AddPlainAnnotation(an);
                    pageEmpty = false;
                    break;
//.........这里部分代码省略.........

 public PdfLine ProcessLine(float leftX, float width, int alignment, int runDirection, int arabicOptions)
 {
     this.arabicOptions = arabicOptions;
     Save();
     bool isRTL = (runDirection == PdfWriter.RUN_DIRECTION_RTL);
     if (currentChar >= totalTextLength) {
         bool hasText = GetParagraph(runDirection);
         if (!hasText)
             return null;
         if (totalTextLength == 0) {
             ArrayList ar = new ArrayList();
             PdfChunk ckx = new PdfChunk("", detailChunks[0]);
             ar.Add(ckx);
             return new PdfLine(0, 0, 0, alignment, true, ar, isRTL);
         }
     }
     float originalWidth = width;
     int lastSplit = -1;
     if (currentChar != 0)
         currentChar = TrimLeftEx(currentChar, totalTextLength - 1);
     int oldCurrentChar = currentChar;
     int uniC = 0;
     PdfChunk ck = null;
     float charWidth = 0;
     PdfChunk lastValidChunk = null;
     bool splitChar = false;
     bool surrogate = false;
     for (; currentChar < totalTextLength; ++currentChar) {
         ck = detailChunks[currentChar];
         surrogate = Utilities.IsSurrogatePair(text, currentChar);
         if (surrogate)
             uniC = ck.GetUnicodeEquivalent(Utilities.ConvertToUtf32(text, currentChar));
         else
             uniC = ck.GetUnicodeEquivalent(text[currentChar]);
         if (PdfChunk.NoPrint(uniC))
             continue;
         if (surrogate)
             charWidth = ck.GetCharWidth(uniC);
         else
             charWidth = ck.GetCharWidth(text[currentChar]);
         splitChar = ck.IsExtSplitCharacter(oldCurrentChar, currentChar, totalTextLength, text, detailChunks);
         if (splitChar && Char.IsWhiteSpace((char)uniC))
             lastSplit = currentChar;
         if (width - charWidth < 0)
             break;
         if (splitChar)
             lastSplit = currentChar;
         width -= charWidth;
         lastValidChunk = ck;
         if (surrogate)
             ++currentChar;
         if (ck.IsTab()) {
             Object[] tab = (Object[])ck.GetAttribute(Chunk.TAB);
             float tabPosition = (float)tab[1];
             bool newLine = (bool)tab[2];
             if (newLine && tabPosition < originalWidth - width) {
                 return new PdfLine(0, originalWidth, width, alignment, true, CreateArrayOfPdfChunks(oldCurrentChar, currentChar - 1), isRTL);
             }
             detailChunks[currentChar].AdjustLeft(leftX);
             width = originalWidth - tabPosition;
         }
     }
     if (lastValidChunk == null) {
         // not even a single char fit; must output the first char
         ++currentChar;
         if (surrogate)
             ++currentChar;
         return new PdfLine(0, originalWidth, 0, alignment, false, CreateArrayOfPdfChunks(currentChar - 1, currentChar - 1), isRTL);
     }
     if (currentChar >= totalTextLength) {
         // there was more line than text
         return new PdfLine(0, originalWidth, width, alignment, true, CreateArrayOfPdfChunks(oldCurrentChar, totalTextLength - 1), isRTL);
     }
     int newCurrentChar = TrimRightEx(oldCurrentChar, currentChar - 1);
     if (newCurrentChar < oldCurrentChar) {
         // only WS
         return new PdfLine(0, originalWidth, width, alignment, false, CreateArrayOfPdfChunks(oldCurrentChar, currentChar - 1), isRTL);
     }
     if (newCurrentChar == currentChar - 1) { // middle of word
         IHyphenationEvent he = (IHyphenationEvent)lastValidChunk.GetAttribute(Chunk.HYPHENATION);
         if (he != null) {
             int[] word = GetWord(oldCurrentChar, newCurrentChar);
             if (word != null) {
                 float testWidth = width + GetWidth(word[0], currentChar - 1);
                 String pre = he.GetHyphenatedWordPre(new String(text, word[0], word[1] - word[0]), lastValidChunk.Font.Font, lastValidChunk.Font.Size, testWidth);
                 String post = he.HyphenatedWordPost;
                 if (pre.Length > 0) {
                     PdfChunk extra = new PdfChunk(pre, lastValidChunk);
                     currentChar = word[1] - post.Length;
                     return new PdfLine(0, originalWidth, testWidth - lastValidChunk.Font.Width(pre), alignment, false, CreateArrayOfPdfChunks(oldCurrentChar, word[0] - 1, extra), isRTL);
                 }
             }
         }
     }
     if (lastSplit == -1 || lastSplit >= newCurrentChar) {
         // no split point or split point ahead of end
         return new PdfLine(0, originalWidth, width + GetWidth(newCurrentChar + 1, currentChar - 1), alignment, false, CreateArrayOfPdfChunks(oldCurrentChar, newCurrentChar), isRTL);
     }
     // standard split
     currentChar = lastSplit + 1;
//.........这里部分代码省略.........

 public void AddPiece(char c, PdfChunk chunk)
 {
     if (totalTextLength >= pieceSize) {
         char[] tempText = text;
         PdfChunk[] tempDetailChunks = detailChunks;
         pieceSize *= 2;
         text = new char[pieceSize];
         detailChunks = new PdfChunk[pieceSize];
         Array.Copy(tempText, 0, text, 0, totalTextLength);
         Array.Copy(tempDetailChunks, 0, detailChunks, 0, totalTextLength);
     }
     text[totalTextLength] = c;
     detailChunks[totalTextLength++] = chunk;
 }

 private void AddToLine(PdfChunk chunk)
 {
     if (chunk.ChangeLeading && chunk.IsImage()) {
         Image img = chunk.Image;
         float f = img.ScaledHeight + chunk.ImageOffsetY
             + img.BorderWidthTop + img.SpacingBefore;
         if (f > height) height = f;
     }
     line.Add(chunk);
 }

        // methods
    
        /**
         * Adds a <CODE>PdfChunk</CODE> to the <CODE>PdfLine</CODE>.
         *
         * @param		chunk		        the <CODE>PdfChunk</CODE> to add
         * @param		currentLeading		new value for the height of the line
         * @return		<CODE>null</CODE> if the chunk could be added completely; if not
         *				a <CODE>PdfChunk</CODE> containing the part of the chunk that could
         *				not be added is returned
         */

        internal PdfChunk Add(PdfChunk chunk, float currentLeading) {
            //we set line height to correspond to the current leading
            if (chunk != null && !chunk.ToString().Equals("")) {
                //whitespace shouldn't change leading
                if (!chunk.ToString().Equals(" ")) {
                    if (this.height < currentLeading || this.line.Count == 0)
                        this.height = currentLeading;
                }
            }
            return Add(chunk);
        }

 private void AddToLine(PdfChunk chunk) {
     if (chunk.ChangeLeading && chunk.IsImage()) {
         float f = chunk.Image.ScaledHeight + chunk.ImageOffsetY + chunk.Image.BorderWidthTop;
         if (f > height) height = f;
     }
     line.Add(chunk);
 }

        // constructors
        /**
         * Constructs a <CODE>PdfCell</CODE>-object.
         *
         * @param   cell        the original <CODE>Cell</CODE>
         * @param   rownumber   the number of the <CODE>Row</CODE> the <CODE>Cell</CODE> was in.
         * @param   left        the left border of the <CODE>PdfCell</CODE>
         * @param   right       the right border of the <CODE>PdfCell</CODE>
         * @param   top         the top border of the <CODE>PdfCell</CODE>
         * @param   cellspacing the cellspacing of the <CODE>Table</CODE>
         * @param   cellpadding the cellpadding of the <CODE>Table</CODE>
         */
        public PdfCell(Cell cell, int rownumber, float left, float right, float top, float cellspacing, float cellpadding)
            : base(left, top, right, top)
        {
            // copying the other Rectangle attributes from class Cell
            CloneNonPositionParameters(cell);
            this.cellpadding = cellpadding;
            this.cellspacing = cellspacing;
            this.verticalAlignment = cell.VerticalAlignment;
            this.useAscender = cell.UseAscender;
            this.useDescender = cell.UseDescender;
            this.useBorderPadding = cell.UseBorderPadding;

            // initialisation of some parameters
            PdfChunk chunk;
            PdfChunk overflow;
            lines = new ArrayList();
            images = new ArrayList();
            leading = cell.Leading;
            int alignment = cell.HorizontalAlignment;
            left += cellspacing + cellpadding;
            right -= cellspacing + cellpadding;

            left += GetBorderWidthInside(LEFT_BORDER);
            right -= GetBorderWidthInside(RIGHT_BORDER);
            contentHeight = 0;
            rowspan = cell.Rowspan;

            ArrayList allActions;
            int aCounter;
            // we loop over all the elements of the cell
            foreach (IElement ele in cell.Elements) {
                switch (ele.Type) {
                    case Element.JPEG:
                    case Element.IMGRAW:
                    case Element.IMGTEMPLATE:
                        AddImage((Image)ele, left, right, 0.4f * leading, alignment);
                        break;
                        // if the element is a list
                    case Element.LIST:
                        if (line != null && line.Size > 0) {
                            line.ResetAlignment();
                            AddLine(line);
                        }
                        allActions = new ArrayList();
                        ProcessActions(ele, null, allActions);
                        aCounter = 0;
                        // we loop over all the listitems
                        foreach (ListItem item in ((List)ele).Items) {
                            line = new PdfLine(left + item.IndentationLeft, right, alignment, item.Leading);
                            line.ListItem = item;
                            foreach (Chunk c in item.Chunks) {
                                chunk = new PdfChunk(c, (PdfAction)(allActions[aCounter++]));
                                while ((overflow = line.Add(chunk)) != null) {
                                    AddLine(line);
                                    line = new PdfLine(left + item.IndentationLeft, right, alignment, item.Leading);
                                    chunk = overflow;
                                }
                                line.ResetAlignment();
                                AddLine(line);
                                line = new PdfLine(left + item.IndentationLeft, right, alignment, leading);
                            }
                        }
                        line = new PdfLine(left, right, alignment, leading);
                        break;
                        // if the element is something else
                    default:
                        allActions = new ArrayList();
                        ProcessActions(ele, null, allActions);
                        aCounter = 0;

                        float currentLineLeading = leading;
                        float currentLeft = left;
                        float currentRight = right;
                        if (ele is Phrase) {
                            currentLineLeading = ((Phrase) ele).Leading;
                        }
                        if (ele is Paragraph) {
                            Paragraph p = (Paragraph) ele;
                            currentLeft += p.IndentationLeft;
                            currentRight -= p.IndentationRight;
                        }
                        if (line == null) {
                            line = new PdfLine(currentLeft, currentRight, alignment, currentLineLeading);
                        }
                        // we loop over the chunks
                        ArrayList chunks = ele.Chunks;
                        if (chunks.Count == 0) {
                            AddLine(line); // add empty line - all cells need some lines even if they are empty
//.........这里部分代码省略.........

 private void AddList(List list, float left, float right, int alignment) {
     PdfChunk chunk;
     PdfChunk overflow;
     ArrayList allActions = new ArrayList();
     ProcessActions(list, null, allActions);
     int aCounter = 0;
     foreach (IElement ele in list.Items) {
         switch (ele.Type) {
             case Element.LISTITEM:
                 ListItem item = (ListItem)ele;
                 line = new PdfLine(left + item.IndentationLeft, right, alignment, item.Leading);
                 line.ListItem = item;
                 foreach (Chunk c in item.Chunks) {
                     chunk = new PdfChunk(c, (PdfAction)(allActions[aCounter++]));
                     while ((overflow = line.Add(chunk)) != null) { 
                         AddLine(line);
                         line = new PdfLine(left + item.IndentationLeft, right, alignment, item.Leading);
                         chunk = overflow;
                     }
                     line.ResetAlignment();
                     AddLine(line);
                     line = new PdfLine(left + item.IndentationLeft, right, alignment, leading);
                 }
                 break;
             case Element.LIST:
                 List sublist = (List)ele;
                 AddList(sublist, left + sublist.IndentationLeft, right, alignment);
                 break;
         }
     }
 }

 /**
 * Checks if a character can be used to split a <CODE>PdfString</CODE>.
 * <P>
 * for the moment every character less than or equal to SPACE and the character '-' are 'splitCharacters'.
 *
 * @param start start position in the array
 * @param current current position in the array
 * @param end end position in the array
 * @param    cc        the character array that has to be checked
 * @param ck chunk array
 * @return    <CODE>true</CODE> if the character can be used to split a string, <CODE>false</CODE> otherwise
 */
 public bool IsSplitCharacter(int start, int current, int end, char[] cc, PdfChunk[] ck)
 {
     char c;
     if (ck == null)
         c = cc[current];
     else
         c = ck[Math.Min(current, ck.Length - 1)].GetUnicodeEquivalent(cc[current]);
     if (c <= ' ' || c == '-') {
         return true;
     }
     if (c < 0x2e80)
         return false;
     return ((c >= 0x2e80 && c < 0xd7a0)
         || (c >= 0xf900 && c < 0xfb00)
         || (c >= 0xfe30 && c < 0xfe50)
         || (c >= 0xff61 && c < 0xffa0));
 }