/**
   * Updates the interal bitset from <code>iterator</code>. This will set <code>validMask</code> to
   * true if <code>iterator</code> is non-null.
   */
  private void updateMask(AttributedCharacterIterator iterator) {
    if (iterator != null) {
      validMask = true;
      this.iterator = iterator;

      // Update the literal mask
      if (literalMask == null) {
        literalMask = new BitSet();
      } else {
        for (int counter = literalMask.length() - 1; counter >= 0; counter--) {
          literalMask.clear(counter);
        }
      }

      iterator.first();
      while (iterator.current() != CharacterIterator.DONE) {
        Map attributes = iterator.getAttributes();
        boolean set = isLiteral(attributes);
        int start = iterator.getIndex();
        int end = iterator.getRunLimit();

        while (start < end) {
          if (set) {
            literalMask.set(start);
          } else {
            literalMask.clear(start);
          }
          start++;
        }
        iterator.setIndex(start);
      }
    }
  }
  public Format.Field[] getFields(final int offset) {
    if (format == null) {
      return null;
    }

    Object value = getFormattedTextField().getValue();
    if (value == null) {
      return null;
    }

    AttributedCharacterIterator iterator = format.formatToCharacterIterator(value);
    if (offset < iterator.getBeginIndex() || offset > iterator.getEndIndex()) {
      return new Format.Field[0];
    }

    iterator.setIndex(offset);
    Set keys = iterator.getAttributes().keySet();
    Set result = new HashSet();
    Iterator iter = keys.iterator();

    while (iter.hasNext()) {
      Object key = iter.next();
      if (key instanceof Format.Field) {
        result.add(key);
      }
    }

    return (Format.Field[]) result.toArray(new Format.Field[result.size()]);
  }
  /**
   * Return a StyledParagraph reflecting the insertion of a single character into the text. This
   * method will attempt to reuse the given paragraph, but may create a new paragraph.
   *
   * @param aci an iterator over the text. The text should be the same as the text used to create
   *     (or most recently update) oldParagraph, with the exception of inserting a single character
   *     at insertPos.
   * @param chars the characters in aci
   * @param insertPos the index of the new character in aci
   * @param oldParagraph a StyledParagraph for the text in aci before the insertion
   */
  public static StyledParagraph insertChar(
      AttributedCharacterIterator aci, char[] chars, int insertPos, StyledParagraph oldParagraph) {

    // If the styles at insertPos match those at insertPos-1,
    // oldParagraph will be reused.  Otherwise we create a new
    // paragraph.

    char ch = aci.setIndex(insertPos);
    int relativePos = Math.max(insertPos - aci.getBeginIndex() - 1, 0);

    Map attributes = addInputMethodAttrs(aci.getAttributes());
    Decoration d = Decoration.getDecoration(attributes);
    if (!oldParagraph.getDecorationAt(relativePos).equals(d)) {
      return new StyledParagraph(aci, chars);
    }
    Object f = getGraphicOrFont(attributes);
    if (f == null) {
      FontResolver resolver = FontResolver.getInstance();
      int fontIndex = resolver.getFontIndex(ch);
      f = resolver.getFont(fontIndex, attributes);
    }
    if (!oldParagraph.getFontOrGraphicAt(relativePos).equals(f)) {
      return new StyledParagraph(aci, chars);
    }

    // insert into existing paragraph
    oldParagraph.length += 1;
    if (oldParagraph.decorations != null) {
      insertInto(relativePos, oldParagraph.decorationStarts, oldParagraph.decorations.size());
    }
    if (oldParagraph.fonts != null) {
      insertInto(relativePos, oldParagraph.fontStarts, oldParagraph.fonts.size());
    }
    return oldParagraph;
  }
示例#4
0
  protected String style(final AttributedCharacterIterator aci) {
    final StringBuilder builder = new StringBuilder();

    Map<AttributedCharacterIterator.Attribute, Object> map = null;
    char chr = aci.current();

    while (aci.getIndex() < aci.getEndIndex()) {
      if (!aci.getAttributes().equals(map)) {
        style(aci.getAttributes(), builder);
        map = aci.getAttributes();
      }

      builder.append(StringEscapeUtils.escapeHtml(String.valueOf(chr)));
      chr = aci.next();
    }

    return builder.toString();
  }
