iTextSharp.text.pdf.PdfChunk.GetAttribute C# (CSharp) Метод

        internal Object GetAttribute(string name)
        {
            if (attributes.ContainsKey(name))
                return attributes[name];
            if (noStroke.ContainsKey(name))
                return noStroke[name];
            return null;
        }

        // methods

        /**
         * Adds a <CODE>PdfChunk</CODE> to the <CODE>PdfLine</CODE>.
         *
         * @param        chunk        the <CODE>PdfChunk</CODE> to add
         * @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)
        {
            // nothing happens if the chunk is null.
            if (chunk == null || chunk.ToString().Equals(""))
            {
                return(null);
            }

            // we split the chunk to be added
            PdfChunk overflow = chunk.Split(width);

            newlineSplit = (chunk.IsNewlineSplit() || overflow == null);
            //        if (chunk.IsNewlineSplit() && alignment == Element.ALIGN_JUSTIFIED)
            //            alignment = Element.ALIGN_LEFT;
            if (chunk.IsTab())
            {
                Object[] tab = (Object[])chunk.GetAttribute(Chunk.TAB);
                if (chunk.IsAttribute(Chunk.TABSETTINGS))
                {
                    bool isWhiteSpace = (bool)tab[1];
                    if (!isWhiteSpace || line.Count > 0)
                    {
                        Flush();
                        tabStopAnchorPosition = float.NaN;
                        tabStop = PdfChunk.GetTabStop(chunk, originalWidth - width);
                        if (tabStop.Position > originalWidth)
                        {
                            width = 0;
                            if (isWhiteSpace)
                            {
                                return(null);
                            }
                            else
                            {
                                return(chunk);
                            }
                        }
                        tabStop.Position = tabStop.Position;
                        chunk.TabStop    = tabStop;
                        if (tabStop.Align == TabStop.Alignment.LEFT)
                        {
                            width       = originalWidth - tabStop.Position;
                            tabStop     = null;
                            tabPosition = float.NaN;
                        }
                        else
                        {
                            tabPosition = originalWidth - width;
                        }
                    }
                    else
                    {
                        return(null);
                    }
                }
                else
                {
                    //Keep deprecated tab logic for backward compatibility...
                    float tabStopPosition = (float)tab[1];
                    bool  newline         = (bool)tab[2];
                    if (newline && tabPosition < originalWidth - width)
                    {
                        return(chunk);
                    }
                    chunk.AdjustLeft(left);
                    width = originalWidth - tabStopPosition;
                }
                AddToLine(chunk);
            }   // if the length of the chunk > 0 we add it to the line
            else if (chunk.Length > 0 || chunk.IsImage())
            {
                if (overflow != null)
                {
                    chunk.TrimLastSpace();
                }
                width -= chunk.Width();
                AddToLine(chunk);
            }

            // if the length == 0 and there were no other chunks added to the line yet,
            // we risk to end up in an endless loop trying endlessly to add the same chunk
            else if (line.Count < 1)
            {
                chunk    = overflow;
                overflow = chunk.Truncate(width);
                width   -= chunk.Width();
                if (chunk.Length > 0)
                {
                    AddToLine(chunk);
                    return(overflow);
                }
                // if the chunck couldn't even be truncated, we add everything, so be it
                else
                {
                    if (overflow != null)
                    {
                        AddToLine(chunk);
                    }
                    return(null);
                }
            }
            else
            {
                width += line[line.Count - 1].TrimLastSpace();
            }
            return(overflow);
        }