home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgLangD.iso / VCAFE.3.0A / JFC.bin / ComponentView.java < prev    next >
Encoding:
Java Source  |  1998-06-30  |  5.8 KB  |  191 lines
  1. /*
  2.  * @(#)ComponentView.java    1.18 98/04/09
  3.  * 
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  */
  20. package com.sun.java.swing.text;
  21.  
  22. import java.awt.*;
  23. import com.sun.java.swing.event.*;
  24.  
  25. /**
  26.  * Component decorator that implements the view interface.  The 
  27.  * entire element is used to represent the component.  This acts
  28.  * as a gateway from the display-only View implementations to
  29.  * interactive lightweight components (ie it allows components
  30.  * to be embedded into the View hierarchy.  The parent of the component
  31.  * is the container that is handed out by the associated view 
  32.  * factory.
  33.  *
  34.  * @author Timothy Prinzing
  35.  * @version 1.18 04/09/98
  36.  */
  37. public class ComponentView extends View  {
  38.  
  39.     /**
  40.      * Creates a new ComponentView object.
  41.      *
  42.      * @param elem the element to decorate
  43.      */
  44.     public ComponentView(Element elem) {
  45.     super(elem);
  46.     AttributeSet attr = elem.getAttributes();
  47.     c = StyleConstants.getComponent(attr);
  48.     c.setVisible(false);
  49.     }
  50.  
  51.     // --- View methods ---------------------------------------------
  52.  
  53.     /**
  54.      * Paints a component view.
  55.      * The real paint behavior occurs naturally from the association
  56.      * that the component has with its parent container (the same
  57.      * container hosting this view), so this simply allows us to 
  58.      * position the component properly relative to the view.  Since
  59.      * the coordinate system for the view is simply the parent 
  60.      * containers, positioning the child component is easy.
  61.      *
  62.      * @param g the graphics context
  63.      * @param a the shape
  64.      * @see View#paint
  65.      */
  66.     public void paint(Graphics g, Shape a) {
  67.     c.setBounds(a.getBounds());
  68.     if (! c.isVisible()) {
  69.         c.setVisible(true);
  70.     }
  71.     }
  72.  
  73.     /**
  74.      * Determines the preferred span for this view along an
  75.      * axis.
  76.      *
  77.      * @param axis may be either View.X_AXIS or View.Y_AXIS
  78.      * @returns  the span the view would like to be rendered into >= 0.
  79.      *           Typically the view is told to render into the span
  80.      *           that is returned, although there is no guarantee.  
  81.      *           The parent may choose to resize or break the view.
  82.      * @exception IllegalArgumentException for an invalid axis
  83.      */
  84.     public float getPreferredSpan(int axis) {
  85.     Dimension size = c.getPreferredSize();
  86.     switch (axis) {
  87.     case View.X_AXIS:
  88.         return size.width;
  89.     case View.Y_AXIS:
  90.         return size.height;
  91.     default:
  92.         throw new IllegalArgumentException("Invalid axis: " + axis);
  93.     }
  94.     }
  95.  
  96.     /**
  97.      * Determines the desired alignment for this view along an
  98.      * axis.  This is implemented to give the alignment of the
  99.      * embedded component.
  100.      *
  101.      * @param axis may be either View.X_AXIS or View.Y_AXIS
  102.      * @returns the desired alignment.  This should be a value
  103.      *   between 0.0 and 1.0 where 0 indicates alignment at the
  104.      *   origin and 1.0 indicates alignment to the full span
  105.      *   away from the origin.  An alignment of 0.5 would be the
  106.      *   center of the view.
  107.      */
  108.     public float getAlignment(int axis) {
  109.     switch (axis) {
  110.     case View.X_AXIS:
  111.         return c.getAlignmentX();
  112.     case View.Y_AXIS:
  113.         return c.getAlignmentY();
  114.     default:
  115.         return super.getAlignment(axis);
  116.     }
  117.     }
  118.  
  119.     /**
  120.      * Sets the size of the view.
  121.      *
  122.      * @param width the width >= 0
  123.      * @param height the height >= 0
  124.      */
  125.     public void setSize(float width, float height) {
  126.     c.setSize((int) width, (int) height);
  127.     }
  128.  
  129.     /**
  130.      * Sets the parent for a child view.
  131.      * The parent calls this on the child to tell it who its
  132.      * parent is.  If this is null, the view has been removed
  133.      * and we need to remove the associated component from its
  134.      * parent.
  135.      *
  136.      * @param p the parent
  137.      */
  138.     public void setParent(View p) {
  139.     super.setParent(p);
  140.     if (p == null) {
  141.         Container parent = c.getParent();
  142.         parent.remove(c);
  143.     } else {
  144.         Container parent = getContainer();
  145.         parent.add(c);
  146.     }
  147.     }
  148.  
  149.     /**
  150.      * Provides a mapping from the coordinate space of the model to
  151.      * that of the view.
  152.      *
  153.      * @param pos the position to convert >= 0
  154.      * @param a the allocated region to render into
  155.      * @return the bounding box of the given position is returned
  156.      * @exception BadLocationException  if the given position does not
  157.      *   represent a valid location in the associated document
  158.      * @see View#modelToView
  159.      */
  160.     public Shape modelToView(int pos, Shape a) throws BadLocationException {
  161.     int p0 = getStartOffset();
  162.     int p1 = getEndOffset();
  163.     if ((pos >= p0) && (pos < p1)) {
  164.         Rectangle r = new Rectangle(a.getBounds());
  165.         r.width = 0;
  166.         return r;
  167.     }
  168.     return null;
  169.     }
  170.  
  171.     /**
  172.      * Provides a mapping from the view coordinate space to the logical
  173.      * coordinate space of the model.
  174.      *
  175.      * @param x the X coordinate >= 0
  176.      * @param y the Y coordinate >= 0
  177.      * @param a the allocated region to render into
  178.      * @return the location within the model that best represents
  179.      *    the given point in the view
  180.      * @see View#viewToModel
  181.      */
  182.     public int viewToModel(float x, float y, Shape a) {
  183.     return getStartOffset();
  184.     }
  185.  
  186.     // --- member variables ------------------------------------------------
  187.  
  188.     private Component c;
  189. }
  190.  
  191.