Home » openjdk-7 » javax » swing » text » [javadoc | source]

    1   /*
    2    * Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
    3    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    4    *
    5    * This code is free software; you can redistribute it and/or modify it
    6    * under the terms of the GNU General Public License version 2 only, as
    7    * published by the Free Software Foundation.  Oracle designates this
    8    * particular file as subject to the "Classpath" exception as provided
    9    * by Oracle in the LICENSE file that accompanied this code.
   10    *
   11    * This code is distributed in the hope that it will be useful, but WITHOUT
   12    * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   13    * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   14    * version 2 for more details (a copy is included in the LICENSE file that
   15    * accompanied this code).
   16    *
   17    * You should have received a copy of the GNU General Public License version
   18    * 2 along with this work; if not, write to the Free Software Foundation,
   19    * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   20    *
   21    * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   22    * or visit www.oracle.com if you need additional information or have any
   23    * questions.
   24    */
   25   package javax.swing.text;
   26   
   27   import java.util.Vector;
   28   import java.awt;
   29   import javax.swing.event;
   30   import javax.swing.SwingConstants;
   31   
   32   /**
   33    * <code>CompositeView</code> is an abstract <code>View</code>
   34    * implementation which manages one or more child views.
   35    * (Note that <code>CompositeView</code> is intended
   36    * for managing relatively small numbers of child views.)
   37    * <code>CompositeView</code> is intended to be used as
   38    * a starting point for <code>View</code> implementations,
   39    * such as <code>BoxView</code>, that will contain child
   40    * <code>View</code>s. Subclasses that wish to manage the
   41    * collection of child <code>View</code>s should use the
   42    * {@link #replace} method.  As <code>View</code> invokes
   43    * <code>replace</code> during <code>DocumentListener</code>
   44    * notification, you normally won't need to directly
   45    * invoke <code>replace</code>.
   46    *
   47    * <p>While <code>CompositeView</code>
   48    * does not impose a layout policy on its child <code>View</code>s,
   49    * it does allow for inseting the child <code>View</code>s
   50    * it will contain.  The insets can be set by either
   51    * {@link #setInsets} or {@link #setParagraphInsets}.
   52    *
   53    * <p>In addition to the abstract methods of
   54    * {@link javax.swing.text.View},
   55    * subclasses of <code>CompositeView</code> will need to
   56    * override:
   57    * <ul>
   58    * <li>{@link #isBefore} - Used to test if a given
   59    *     <code>View</code> location is before the visual space
   60    *     of the <code>CompositeView</code>.
   61    * <li>{@link #isAfter} - Used to test if a given
   62    *     <code>View</code> location is after the visual space
   63    *     of the <code>CompositeView</code>.
   64    * <li>{@link #getViewAtPoint} - Returns the view at
   65    *     a given visual location.
   66    * <li>{@link #childAllocation} - Returns the bounds of
   67    *     a particular child <code>View</code>.
   68    *     <code>getChildAllocation</code> will invoke
   69    *     <code>childAllocation</code> after offseting
   70    *     the bounds by the <code>Inset</code>s of the
   71    *     <code>CompositeView</code>.
   72    * </ul>
   73    *
   74    * @author  Timothy Prinzing
   75    */
   76   public abstract class CompositeView extends View {
   77   
   78       /**
   79        * Constructs a <code>CompositeView</code> for the given element.
   80        *
   81        * @param elem  the element this view is responsible for
   82        */
   83       public CompositeView(Element elem) {
   84           super(elem);
   85           children = new View[1];
   86           nchildren = 0;
   87           childAlloc = new Rectangle();
   88       }
   89   
   90       /**
   91        * Loads all of the children to initialize the view.
   92        * This is called by the {@link #setParent}
   93        * method.  Subclasses can reimplement this to initialize
   94        * their child views in a different manner.  The default
   95        * implementation creates a child view for each
   96        * child element.
   97        *
   98        * @param f the view factory
   99        * @see #setParent
  100        */
  101       protected void loadChildren(ViewFactory f) {
  102           if (f == null) {
  103               // No factory. This most likely indicates the parent view
  104               // has changed out from under us, bail!
  105               return;
  106           }
  107           Element e = getElement();
  108           int n = e.getElementCount();
  109           if (n > 0) {
  110               View[] added = new View[n];
  111               for (int i = 0; i < n; i++) {
  112                   added[i] = f.create(e.getElement(i));
  113               }
  114               replace(0, 0, added);
  115           }
  116       }
  117   
  118       // --- View methods ---------------------------------------------
  119   
  120       /**
  121        * Sets the parent of the view.
  122        * This is reimplemented to provide the superclass
  123        * behavior as well as calling the <code>loadChildren</code>
  124        * method if this view does not already have children.
  125        * The children should not be loaded in the
  126        * constructor because the act of setting the parent
  127        * may cause them to try to search up the hierarchy
  128        * (to get the hosting <code>Container</code> for example).
  129        * If this view has children (the view is being moved
  130        * from one place in the view hierarchy to another),
  131        * the <code>loadChildren</code> method will not be called.
  132        *
  133        * @param parent the parent of the view, <code>null</code> if none
  134        */
  135       public void setParent(View parent) {
  136           super.setParent(parent);
  137           if ((parent != null) && (nchildren == 0)) {
  138               ViewFactory f = getViewFactory();
  139               loadChildren(f);
  140           }
  141       }
  142   
  143       /**
  144        * Returns the number of child views of this view.
  145        *
  146        * @return the number of views >= 0
  147        * @see #getView
  148        */
  149       public int getViewCount() {
  150           return nchildren;
  151       }
  152   
  153       /**
  154        * Returns the n-th view in this container.
  155        *
  156        * @param n the number of the desired view, >= 0 && < getViewCount()
  157        * @return the view at index <code>n</code>
  158        */
  159       public View getView(int n) {
  160           return children[n];
  161       }
  162   
  163       /**
  164        * Replaces child views.  If there are no views to remove
  165        * this acts as an insert.  If there are no views to
  166        * add this acts as a remove.  Views being removed will
  167        * have the parent set to <code>null</code>,
  168        * and the internal reference to them removed so that they
  169        * may be garbage collected.
  170        *
  171        * @param offset the starting index into the child views to insert
  172        *   the new views; >= 0 and <= getViewCount
  173        * @param length the number of existing child views to remove;
  174        *   this should be a value >= 0 and <= (getViewCount() - offset)
  175        * @param views the child views to add; this value can be
  176        *  <code>null</code>
  177        *   to indicate no children are being added (useful to remove)
  178        */
  179       public void replace(int offset, int length, View[] views) {
  180           // make sure an array exists
  181           if (views == null) {
  182               views = ZERO;
  183           }
  184   
  185           // update parent reference on removed views
  186           for (int i = offset; i < offset + length; i++) {
  187               if (children[i].getParent() == this) {
  188                   // in FlowView.java view might be referenced
  189                   // from two super-views as a child. see logicalView
  190                   children[i].setParent(null);
  191               }
  192               children[i] = null;
  193           }
  194   
  195           // update the array
  196           int delta = views.length - length;
  197           int src = offset + length;
  198           int nmove = nchildren - src;
  199           int dest = src + delta;
  200           if ((nchildren + delta) >= children.length) {
  201               // need to grow the array
  202               int newLength = Math.max(2*children.length, nchildren + delta);
  203               View[] newChildren = new View[newLength];
  204               System.arraycopy(children, 0, newChildren, 0, offset);
  205               System.arraycopy(views, 0, newChildren, offset, views.length);
  206               System.arraycopy(children, src, newChildren, dest, nmove);
  207               children = newChildren;
  208           } else {
  209               // patch the existing array
  210               System.arraycopy(children, src, children, dest, nmove);
  211               System.arraycopy(views, 0, children, offset, views.length);
  212           }
  213           nchildren = nchildren + delta;
  214   
  215           // update parent reference on added views
  216           for (int i = 0; i < views.length; i++) {
  217               views[i].setParent(this);
  218           }
  219       }
  220   
  221       /**
  222        * Fetches the allocation for the given child view to
  223        * render into. This enables finding out where various views
  224        * are located.
  225        *
  226        * @param index the index of the child, >= 0 && < getViewCount()
  227        * @param a  the allocation to this view
  228        * @return the allocation to the child
  229        */
  230       public Shape getChildAllocation(int index, Shape a) {
  231           Rectangle alloc = getInsideAllocation(a);
  232           childAllocation(index, alloc);
  233           return alloc;
  234       }
  235   
  236       /**
  237        * Provides a mapping from the document model coordinate space
  238        * to the coordinate space of the view mapped to it.
  239        *
  240        * @param pos the position to convert >= 0
  241        * @param a the allocated region to render into
  242        * @param b a bias value of either <code>Position.Bias.Forward</code>
  243        *  or <code>Position.Bias.Backward</code>
  244        * @return the bounding box of the given position
  245        * @exception BadLocationException  if the given position does
  246        *   not represent a valid location in the associated document
  247        * @see View#modelToView
  248        */
  249       public Shape modelToView(int pos, Shape a, Position.Bias b) throws BadLocationException {
  250           boolean isBackward = (b == Position.Bias.Backward);
  251           int testPos = (isBackward) ? Math.max(0, pos - 1) : pos;
  252           if(isBackward && testPos < getStartOffset()) {
  253               return null;
  254           }
  255           int vIndex = getViewIndexAtPosition(testPos);
  256           if ((vIndex != -1) && (vIndex < getViewCount())) {
  257               View v = getView(vIndex);
  258               if(v != null && testPos >= v.getStartOffset() &&
  259                  testPos < v.getEndOffset()) {
  260                   Shape childShape = getChildAllocation(vIndex, a);
  261                   if (childShape == null) {
  262                       // We are likely invalid, fail.
  263                       return null;
  264                   }
  265                   Shape retShape = v.modelToView(pos, childShape, b);
  266                   if(retShape == null && v.getEndOffset() == pos) {
  267                       if(++vIndex < getViewCount()) {
  268                           v = getView(vIndex);
  269                           retShape = v.modelToView(pos, getChildAllocation(vIndex, a), b);
  270                       }
  271                   }
  272                   return retShape;
  273               }
  274           }
  275           throw new BadLocationException("Position not represented by view",
  276                                          pos);
  277       }
  278   
  279       /**
  280        * Provides a mapping from the document model coordinate space
  281        * to the coordinate space of the view mapped to it.
  282        *
  283        * @param p0 the position to convert >= 0
  284        * @param b0 the bias toward the previous character or the
  285        *  next character represented by p0, in case the
  286        *  position is a boundary of two views; either
  287        *  <code>Position.Bias.Forward</code> or
  288        *  <code>Position.Bias.Backward</code>
  289        * @param p1 the position to convert >= 0
  290        * @param b1 the bias toward the previous character or the
  291        *  next character represented by p1, in case the
  292        *  position is a boundary of two views
  293        * @param a the allocated region to render into
  294        * @return the bounding box of the given position is returned
  295        * @exception BadLocationException  if the given position does
  296        *   not represent a valid location in the associated document
  297        * @exception IllegalArgumentException for an invalid bias argument
  298        * @see View#viewToModel
  299        */
  300       public Shape modelToView(int p0, Position.Bias b0, int p1, Position.Bias b1, Shape a) throws BadLocationException {
  301           if (p0 == getStartOffset() && p1 == getEndOffset()) {
  302               return a;
  303           }
  304           Rectangle alloc = getInsideAllocation(a);
  305           Rectangle r0 = new Rectangle(alloc);
  306           View v0 = getViewAtPosition((b0 == Position.Bias.Backward) ?
  307                                       Math.max(0, p0 - 1) : p0, r0);
  308           Rectangle r1 = new Rectangle(alloc);
  309           View v1 = getViewAtPosition((b1 == Position.Bias.Backward) ?
  310                                       Math.max(0, p1 - 1) : p1, r1);
  311           if (v0 == v1) {
  312               if (v0 == null) {
  313                   return a;
  314               }
  315               // Range contained in one view
  316               return v0.modelToView(p0, b0, p1, b1, r0);
  317           }
  318           // Straddles some views.
  319           int viewCount = getViewCount();
  320           int counter = 0;
  321           while (counter < viewCount) {
  322               View v;
  323               // Views may not be in same order as model.
  324               // v0 or v1 may be null if there is a gap in the range this
  325               // view contains.
  326               if ((v = getView(counter)) == v0 || v == v1) {
  327                   View endView;
  328                   Rectangle retRect;
  329                   Rectangle tempRect = new Rectangle();
  330                   if (v == v0) {
  331                       retRect = v0.modelToView(p0, b0, v0.getEndOffset(),
  332                                                Position.Bias.Backward, r0).
  333                                 getBounds();
  334                       endView = v1;
  335                   }
  336                   else {
  337                       retRect = v1.modelToView(v1.getStartOffset(),
  338                                                Position.Bias.Forward,
  339                                                p1, b1, r1).getBounds();
  340                       endView = v0;
  341                   }
  342   
  343                   // Views entirely covered by range.
  344                   while (++counter < viewCount &&
  345                          (v = getView(counter)) != endView) {
  346                       tempRect.setBounds(alloc);
  347                       childAllocation(counter, tempRect);
  348                       retRect.add(tempRect);
  349                   }
  350   
  351                   // End view.
  352                   if (endView != null) {
  353                       Shape endShape;
  354                       if (endView == v1) {
  355                           endShape = v1.modelToView(v1.getStartOffset(),
  356                                                     Position.Bias.Forward,
  357                                                     p1, b1, r1);
  358                       }
  359                       else {
  360                           endShape = v0.modelToView(p0, b0, v0.getEndOffset(),
  361                                                     Position.Bias.Backward, r0);
  362                       }
  363                       if (endShape instanceof Rectangle) {
  364                           retRect.add((Rectangle)endShape);
  365                       }
  366                       else {
  367                           retRect.add(endShape.getBounds());
  368                       }
  369                   }
  370                   return retRect;
  371               }
  372               counter++;
  373           }
  374           throw new BadLocationException("Position not represented by view", p0);
  375       }
  376   
  377       /**
  378        * Provides a mapping from the view coordinate space to the logical
  379        * coordinate space of the model.
  380        *
  381        * @param x   x coordinate of the view location to convert >= 0
  382        * @param y   y coordinate of the view location to convert >= 0
  383        * @param a the allocated region to render into
  384        * @param bias either <code>Position.Bias.Forward</code> or
  385        *  <code>Position.Bias.Backward</code>
  386        * @return the location within the model that best represents the
  387        *  given point in the view >= 0
  388        * @see View#viewToModel
  389        */
  390       public int viewToModel(float x, float y, Shape a, Position.Bias[] bias) {
  391           Rectangle alloc = getInsideAllocation(a);
  392           if (isBefore((int) x, (int) y, alloc)) {
  393               // point is before the range represented
  394               int retValue = -1;
  395   
  396               try {
  397                   retValue = getNextVisualPositionFrom(-1, Position.Bias.Forward,
  398                                                        a, EAST, bias);
  399               } catch (BadLocationException ble) { }
  400               catch (IllegalArgumentException iae) { }
  401               if(retValue == -1) {
  402                   retValue = getStartOffset();
  403                   bias[0] = Position.Bias.Forward;
  404               }
  405               return retValue;
  406           } else if (isAfter((int) x, (int) y, alloc)) {
  407               // point is after the range represented.
  408               int retValue = -1;
  409               try {
  410                   retValue = getNextVisualPositionFrom(-1, Position.Bias.Forward,
  411                                                        a, WEST, bias);
  412               } catch (BadLocationException ble) { }
  413               catch (IllegalArgumentException iae) { }
  414   
  415               if(retValue == -1) {
  416                   // NOTE: this could actually use end offset with backward.
  417                   retValue = getEndOffset() - 1;
  418                   bias[0] = Position.Bias.Forward;
  419               }
  420               return retValue;
  421           } else {
  422               // locate the child and pass along the request
  423               View v = getViewAtPoint((int) x, (int) y, alloc);
  424               if (v != null) {
  425                 return v.viewToModel(x, y, alloc, bias);
  426               }
  427           }
  428           return -1;
  429       }
  430   
  431       /**
  432        * Provides a way to determine the next visually represented model
  433        * location that one might place a caret.  Some views may not be visible,
  434        * they might not be in the same order found in the model, or they just
  435        * might not allow access to some of the locations in the model.
  436        * This is a convenience method for {@link #getNextNorthSouthVisualPositionFrom}
  437        * and {@link #getNextEastWestVisualPositionFrom}.
  438        *
  439        * @param pos the position to convert >= 0
  440        * @param b a bias value of either <code>Position.Bias.Forward</code>
  441        *  or <code>Position.Bias.Backward</code>
  442        * @param a the allocated region to render into
  443        * @param direction the direction from the current position that can
  444        *  be thought of as the arrow keys typically found on a keyboard;
  445        *  this may be one of the following:
  446        *  <ul>
  447        *  <li><code>SwingConstants.WEST</code>
  448        *  <li><code>SwingConstants.EAST</code>
  449        *  <li><code>SwingConstants.NORTH</code>
  450        *  <li><code>SwingConstants.SOUTH</code>
  451        *  </ul>
  452        * @param biasRet an array containing the bias that was checked
  453        * @return the location within the model that best represents the next
  454        *  location visual position
  455        * @exception BadLocationException
  456        * @exception IllegalArgumentException if <code>direction</code> is invalid
  457        */
  458       public int getNextVisualPositionFrom(int pos, Position.Bias b, Shape a,
  459                                            int direction, Position.Bias[] biasRet)
  460         throws BadLocationException {
  461           Rectangle alloc = getInsideAllocation(a);
  462   
  463           switch (direction) {
  464           case NORTH:
  465               return getNextNorthSouthVisualPositionFrom(pos, b, a, direction,
  466                                                          biasRet);
  467           case SOUTH:
  468               return getNextNorthSouthVisualPositionFrom(pos, b, a, direction,
  469                                                          biasRet);
  470           case EAST:
  471               return getNextEastWestVisualPositionFrom(pos, b, a, direction,
  472                                                        biasRet);
  473           case WEST:
  474               return getNextEastWestVisualPositionFrom(pos, b, a, direction,
  475                                                        biasRet);
  476           default:
  477               throw new IllegalArgumentException("Bad direction: " + direction);
  478           }
  479       }
  480   
  481       /**
  482        * Returns the child view index representing the given
  483        * position in the model.  This is implemented to call the
  484        * <code>getViewIndexByPosition</code>
  485        * method for backward compatibility.
  486        *
  487        * @param pos the position >= 0
  488        * @return  index of the view representing the given position, or
  489        *   -1 if no view represents that position
  490        * @since 1.3
  491        */
  492       public int getViewIndex(int pos, Position.Bias b) {
  493           if(b == Position.Bias.Backward) {
  494               pos -= 1;
  495           }
  496           if ((pos >= getStartOffset()) && (pos < getEndOffset())) {
  497               return getViewIndexAtPosition(pos);
  498           }
  499           return -1;
  500       }
  501   
  502       // --- local methods ----------------------------------------------------
  503   
  504   
  505       /**
  506        * Tests whether a point lies before the rectangle range.
  507        *
  508        * @param x the X coordinate >= 0
  509        * @param y the Y coordinate >= 0
  510        * @param alloc the rectangle
  511        * @return true if the point is before the specified range
  512        */
  513       protected abstract boolean isBefore(int x, int y, Rectangle alloc);
  514   
  515       /**
  516        * Tests whether a point lies after the rectangle range.
  517        *
  518        * @param x the X coordinate >= 0
  519        * @param y the Y coordinate >= 0
  520        * @param alloc the rectangle
  521        * @return true if the point is after the specified range
  522        */
  523       protected abstract boolean isAfter(int x, int y, Rectangle alloc);
  524   
  525       /**
  526        * Fetches the child view at the given coordinates.
  527        *
  528        * @param x the X coordinate >= 0
  529        * @param y the Y coordinate >= 0
  530        * @param alloc the parent's allocation on entry, which should
  531        *   be changed to the child's allocation on exit
  532        * @return the child view
  533        */
  534       protected abstract View getViewAtPoint(int x, int y, Rectangle alloc);
  535   
  536       /**
  537        * Returns the allocation for a given child.
  538        *
  539        * @param index the index of the child, >= 0 && < getViewCount()
  540        * @param a  the allocation to the interior of the box on entry,
  541        *   and the allocation of the child view at the index on exit.
  542        */
  543       protected abstract void childAllocation(int index, Rectangle a);
  544   
  545       /**
  546        * Fetches the child view that represents the given position in
  547        * the model.  This is implemented to fetch the view in the case
  548        * where there is a child view for each child element.
  549        *
  550        * @param pos the position >= 0
  551        * @param a  the allocation to the interior of the box on entry,
  552        *   and the allocation of the view containing the position on exit
  553        * @return  the view representing the given position, or
  554        *   <code>null</code> if there isn't one
  555        */
  556       protected View getViewAtPosition(int pos, Rectangle a) {
  557           int index = getViewIndexAtPosition(pos);
  558           if ((index >= 0) && (index < getViewCount())) {
  559               View v = getView(index);
  560               if (a != null) {
  561                   childAllocation(index, a);
  562               }
  563               return v;
  564           }
  565           return null;
  566       }
  567   
  568       /**
  569        * Fetches the child view index representing the given position in
  570        * the model.  This is implemented to fetch the view in the case
  571        * where there is a child view for each child element.
  572        *
  573        * @param pos the position >= 0
  574        * @return  index of the view representing the given position, or
  575        *   -1 if no view represents that position
  576        */
  577       protected int getViewIndexAtPosition(int pos) {
  578           Element elem = getElement();
  579           return elem.getElementIndex(pos);
  580       }
  581   
  582       /**
  583        * Translates the immutable allocation given to the view
  584        * to a mutable allocation that represents the interior
  585        * allocation (i.e. the bounds of the given allocation
  586        * with the top, left, bottom, and right insets removed.
  587        * It is expected that the returned value would be further
  588        * mutated to represent an allocation to a child view.
  589        * This is implemented to reuse an instance variable so
  590        * it avoids creating excessive Rectangles.  Typically
  591        * the result of calling this method would be fed to
  592        * the <code>childAllocation</code> method.
  593        *
  594        * @param a the allocation given to the view
  595        * @return the allocation that represents the inside of the
  596        *   view after the margins have all been removed; if the
  597        *   given allocation was <code>null</code>,
  598        *   the return value is <code>null</code>
  599        */
  600       protected Rectangle getInsideAllocation(Shape a) {
  601           if (a != null) {
  602               // get the bounds, hopefully without allocating
  603               // a new rectangle.  The Shape argument should
  604               // not be modified... we copy it into the
  605               // child allocation.
  606               Rectangle alloc;
  607               if (a instanceof Rectangle) {
  608                   alloc = (Rectangle) a;
  609               } else {
  610                   alloc = a.getBounds();
  611               }
  612   
  613               childAlloc.setBounds(alloc);
  614               childAlloc.x += getLeftInset();
  615               childAlloc.y += getTopInset();
  616               childAlloc.width -= getLeftInset() + getRightInset();
  617               childAlloc.height -= getTopInset() + getBottomInset();
  618               return childAlloc;
  619           }
  620           return null;
  621       }
  622   
  623       /**
  624        * Sets the insets from the paragraph attributes specified in
  625        * the given attributes.
  626        *
  627        * @param attr the attributes
  628        */
  629       protected void setParagraphInsets(AttributeSet attr) {
  630           // Since version 1.1 doesn't have scaling and assumes
  631           // a pixel is equal to a point, we just cast the point
  632           // sizes to integers.
  633           top = (short) StyleConstants.getSpaceAbove(attr);
  634           left = (short) StyleConstants.getLeftIndent(attr);
  635           bottom = (short) StyleConstants.getSpaceBelow(attr);
  636           right = (short) StyleConstants.getRightIndent(attr);
  637       }
  638   
  639       /**
  640        * Sets the insets for the view.
  641        *
  642        * @param top the top inset >= 0
  643        * @param left the left inset >= 0
  644        * @param bottom the bottom inset >= 0
  645        * @param right the right inset >= 0
  646        */
  647       protected void setInsets(short top, short left, short bottom, short right) {
  648           this.top = top;
  649           this.left = left;
  650           this.right = right;
  651           this.bottom = bottom;
  652       }
  653   
  654       /**
  655        * Gets the left inset.
  656        *
  657        * @return the inset >= 0
  658        */
  659       protected short getLeftInset() {
  660           return left;
  661       }
  662   
  663       /**
  664        * Gets the right inset.
  665        *
  666        * @return the inset >= 0
  667        */
  668       protected short getRightInset() {
  669           return right;
  670       }
  671   
  672       /**
  673        * Gets the top inset.
  674        *
  675        * @return the inset >= 0
  676        */
  677       protected short getTopInset() {
  678           return top;
  679       }
  680   
  681       /**
  682        * Gets the bottom inset.
  683        *
  684        * @return the inset >= 0
  685        */
  686       protected short getBottomInset() {
  687           return bottom;
  688       }
  689   
  690       /**
  691        * Returns the next visual position for the cursor, in either the
  692        * north or south direction.
  693        *
  694        * @param pos the position to convert >= 0
  695        * @param b a bias value of either <code>Position.Bias.Forward</code>
  696        *  or <code>Position.Bias.Backward</code>
  697        * @param a the allocated region to render into
  698        * @param direction the direction from the current position that can
  699        *  be thought of as the arrow keys typically found on a keyboard;
  700        *  this may be one of the following:
  701        *  <ul>
  702        *  <li><code>SwingConstants.NORTH</code>
  703        *  <li><code>SwingConstants.SOUTH</code>
  704        *  </ul>
  705        * @param biasRet an array containing the bias that was checked
  706        * @return the location within the model that best represents the next
  707        *  north or south location
  708        * @exception BadLocationException
  709        * @exception IllegalArgumentException if <code>direction</code> is invalid
  710        * @see #getNextVisualPositionFrom
  711        *
  712        * @return the next position west of the passed in position
  713        */
  714       protected int getNextNorthSouthVisualPositionFrom(int pos, Position.Bias b,
  715                                                         Shape a, int direction,
  716                                                         Position.Bias[] biasRet)
  717                                                   throws BadLocationException {
  718           return Utilities.getNextVisualPositionFrom(
  719                               this, pos, b, a, direction, biasRet);
  720       }
  721   
  722       /**
  723        * Returns the next visual position for the cursor, in either the
  724        * east or west direction.
  725        *
  726       * @param pos the position to convert >= 0
  727        * @param b a bias value of either <code>Position.Bias.Forward</code>
  728        *  or <code>Position.Bias.Backward</code>
  729        * @param a the allocated region to render into
  730        * @param direction the direction from the current position that can
  731        *  be thought of as the arrow keys typically found on a keyboard;
  732        *  this may be one of the following:
  733        *  <ul>
  734        *  <li><code>SwingConstants.WEST</code>
  735        *  <li><code>SwingConstants.EAST</code>
  736        *  </ul>
  737        * @param biasRet an array containing the bias that was checked
  738        * @return the location within the model that best represents the next
  739        *  west or east location
  740        * @exception BadLocationException
  741        * @exception IllegalArgumentException if <code>direction</code> is invalid
  742        * @see #getNextVisualPositionFrom
  743        */
  744       protected int getNextEastWestVisualPositionFrom(int pos, Position.Bias b,
  745                                                       Shape a,
  746                                                       int direction,
  747                                                       Position.Bias[] biasRet)
  748                                                   throws BadLocationException {
  749           return Utilities.getNextVisualPositionFrom(
  750                               this, pos, b, a, direction, biasRet);
  751       }
  752   
  753       /**
  754        * Determines in which direction the next view lays.
  755        * Consider the <code>View</code> at index n. Typically the
  756        * <code>View</code>s are layed out from left to right,
  757        * so that the <code>View</code> to the EAST will be
  758        * at index n + 1, and the <code>View</code> to the WEST
  759        * will be at index n - 1. In certain situations,
  760        * such as with bidirectional text, it is possible
  761        * that the <code>View</code> to EAST is not at index n + 1,
  762        * but rather at index n - 1, or that the <code>View</code>
  763        * to the WEST is not at index n - 1, but index n + 1.
  764        * In this case this method would return true, indicating the
  765        * <code>View</code>s are layed out in descending order.
  766        * <p>
  767        * This unconditionally returns false, subclasses should override this
  768        * method if there is the possibility for laying <code>View</code>s in
  769        * descending order.
  770        *
  771        * @param position position into the model
  772        * @param bias either <code>Position.Bias.Forward</code> or
  773        *          <code>Position.Bias.Backward</code>
  774        * @return false
  775        */
  776       protected boolean flipEastAndWestAtEnds(int position,
  777                                               Position.Bias bias) {
  778           return false;
  779       }
  780   
  781   
  782       // ---- member variables ---------------------------------------------
  783   
  784   
  785       private static View[] ZERO = new View[0];
  786   
  787       private View[] children;
  788       private int nchildren;
  789       private short left;
  790       private short right;
  791       private short top;
  792       private short bottom;
  793       private Rectangle childAlloc;
  794   }

Home » openjdk-7 » javax » swing » text » [javadoc | source]