示例#5
0
  /**
   * This routine goes through the attributes and sets the font before calling the actual string
   * drawing routine
   *
   * @param iter
   */
  protected void doAttributes(AttributedCharacterIterator iter) {
    underline = false;
    Set set = iter.getAttributes().keySet();
    for (Iterator iterator = set.iterator(); iterator.hasNext(); ) {
      TextAttribute textattribute = (TextAttribute) iterator.next();
      if (textattribute.equals(TextAttribute.FONT)) {
        Font font = (Font) iter.getAttributes().get(textattribute);
        setFont(font);
      } else if (textattribute.equals(TextAttribute.UNDERLINE)) {
        if (iter.getAttributes().get(textattribute) == TextAttribute.UNDERLINE_ON) underline = true;
      } else if (textattribute.equals(TextAttribute.SUPERSCRIPT)) {
        /*
        iter.getAttributes().get(textattribute);
        Integer _tmp = TextAttribute.SUPERSCRIPT_SUPER;
        subscript = true;
         */
      } else if (textattribute.equals(TextAttribute.SIZE)) {
        Object obj = iter.getAttributes().get(textattribute);
        Font font1 = null;
        /* ssteward: no deriveFont method for java.awt.Font in libgcj 3.4.2
                      if(obj instanceof Integer) {
                          int i = ((Integer)obj).intValue();
                          font1 = getFont().deriveFont(getFont().getStyle(), i);
                      }
                      else if(obj instanceof Float) {
                          float f = ((Float)obj).floatValue();
                          font1 = getFont().deriveFont(getFont().getStyle(), f);
                      }
                      else {
                          //System.out.println("Unknown type for attribute SIZE");
                          return;
                      }
        */
        return;

        // setFont(font1); // ssteward
      } else {
        String s = "only FONT/SIZE/UNDERLINE/SUPERSCRIPT supported";
        throw new RuntimeException(s);
      }
    }
  }
  /** Returns a Set of the attribute identifiers at <code>index</code>. */
  Map getAttributes(int index) {
    if (isValidMask()) {
      AttributedCharacterIterator iterator = getIterator();

      if (index >= 0 && index <= iterator.getEndIndex()) {
        iterator.setIndex(index);
        return iterator.getAttributes();
      }
    }
    return null;
  }
    public void actionPerformed(ActionEvent ae) {

      if (getFormattedTextField().isEditable()) {
        if (getAllowsInvalid()) {
          // This will work if the currently edited value is valid.
          updateMask();
        }

        boolean validEdit = false;

        if (isValidMask()) {
          int start = getFormattedTextField().getSelectionStart();

          if (start != -1) {
            AttributedCharacterIterator iterator = getIterator();

            iterator.setIndex(start);

            Map attributes = iterator.getAttributes();
            Object field = getAdjustField(start, attributes);

            if (canIncrement(field, start)) {
              try {
                Object value = stringToValue(getFormattedTextField().getText());
                int fieldTypeCount = getFieldTypeCountTo(field, start);

                value = adjustValue(value, attributes, field, direction);
                if (value != null && isValidValue(value, false)) {
                  resetValue(value);
                  updateMask();

                  if (isValidMask()) {
                    selectField(field, fieldTypeCount);
                  }
                  validEdit = true;
                }
              } catch (ParseException pe) {
              } catch (BadLocationException ble) {
              }
            }
          }
        }
        if (!validEdit) {
          invalidEdit();
        }
      }
    }
