plainview.java

gcc的组建

    // make sure we have the metrics
    updateMetrics();

    float span = 0;
    Element el = getElement();

    switch (axis)
      {
      case X_AXIS:
        span = determineMaxLineLength();
      case Y_AXIS:
      default:
        span = metrics.getHeight() * el.getElementCount();
        break;
      }
    return span;
  }

  /**
   * Maps coordinates from the <code>View</code>'s space into a position
   * in the document model.
   *
   * @param x the x coordinate in the view space
   * @param y the y coordinate in the view space
   * @param a the allocation of this <code>View</code>
   * @param b the bias to use
   *
   * @return the position in the document that corresponds to the screen
   *         coordinates <code>x, y</code>
   */
  public int viewToModel(float x, float y, Shape a, Position.Bias[] b)
  {
    Rectangle rec = a.getBounds();
    Document doc = getDocument();
    Element root = doc.getDefaultRootElement();
    
    // PlainView doesn't support line-wrapping so we can find out which
    // Element was clicked on just by the y-position    
    int lineClicked = (int) (y - rec.y) / metrics.getHeight();
    if (lineClicked >= root.getElementCount())
      return getEndOffset() - 1;
    
    Element line = root.getElement(lineClicked);
    Segment s = getLineBuffer();
    int start = line.getStartOffset();
    // We don't want the \n at the end of the line.
    int end = line.getEndOffset() - 1;
    try
      {
        doc.getText(start, end - start, s);
      }
    catch (BadLocationException ble)
      {
        AssertionError ae = new AssertionError("Unexpected bad location");
        ae.initCause(ble);
        throw ae;
      }
    
    int pos = Utilities.getTabbedTextOffset(s, metrics, rec.x, (int)x, this, start);
    return Math.max (0, pos);
  }     
  
  /**
   * Since insertUpdate and removeUpdate each deal with children
   * Elements being both added and removed, they both have to perform
   * the same checks.  So they both simply call this method.
   * @param changes the DocumentEvent for the changes to the Document.
   * @param a the allocation of the View.
   * @param f the ViewFactory to use for rebuilding.
   */
  protected void updateDamage(DocumentEvent changes, Shape a, ViewFactory f)
  {
    Element el = getElement();
    ElementChange ec = changes.getChange(el);
    
    // If ec is null then no lines were added or removed, just 
    // repaint the changed line
    if (ec == null)
      {
        int line = getElement().getElementIndex(changes.getOffset());
        damageLineRange(line, line, a, getContainer());
        return;
      }
    
    Element[] removed = ec.getChildrenRemoved();
    Element[] newElements = ec.getChildrenAdded();
    
    // If no Elements were added or removed, we just want to repaint
    // the area containing the line that was modified
    if (removed == null && newElements == null)
      {
        int line = getElement().getElementIndex(changes.getOffset());
        damageLineRange(line, line, a, getContainer());
        return;
      }

    // Check to see if we removed the longest line, if so we have to
    // search through all lines and find the longest one again
    if (removed != null)
      {
        for (int i = 0; i < removed.length; i++)
          if (removed[i].equals(longestLine))
            {
              // reset maxLineLength and search through all lines for longest one
              maxLineLength = -1;
              determineMaxLineLength();
              ((JTextComponent)getContainer()).repaint();
              return;
            }
      }
    
    // If we've reached here, that means we haven't removed the longest line
    if (newElements == null)
      {
        // No lines were added, just repaint the container and exit
        ((JTextComponent)getContainer()).repaint();
        return;
      }

    //  Make sure we have the metrics
    updateMetrics();
       
    // If we've reached here, that means we haven't removed the longest line
    // and we have added at least one line, so we have to check if added lines
    // are longer than the previous longest line        
    Segment seg = getLineBuffer();
    float longestNewLength = 0;
    Element longestNewLine = null;    

    // Loop through the added lines to check their length
    for (int i = 0; i < newElements.length; i++)
      {
        Element child = newElements[i];
        int start = child.getStartOffset();
        int end = child.getEndOffset();
        try
          {
            el.getDocument().getText(start, end - start, seg);
          }
        catch (BadLocationException ex)
          {
            AssertionError ae = new AssertionError("Unexpected bad location");
	    ae.initCause(ex);
	    throw ae;
          }
                
        if (seg == null || seg.array == null || seg.count == 0)
          continue;
        
        int width = metrics.charsWidth(seg.array, seg.offset, seg.count);
        if (width > longestNewLength)
          {
            longestNewLine = child;
            longestNewLength = width;
          }
      }
    
    // Check if the longest of the new lines is longer than our previous
    // longest line, and if so update our values
    if (longestNewLength > maxLineLength)
      {
        maxLineLength = longestNewLength;
        longestLine = longestNewLine;
      }
    // Repaint the container
    ((JTextComponent)getContainer()).repaint();
  }

  /**
   * This method is called when something is inserted into the Document
   * that this View is displaying.
   * 
   * @param changes the DocumentEvent for the changes.
   * @param a the allocation of the View
   * @param f the ViewFactory used to rebuild
   */
  public void insertUpdate(DocumentEvent changes, Shape a, ViewFactory f)
  {
    updateDamage(changes, a, f);
  }

  /**
   * This method is called when something is removed from the Document
   * that this View is displaying.
   * 
   * @param changes the DocumentEvent for the changes.
   * @param a the allocation of the View
   * @param f the ViewFactory used to rebuild
   */
  public void removeUpdate(DocumentEvent changes, Shape a, ViewFactory f)
  {
    updateDamage(changes, a, f);
  }
  
  /**
   * This method is called when attributes were changed in the 
   * Document in a location that this view is responsible for.
   */
  public void changedUpdate (DocumentEvent changes, Shape a, ViewFactory f)
  {
    updateDamage(changes, a, f);
  }
  
  /**
   * Repaint the given line range.  This is called from insertUpdate,
   * changedUpdate, and removeUpdate when no new lines were added 
   * and no lines were removed, to repaint the line that was 
   * modified.
   * 
   * @param line0 the start of the range
   * @param line1 the end of the range
   * @param a the rendering region of the host
   * @param host the Component that uses this View (used to call repaint
   * on that Component)
   * 
   * @since 1.4
   */
  protected void damageLineRange (int line0, int line1, Shape a, Component host)
  {
    if (a == null)
      return;

    Rectangle rec0 = lineToRect(a, line0);
    Rectangle rec1 = lineToRect(a, line1);

    if (rec0 == null || rec1 == null)
      // something went wrong, repaint the entire host to be safe
      host.repaint();
    else
      {
        Rectangle repaintRec = rec0.union(rec1);
        host.repaint();
      }    
  }

  /**
   * Provides a {@link Segment} object, that can be used to fetch text from
   * the document.
   *
   * @returna {@link Segment} object, that can be used to fetch text from
   *          the document
   */
  protected Segment getLineBuffer()
  {
    if (lineBuffer == null)
      lineBuffer = new Segment();
    return lineBuffer;
  }

  /**
   * Returns the document position that is (visually) nearest to the given
   * document position <code>pos</code> in the given direction <code>d</code>.
   *
   * @param c the text component
   * @param pos the document position
   * @param b the bias for <code>pos</code>
   * @param d the direction, must be either {@link SwingConstants#NORTH},
   *        {@link SwingConstants#SOUTH}, {@link SwingConstants#WEST} or
   *        {@link SwingConstants#EAST}
   * @param biasRet an array of {@link Position.Bias} that can hold at least
   *        one element, which is filled with the bias of the return position
   *        on method exit
   *
   * @return the document position that is (visually) nearest to the given
   *         document position <code>pos</code> in the given direction
   *         <code>d</code>
   *
   * @throws BadLocationException if <code>pos</code> is not a valid offset in
   *         the document model
   */
  public int getNextVisualPositionFrom(JTextComponent c, int pos,
                                       Position.Bias b, int d,
                                       Position.Bias[] biasRet)
    throws BadLocationException
  {
    // TODO: Implement this properly.
    throw new AssertionError("Not implemented yet.");
  }
}