示例#8
0
 /**
  * This routine goes through the attributes and sets the font before calling the actual string
  * drawing routine
  *
  * @param iter
  */
 protected void doAttributes(AttributedCharacterIterator iter) {
   underline = false;
   Set set = iter.getAttributes().keySet();
   for (Iterator iterator = set.iterator(); iterator.hasNext(); ) {
     AttributedCharacterIterator.Attribute attribute =
         (AttributedCharacterIterator.Attribute) iterator.next();
     if (!(attribute instanceof TextAttribute)) continue;
     TextAttribute textattribute = (TextAttribute) attribute;
     if (textattribute.equals(TextAttribute.FONT)) {
       Font font = (Font) iter.getAttributes().get(textattribute);
       setFont(font);
     } else if (textattribute.equals(TextAttribute.UNDERLINE)) {
       if (iter.getAttributes().get(textattribute) == TextAttribute.UNDERLINE_ON) underline = true;
     } else if (textattribute.equals(TextAttribute.SIZE)) {
       Object obj = iter.getAttributes().get(textattribute);
       if (obj instanceof Integer) {
         int i = ((Integer) obj).intValue();
         setFont(getFont().deriveFont(getFont().getStyle(), i));
       } else if (obj instanceof Float) {
         float f = ((Float) obj).floatValue();
         setFont(getFont().deriveFont(getFont().getStyle(), f));
       }
     } else if (textattribute.equals(TextAttribute.FOREGROUND)) {
       setColor((Color) iter.getAttributes().get(textattribute));
     } else if (textattribute.equals(TextAttribute.FAMILY)) {
       Font font = getFont();
       Map fontAttributes = font.getAttributes();
       fontAttributes.put(TextAttribute.FAMILY, iter.getAttributes().get(textattribute));
       setFont(font.deriveFont(fontAttributes));
     } else if (textattribute.equals(TextAttribute.POSTURE)) {
       Font font = getFont();
       Map fontAttributes = font.getAttributes();
       fontAttributes.put(TextAttribute.POSTURE, iter.getAttributes().get(textattribute));
       setFont(font.deriveFont(fontAttributes));
     } else if (textattribute.equals(TextAttribute.WEIGHT)) {
       Font font = getFont();
       Map fontAttributes = font.getAttributes();
       fontAttributes.put(TextAttribute.WEIGHT, iter.getAttributes().get(textattribute));
       setFont(font.deriveFont(fontAttributes));
     }
   }
 }
  protected void exportStyledText(JRStyledText styledText, Locale locale, boolean startedHyperlink)
      throws IOException {
    String text = styledText.getText();

    int runLimit = 0;

    AttributedCharacterIterator iterator = styledText.getAttributedString().getIterator();

    while (runLimit < styledText.length()
        && (runLimit = iterator.getRunLimit()) <= styledText.length()) {
      exportStyledTextRun(
          iterator.getAttributes(),
          text.substring(iterator.getIndex(), runLimit),
          locale,
          startedHyperlink);

      iterator.setIndex(runLimit);
    }
  }
  /**
   * finds attributes with regards to char index in this AttributedCharacterIterator, and puts them
   * in a vector
   *
   * @param iterator
   * @return a vector, each entry in this vector are of type FieldContainer , which stores start and
   *     end indexes and an attribute this range has
   */
  private static List<FieldContainer> findFields(AttributedCharacterIterator iterator) {
    List<FieldContainer> result = new ArrayList<FieldContainer>();
    while (iterator.getIndex() != iterator.getEndIndex()) {
      int start = iterator.getRunStart();
      int end = iterator.getRunLimit();

      Iterator it = iterator.getAttributes().keySet().iterator();
      while (it.hasNext()) {
        AttributedCharacterIterator.Attribute attribute =
            (AttributedCharacterIterator.Attribute) it.next();
        Object value = iterator.getAttribute(attribute);
        result.add(new FieldContainer(start, end, attribute, value));
        // System.out.println(start + " " + end + ": " + attribute + ",
        // " + value );
        // System.out.println("v.add(new FieldContainer(" + start +"," +
        // end +"," + attribute+ "," + value+ "));");
      }
      iterator.setIndex(end);
    }
    return result;
  }
  /**
   * Create a new StyledParagraph over the given styled text.
   *
   * @param aci an iterator over the text
   * @param chars the characters extracted from aci
   */
  public StyledParagraph(AttributedCharacterIterator aci, char[] chars) {

    int start = aci.getBeginIndex();
    int end = aci.getEndIndex();
    length = end - start;

    int index = start;
    aci.first();

    do {
      final int nextRunStart = aci.getRunLimit();
      final int localIndex = index - start;

      Map attributes = aci.getAttributes();
      attributes = addInputMethodAttrs(attributes);
      Decoration d = Decoration.getDecoration(attributes);
      addDecoration(d, localIndex);

      Object f = getGraphicOrFont(attributes);
      if (f == null) {
        addFonts(chars, attributes, localIndex, nextRunStart - start);
      } else {
        addFont(f, localIndex);
      }

      aci.setIndex(nextRunStart);
      index = nextRunStart;

    } while (index < end);

    // Add extra entries to starts arrays with the length
    // of the paragraph.  'this' is used as a dummy value
    // in the Vector.
    if (decorations != null) {
      decorationStarts = addToVector(this, length, decorations, decorationStarts);
    }
    if (fonts != null) {
      fontStarts = addToVector(this, length, fonts, fontStarts);
    }
  }
示例#12
0
  /** Initialize state, including fChars array, direction, and fBidi. */
  private void initAll(AttributedCharacterIterator text) {

    fStart = text.getBeginIndex();

    // extract chars
    fChars = new char[text.getEndIndex() - fStart];

    int n = 0;
    for (char c = text.first(); c != CharacterIterator.DONE; c = text.next()) {
      fChars[n++] = c;
    }

    text.first();

    fBidi = new Bidi(text);
    if (fBidi.isLeftToRight()) {
      fBidi = null;
    }

    text.first();
    Map<? extends Attribute, ?> paragraphAttrs = text.getAttributes();
    NumericShaper shaper = AttributeValues.getNumericShaping(paragraphAttrs);
    if (shaper != null) {
      shaper.shape(fChars, 0, fChars.length);
    }

    fParagraph = new StyledParagraph(text, fChars);

    // set paragraph attributes
    {
      // If there's an embedded graphic at the start of the
      // paragraph, look for the first non-graphic character
      // and use it and its font to initialize the paragraph.
      // If not, use the first graphic to initialize.
      fJustifyRatio = AttributeValues.getJustification(paragraphAttrs);

      boolean haveFont = TextLine.advanceToFirstFont(text);

      if (haveFont) {
        Font defaultFont = TextLine.getFontAtCurrentPos(text);
        int charsStart = text.getIndex() - text.getBeginIndex();
        LineMetrics lm = defaultFont.getLineMetrics(fChars, charsStart, charsStart + 1, fFrc);
        fBaseline = (byte) lm.getBaselineIndex();
        fBaselineOffsets = lm.getBaselineOffsets();
      } else {
        // hmmm what to do here?  Just try to supply reasonable
        // values I guess.

        GraphicAttribute graphic =
            (GraphicAttribute) paragraphAttrs.get(TextAttribute.CHAR_REPLACEMENT);
        fBaseline = TextLayout.getBaselineFromGraphic(graphic);
        Hashtable<Attribute, ?> fmap = new Hashtable<>(5, (float) 0.9);
        Font dummyFont = new Font(fmap);
        LineMetrics lm = dummyFont.getLineMetrics(" ", 0, 1, fFrc);
        fBaselineOffsets = lm.getBaselineOffsets();
      }
      fBaselineOffsets = TextLine.getNormalizedOffsets(fBaselineOffsets, fBaseline);
    }

    invalidateComponents();
  }
  public void drawString(AttributedCharacterIterator iterator, float x, float y) {

    // TextLayout draws the iterator as glyph vector
    // thats why we use it only in the case of TEXT_AS_SHAPES,
    // otherwise tagged strings are always written as glyphs
    if (isProperty(TEXT_AS_SHAPES)) {
      // draws all attributes
      TextLayout tl = new TextLayout(iterator, getFontRenderContext());
      tl.draw(this, x, y);
    } else {
      // reset to that font at the end
      Font font = getFont();

      // initial attributes, we us TextAttribute.equals() rather
      // than Font.equals() because using Font.equals() we do
      // not get a 'false' if underline etc. is changed
      Map<? extends Attribute, Object> attributes = FontUtilities.getAttributes(font);

      // stores all characters which are written with the same font
      // if font is changed the buffer will be written and cleared
      // after it
      StringBuffer sb = new StringBuffer();

      for (char c = iterator.first(); c != AttributedCharacterIterator.DONE; c = iterator.next()) {

        // append c if font is not changed
        if (attributes.equals(iterator.getAttributes())) {
          sb.append(c);

        } else {
          // TextLayout does not like 0 length strings
          if (sb.length() > 0) {
            // draw sb if font is changed
            drawString(sb.toString(), x, y);

            // change the x offset for the next drawing
            // FIXME: change y offset for vertical text
            TextLayout tl = new TextLayout(sb.toString(), attributes, getFontRenderContext());

            // calculate real width
            x = x + Math.max(tl.getAdvance(), (float) tl.getBounds().getWidth());
          }

          // empty sb
          sb = new StringBuffer();
          sb.append(c);

          // change the font
          attributes = iterator.getAttributes();
          setFont(new Font(attributes));
        }
      }

      // draw the rest
      if (sb.length() > 0) {
        drawString(sb.toString(), x, y);
      }

      // use the old font for the next string drawing
      setFont(font);
    }
  }