Java/Swing Components/Label

Материал из Java эксперт
Перейти к: навигация, поиск

A JLabel that can be underlined, implements Scrollable

   <source lang="java">
 

/*

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public
   License as published by the Free Software Foundation; either
   version 2 of the license, or (at your option) any later version.
  • /

import javax.swing.*; import java.awt.*; /**

   A JLabel that can be underlined, implements Scrollable,
   may have a tooltip text equal to its text and exposes a few convenience methods
   for setText().

   @author 
   @version $Revision: 1.3 $ $Date: 2003/08/18 07:47:20 $
  • /

public class ExtendedJLabel extends JLabel implements Scrollable {

   private boolean underlined = false;
   private boolean autoTooltip = false;
   /**
       Constructor.
    */
   public ExtendedJLabel() {
   }
   /**
       Constructor.
       @param text the label text.
    */
   public ExtendedJLabel(String text) {
       super(text);
   }
   
   public Dimension getPreferredScrollableViewportSize() {
       return getSize();
   }
   public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction) {
       return getWidth() / 10;
   }
   
   public boolean getScrollableTracksViewportWidth() {
       return false;
   }
   
   public boolean getScrollableTracksViewportHeight() {
       return false;
   }
   
   public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction) {
       return 10;
   }
   
   /**
       Check whether this label is underlined.
       @return underlined or not
    */
   public boolean isUnderlined() {
       return underlined;
   }
   
   /**
       Set whether this label is underlined.
       @param underlined underlined or not
    */
   public void setUnderlined(boolean underlined) {
       this.underlined = underlined;
       repaint();
   }
   
   /**
       Check whether the tooltip text is automatically equal
       to the text of this label or not.
       @return equal or not
    */
   public boolean getAutoTooltip() {
       return autoTooltip;
   }
   /**
       Set whether the tooltip text is automatically equal
       to the text of this label or not.
       @param autoTooltip equal or not
    */
   public void setAutoTooltip(boolean autoTooltip) {
       this.autoTooltip = autoTooltip;
       setToolTipText(getText());
   }
   
   public void setText(String text) {
       super.setText(text);
       if (autoTooltip) {
           setToolTipText(text);
       }
   }
   
   /**
       Convenience method for calling setText() with a short.
       @param number the short
    */
   public void setText(short number) {
       setText(String.valueOf(number));
   }
   /**
       Convenience method for calling setText() with a int.
       @param number the int
    */
   public void setText(int number) {
       setText(String.valueOf(number));
   }
   /**
       Convenience method for calling setText() with a double.
       @param number the double
    */
   public void setText(double number) {
       setText(String.valueOf(number));
   }
   /**
       Convenience method for calling setText() with a float.
       @param number the float
    */
   public void setText(float number) {
       setText(String.valueOf(number));
   }
   /**
       Convenience method for calling setText() with a long.
       @param number the long
    */
   public void setText(long number) {
       setText(String.valueOf(number));
   }
   public void paint(Graphics g) {
       super.paint(g);
       
       if (underlined) {
           Insets i = getInsets();
           FontMetrics fm = g.getFontMetrics();
           Rectangle textRect = new Rectangle();
           Rectangle viewRect = new Rectangle(i.left, i.top, getWidth() - (i.right + i.left), getHeight() - (i.bottom + i.top) );
           SwingUtilities.layoutCompoundLabel(
                               this,
                               fm,
                               getText(),
                               getIcon(),
                               getVerticalAlignment(),
                               getHorizontalAlignment(),
                               getVerticalTextPosition(),
                               getHorizontalTextPosition(),
                               viewRect,
                               new Rectangle(),
                               textRect,
                               getText() == null ? 0 : ((Integer)UIManager.get("Button.textIconGap")).intValue()
                         );
           int offset = 2;
           if (UIManager.getLookAndFeel().isNativeLookAndFeel() && System.getProperty("os.name").startsWith("Windows")) {
               offset = 1;
           }
           g.fillRect(textRect.x + ((Integer)UIManager.get("Button.textShiftOffset")).intValue() ,
                      textRect.y + fm.getAscent() + ((Integer)UIManager.get("Button.textShiftOffset")).intValue() + offset,
                      textRect.width,
                      1);
       }
   }

}


 </source>
   
  
 
  



Bevel Text

   <source lang="java">
 

import java.awt.Color; import java.awt.Dimension; import java.awt.Font; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Insets; import java.awt.Rectangle; import java.awt.RenderingHints; import java.awt.font.FontRenderContext; import java.awt.geom.Rectangle2D; import javax.swing.JComponent; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.SwingConstants; import javax.swing.UIManager; import javax.swing.border.Border; import javax.swing.plaf.ColorUIResource; import javax.swing.plaf.FontUIResource; public class jexpBevelText extends JComponent implements SwingConstants {

 RenderingLabel leftShadeLabel = new RenderingLabel();
 RenderingLabel contentLabel = new RenderingLabel();
 RenderingLabel rightShadeLabel = new RenderingLabel();
 boolean raisedBevel= true;
 int depthX = 1;
 int depthY = 1;
 RenderingHints renderingHints;
 String text  = "jexp";
 Color foregroundColor;
 Color defaultForeground = new Color(132, 132, 204);
 Font font = new FontUIResource(Font.decode("Dialog-Plain-28"));;
 public jexpBevelText() {
   setLayout(null);
   add(contentLabel);
   add(leftShadeLabel);
   add(rightShadeLabel);
   reSize();
   setToolTipText(getToolTipText());
   setFont(font);
   setBackground(getBackground());
   setForeground(getForeground());
   setText(getText());
   setSize(getPreferredSize());
   setEnabled(isEnabled());
   setOpaque(isOpaque());
   setHorizontalAlignment(0);
   renderingHints = new RenderingHints(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
   renderingHints.put(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON);
 }
 public jexpBevelText(String s) {
   this();
   setText(s);
   setSize(getPreferredSize());
 }
 public void setToolTipText(String s) {
   super.setToolTipText(s);
   leftShadeLabel.setToolTipText(s);
   contentLabel.setToolTipText(s);
   rightShadeLabel.setToolTipText(s);
 }
 public void updateUI() {
   super.updateUI();
   leftShadeLabel.updateUI();
   contentLabel.updateUI();
   rightShadeLabel.updateUI();
   setBackground(getBackground());
   setForeground(getForeground());
   setFont(font);
 }
 public void setRaisedBevel(boolean flag) {
   raisedBevel = flag;
   setForeground(getForeground());
 }
 public boolean isRaisedBevel() {
   return raisedBevel;
 }
 public void setDepthX(int depth) {
   depthX = depth;
   setSize(getSize());
 }
 public int getDepthX() {
   return depthX;
 }
 public void setDepthY(int depth) {
   depthY = depth;
   setSize(getSize());
 }
 public int getDepthY() {
   return depthY;
 }
 public Color getBackground() {
   return super.getBackground();
 }
 public void setBackground(Color newColor) {
   Color backgroundColor = newColor;
   if (backgroundColor == null || (backgroundColor instanceof ColorUIResource))
     backgroundColor = UIManager.getColor("control");
   super.setBackground(backgroundColor);
 }
 public Color getForeground() {
   return foregroundColor;
 }
 public void setForeground(Color newColor) {
   foregroundColor = newColor;
   if (foregroundColor == null || (foregroundColor instanceof ColorUIResource)) {
     foregroundColor = new ColorUIResource(defaultForeground);
     newColor = defaultForeground;
   }
   contentLabel.setForeground(newColor);
   if (raisedBevel) {
     leftShadeLabel.setForeground(Color.white);
     rightShadeLabel.setForeground(newColor.darker().darker().darker());
   } else {
     leftShadeLabel.setForeground(newColor.darker().darker().darker());
     rightShadeLabel.setForeground(Color.white);
   }
 }
 public Font getFont() {
   if (font == null || (font instanceof FontUIResource))
     font = new FontUIResource(Font.decode("Dialog-Plain-28"));
   return font;
 }
 public void setFont(Font newFont) {
   font = newFont;
   leftShadeLabel.setFont(font);
   contentLabel.setFont(font);
   rightShadeLabel.setFont(font);
 }
 public void setEnabled(boolean enabled) {
   super.setEnabled(enabled);
   leftShadeLabel.setEnabled(enabled);
   contentLabel.setEnabled(enabled);
   rightShadeLabel.setEnabled(enabled);
 }
 public void setOpaque(boolean flag) {
   super.setOpaque(flag);
   leftShadeLabel.setOpaque(false);
   contentLabel.setOpaque(false);
   rightShadeLabel.setOpaque(false);
   updateUI();
 }
 public void setVisible(boolean isVisible) {
   super.setVisible(isVisible);
   leftShadeLabel.setVisible(isVisible);
   contentLabel.setVisible(isVisible);
   rightShadeLabel.setVisible(isVisible);
 }
 public void setText(String s) {
   text = s;
   leftShadeLabel.setText(s);
   contentLabel.setText(s);
   rightShadeLabel.setText(s);
 }
 public String getText() {
   return text;
 }
 public Dimension getPreferredSize() {
   JLabel jlabel = new JLabel();
   jlabel.setFont(getFont());
   jlabel.setBorder(getBorder());
   if (renderingHints == null) {
     jlabel.setText(getText() + "m");
     Dimension dimension = jlabel.getPreferredSize();
     dimension.width += depthX * 2;
     dimension.height += depthY * 2;
     return dimension;
   } else {
     Dimension dimension1 = jlabel.getPreferredSize();
     dimension1.width += depthX * 2;
     dimension1.height += depthY * 2;
     boolean flag = true;
     boolean flag1 = true;
     FontRenderContext fontrendercontext = new FontRenderContext(null, flag, flag1);
     dimension1.width += getFont().getStringBounds(getText() + "m", fontrendercontext).getWidth();
     Rectangle2D rectangle2d = getFont().getMaxCharBounds(fontrendercontext);
     dimension1.height += rectangle2d.getHeight();
     return dimension1;
   }
 }
 public Dimension getMinimumSize() {
   return getPreferredSize();
 }
 public void setBorder(Border border) {
   super.setBorder(border);
   setSize(getSize());
 }
 private void reSize() {
   Insets insets = new Insets(0, 0, 0, 0);
   Border border = getBorder();
   if (border != null)
     insets = border.getBorderInsets(this);
   leftShadeLabel.setLocation(insets.top, insets.left);
   contentLabel.setLocation(insets.top + depthX, insets.left + depthY);
   rightShadeLabel.setLocation(insets.top + depthX * 2, insets.left + depthY * 2);
 }
 public void setBounds(int x, int y, int width, int height) {
   super.setBounds(x, y, width, height);
   reSize();
   Insets insets = new Insets(0, 0, 0, 0);
   Border border = getBorder();
   if (border != null)
     insets = border.getBorderInsets(this);
   int w = width - depthX * 2 - insets.left - insets.right;
   int h = height - depthY * 2 - insets.top - insets.bottom;
   leftShadeLabel.setSize(w, h);
   contentLabel.setSize(w, h);
   rightShadeLabel.setSize(w, h);
 }
 public void setBounds(Rectangle rectangle) {
   setBounds(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
 }
 public void setSize(int w, int h) {
   super.setSize(w, h);
   reSize();
   Insets insets = new Insets(0, 0, 0, 0);
   Border border = getBorder();
   if (border != null)
     insets = border.getBorderInsets(this);
   int width = w - depthX * 2 - insets.left - insets.right;
   int height = h - depthY * 2 - insets.top - insets.bottom;
   leftShadeLabel.setSize(width, height);
   contentLabel.setSize(width, height);
   rightShadeLabel.setSize(width, height);
 }
 public void setSize(Dimension dimension) {
   setSize(dimension.width, dimension.height);
 }
 public final void paintInterface(Graphics g1) {
   if (isOpaque()) {
     g1.setColor(getBackground());
     g1.fillRect(0, 0, getWidth(), getHeight());
   }
   super.paint(g1);
 }
 public void setHorizontalAlignment(int i) {
   leftShadeLabel.setHorizontalAlignment(i);
   contentLabel.setHorizontalAlignment(i);
   rightShadeLabel.setHorizontalAlignment(i);
 }
 public int getHorizontalAlignment() {
   return leftShadeLabel.getHorizontalAlignment();
 }
 public void setVerticalAlignment(int i) {
   leftShadeLabel.setVerticalAlignment(i);
   contentLabel.setVerticalAlignment(i);
   rightShadeLabel.setVerticalAlignment(i);
 }
 public int getVerticalAlignment() {
   return leftShadeLabel.getVerticalAlignment();
 }
 private void setHorizontalTextPosition(int i) {
   leftShadeLabel.setHorizontalTextPosition(i);
   contentLabel.setHorizontalTextPosition(i);
   rightShadeLabel.setHorizontalTextPosition(i);
 }
 private int getHorizontalTextPosition() {
   return leftShadeLabel.getHorizontalTextPosition();
 }
 private void setVerticalTextPosition(int i) {
   if (rightShadeLabel != null) {
     leftShadeLabel.setVerticalTextPosition(i);
     contentLabel.setVerticalTextPosition(i);
     rightShadeLabel.setVerticalTextPosition(i);
   }
 }
 class RenderingLabel extends JLabel {
   public void paint(Graphics g1) {
     if (renderingHints != null && (g1 instanceof Graphics2D)) {
       Graphics2D graphics2d = (Graphics2D) g1;
       graphics2d.setRenderingHints(renderingHints);
     }
     super.paint(g1);
   }
 }
 private int getVerticalTextPosition() {
   return leftShadeLabel.getVerticalTextPosition();
 }
 public static void main(String[] args) {
   JFrame f = new JFrame();
   jexpBevelText j = new jexpBevelText();
   j.setForeground(Color.RED);
   f.getContentPane().add(j, "Center");
   f.setSize(400, 600);
   f.setVisible(true);
 }

}



 </source>
   
  
 
  



Gradient Label

   <source lang="java">

/*

*  soapUI, copyright (C) 2004-2009 eviware.ru 
*
*  soapUI is free software; you can redistribute it and/or modify it under the 
*  terms of version 2.1 of the GNU Lesser General Public License as published by 
*  the Free Software Foundation.
*
*  soapUI is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without 
*  even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
*  See the GNU Lesser General Public License for more details at gnu.org.
*/

import java.awt.Color; import java.awt.GradientPaint; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Paint; import javax.swing.JLabel; public class GradientLabel extends JLabel {

 // ------------------------------ FIELDS ------------------------------
 private Color start;
 private Color end;
 // --------------------------- CONSTRUCTORS ---------------------------
 public GradientLabel( String text )
 {
   super( text );
   start = Color.LIGHT_GRAY;
   end = getBackground();
 }
 public GradientLabel( String text, Color start, Color end )
 {
   super( text );
   this.start = start;
   this.end = end;
 }
 // -------------------------- OTHER METHODS --------------------------
 public void paint( Graphics g )
 {
   int width = getWidth();
   int height = getHeight();
   // Create the gradient paint
   GradientPaint paint = new GradientPaint( 0, 0, start, width, height, end, true );
   // we need to cast to Graphics2D for this operation
   Graphics2D g2d = ( Graphics2D )g;
   // save the old paint
   Paint oldPaint = g2d.getPaint();
   // set the paint to use for this operation
   g2d.setPaint( paint );
   // fill the background using the paint
   g2d.fillRect( 0, 0, width, height );
   // restore the original paint
   g2d.setPaint( oldPaint );
   super.paint( g );
 }

}

 </source>
   
  
 
  



Hyperlink Label

   <source lang="java">

import java.awt.Color; import java.awt.Cursor; import java.awt.Graphics; import java.awt.Insets; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent; import javax.swing.JLabel; public class JHyperlinkLabel extends JLabel {

 private Color underlineColor = null;
 public JHyperlinkLabel(String label) {
   super(label);
   setForeground(Color.BLUE.darker());
   setCursor(new Cursor(Cursor.HAND_CURSOR));
   addMouseListener(new HyperlinkLabelMouseAdapter());
 }
 @Override
 protected void paintComponent(Graphics g) {
   super.paintComponent(g);
   g.setColor(underlineColor == null ? getForeground() : underlineColor);
   Insets insets = getInsets();
   int left = insets.left;
   if (getIcon() != null)
     left += getIcon().getIconWidth() + getIconTextGap();
   g.drawLine(left, getHeight() - 1 - insets.bottom, (int) getPreferredSize().getWidth()
       - insets.right, getHeight() - 1 - insets.bottom);
 }
 public class HyperlinkLabelMouseAdapter extends MouseAdapter {
   @Override
   public void mouseClicked(MouseEvent e) {
     System.out.println(getText());
   }
 }
 public Color getUnderlineColor() {
   return underlineColor;
 }
 public void setUnderlineColor(Color underlineColor) {
   this.underlineColor = underlineColor;
 }

}

 </source>
   
  
 
  



Label 3D

   <source lang="java">
 

/* Swing Hacks Tips and Tools for Killer GUIs By Joshua Marinacci, Chris Adamson First Edition June 2005 Series: Hacks ISBN: 0-596-00907-0 Pages: 542 website: http://www.oreilly.ru/catalog/swinghks/

  • /

import java.awt.Color; import java.awt.Dimension; import java.awt.FontMetrics; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.RenderingHints; import java.awt.font.LineMetrics; import javax.swing.JFrame; import javax.swing.JLabel; public class RichJLabel extends JLabel {

 private int tracking;
 public RichJLabel(String text, int tracking) {
   super(text);
   this.tracking = tracking;
 }
 private int left_x, left_y, right_x, right_y;
 private Color left_color, right_color;
 public void setLeftShadow(int x, int y, Color color) {
   left_x = x;
   left_y = y;
   left_color = color;
 }
 public void setRightShadow(int x, int y, Color color) {
   right_x = x;
   right_y = y;
   right_color = color;
 }
 public Dimension getPreferredSize() {
   String text = getText();
   FontMetrics fm = this.getFontMetrics(getFont());
   int w = fm.stringWidth(text);
   w += (text.length() - 1) * tracking;
   w += left_x + right_x;
   int h = fm.getHeight();
   h += left_y + right_y;
   return new Dimension(w, h);
 }
 public void paintComponent(Graphics g) {
   ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
       RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
   char[] chars = getText().toCharArray();
   FontMetrics fm = this.getFontMetrics(getFont());
   int h = fm.getAscent();
   LineMetrics lm = fm.getLineMetrics(getText(), g);
   g.setFont(getFont());
   int x = 0;
   for (int i = 0; i < chars.length; i++) {
     char ch = chars[i];
     int w = fm.charWidth(ch) + tracking;
     g.setColor(left_color);
     g.drawString("" + chars[i], x - left_x, h - left_y);
     g.setColor(right_color);
     g.drawString("" + chars[i], x + right_x, h + right_y);
     g.setColor(getForeground());
     g.drawString("" + chars[i], x, h);
     x += w;
   }
 }
 public static void main(String[] args) {
   RichJLabel label = new RichJLabel("www.jexp.ru", 0);
   label.setLeftShadow(1, 1, Color.white);
   label.setRightShadow(1, 1, Color.white);
   label.setForeground(Color.blue);
   label.setFont(label.getFont().deriveFont(140f));
   label.setLeftShadow(5,5,Color.white);
   label.setRightShadow(-3,-3, new Color(0xccccff));
   label.setForeground(new Color(0x8888ff));
   label.setFont(label.getFont().deriveFont(140f));
   
   
   JFrame frame = new JFrame("RichJLabel hack");
   frame.getContentPane().add(label);
   frame.pack();
   frame.setVisible(true);
 }
 public static void p(String str) {
   System.out.println(str);
 }

}


 </source>
   
  
 
  



Label with large font and ANTIALIAS paint

   <source lang="java">
 

/* Swing Hacks Tips and Tools for Killer GUIs By Joshua Marinacci, Chris Adamson First Edition June 2005 Series: Hacks ISBN: 0-596-00907-0 Pages: 542 website: http://www.oreilly.ru/catalog/swinghks/

  • /

import java.awt.Color; import java.awt.Dimension; import java.awt.FontMetrics; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.RenderingHints; import java.awt.font.LineMetrics; import javax.swing.JFrame; import javax.swing.JLabel; public class RichJLabel extends JLabel {

 private int tracking;
 public RichJLabel(String text, int tracking) {
   super(text);
   this.tracking = tracking;
 }
 private int left_x, left_y, right_x, right_y;
 private Color left_color, right_color;
 public void setLeftShadow(int x, int y, Color color) {
   left_x = x;
   left_y = y;
   left_color = color;
 }
 public void setRightShadow(int x, int y, Color color) {
   right_x = x;
   right_y = y;
   right_color = color;
 }
 public Dimension getPreferredSize() {
   String text = getText();
   FontMetrics fm = this.getFontMetrics(getFont());
   int w = fm.stringWidth(text);
   w += (text.length() - 1) * tracking;
   w += left_x + right_x;
   int h = fm.getHeight();
   h += left_y + right_y;
   return new Dimension(w, h);
 }
 public void paintComponent(Graphics g) {
   ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
       RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
   char[] chars = getText().toCharArray();
   FontMetrics fm = this.getFontMetrics(getFont());
   int h = fm.getAscent();
   LineMetrics lm = fm.getLineMetrics(getText(), g);
   g.setFont(getFont());
   int x = 0;
   for (int i = 0; i < chars.length; i++) {
     char ch = chars[i];
     int w = fm.charWidth(ch) + tracking;
     g.setColor(left_color);
     g.drawString("" + chars[i], x - left_x, h - left_y);
     g.setColor(right_color);
     g.drawString("" + chars[i], x + right_x, h + right_y);
     g.setColor(getForeground());
     g.drawString("" + chars[i], x, h);
     x += w;
   }
 }
 public static void main(String[] args) {
   RichJLabel label = new RichJLabel("www.jexp.ru", 0);
   label.setLeftShadow(1, 1, Color.white);
   label.setRightShadow(1, 1, Color.white);
   label.setForeground(Color.blue);
   label.setFont(label.getFont().deriveFont(140f));
   JFrame frame = new JFrame("RichJLabel hack");
   frame.getContentPane().add(label);
   frame.pack();
   frame.setVisible(true);
 }
 public static void p(String str) {
   System.out.println(str);
 }

}


 </source>
   
  
 
  



Link Label

   <source lang="java">
 

/**

* The utillib library.
* More information is available at http://www.jinchess.ru/.
* Copyright (C) 2002 Alexander Maryanovsky.
* All rights reserved.
*
* The utillib library is free software; you can redistribute
* it and/or modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* The utillib library is distributed in the hope that it will
* be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser
* General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with utillib library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

import java.awt.Cursor; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.MouseEvent; import javax.swing.JLabel;

/**

* An extension of JLabel which looks like a link and responds appropriately
* when clicked. Note that this class will only work with Swing 1.1.1 and later.
* Note that because of the way this class is implemented, getText() will not
* return correct values, user getNormalText instead.
*/

public class LinkLabel extends JLabel{

 /**
  * The normal text set by the user.
  */
 private String text;


 /**
  * Creates a new LinkLabel with the given text.
  */
 public LinkLabel(String text){
   super(text);
   setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
   enableEvents(MouseEvent.MOUSE_EVENT_MASK);
 }


 /**
  * Sets the text of the label.
  */
 public void setText(String text){
   super.setText("<html>"+text+"</html>"); //$NON-NLS-1$ //$NON-NLS-2$
   this.text = text;
 }


 /**
  * Returns the text set by the user.
  */
 public String getNormalText(){
   return text;
 }


 /**
  * Processes mouse events and responds to clicks.
  */
 protected void processMouseEvent(MouseEvent evt){
   super.processMouseEvent(evt);
   if (evt.getID() == MouseEvent.MOUSE_CLICKED)
     fireActionPerformed(new ActionEvent(this, ActionEvent.ACTION_PERFORMED, getNormalText()));
 }


 /**
  * Adds an ActionListener to the list of listeners receiving notifications
  * when the label is clicked.
  */
 public void addActionListener(ActionListener listener){
   listenerList.add(ActionListener.class, listener);
 }


 /**
  * Removes the given ActionListener from the list of listeners receiving
  * notifications when the label is clicked.
  */
 public void removeActionListener(ActionListener listener){
   listenerList.remove(ActionListener.class, listener);
 }


 /**
  * Fires an ActionEvent to all interested listeners.
  */
 protected void fireActionPerformed(ActionEvent evt){
   Object [] listeners = listenerList.getListenerList();
   for (int i = 0; i < listeners.length; i += 2){
     if (listeners[i] == ActionListener.class){
       ActionListener listener = (ActionListener)listeners[i+1];
       listener.actionPerformed(evt);
     }
   }
 }

}


 </source>
   
  
 
  



MultiLine Label

   <source lang="java">
 

// This example is from the book _Java in a Nutshell_ by David Flanagan. //Written by David Flanagan. Copyright (c) 1996 O"Reilly & Associates. //You may study, use, modify, and distribute this example for any purpose. //This example is provided WITHOUT WARRANTY either expressed or implied. import java.awt.Canvas; import java.awt.Color; import java.awt.Dimension; import java.awt.Font; import java.awt.FontMetrics; import java.awt.Graphics; import java.util.StringTokenizer; public class MultiLineLabel extends Canvas {

 public static final int LEFT = 0; // Alignment constants
 public static final int CENTER = 1;
 public static final int RIGHT = 2;
 protected String[] lines; // The lines of text to display
 protected int num_lines; // The number of lines
 protected int margin_width; // Left and right margins
 protected int margin_height; // Top and bottom margins
 protected int line_height; // Total height of the font
 protected int line_ascent; // Font height above baseline
 protected int[] line_widths; // How wide each line is
 protected int max_width; // The width of the widest line
 protected int alignment = LEFT; // The alignment of the text.
 // This method breaks a specified label up into an array of lines.
 // It uses the StringTokenizer utility class.
 protected void newLabel(String label) {
   StringTokenizer t = new StringTokenizer(label, "\n");
   num_lines = t.countTokens();
   lines = new String[num_lines];
   line_widths = new int[num_lines];
   for (int i = 0; i < num_lines; i++)
     lines[i] = t.nextToken();
 }
 // This method figures out how the font is, and how wide each
 // line of the label is, and how wide the widest line is.
 protected void measure() {
   FontMetrics fm = getFontMetrics(getFont());
   // If we don"t have font metrics yet, just return.
   if (fm == null)
     return;
   line_height = fm.getHeight();
   line_ascent = fm.getAscent();
   max_width = 0;
   for (int i = 0; i < num_lines; i++) {
     line_widths[i] = fm.stringWidth(lines[i]);
     if (line_widths[i] > max_width)
       max_width = line_widths[i];
   }
 }
 // Here are four versions of the cosntrutor.
 // Break the label up into separate lines, and save the other info.
 public MultiLineLabel(String label, int margin_width, int margin_height,
     int alignment) {
   newLabel(label);
   this.margin_width = margin_width;
   this.margin_height = margin_height;
   this.alignment = alignment;
 }
 public MultiLineLabel(String label, int margin_width, int margin_height) {
   this(label, margin_width, margin_height, LEFT);
 }
 public MultiLineLabel(String label, int alignment) {
   this(label, 10, 10, alignment);
 }
 public MultiLineLabel(String label) {
   this(label, 10, 10, LEFT);
 }
 // Methods to set the various attributes of the component
 public void setLabel(String label) {
   newLabel(label);
   measure();
   repaint();
 }
 public void setFont(Font f) {
   super.setFont(f);
   measure();
   repaint();
 }
 public void setForeground(Color c) {
   super.setForeground(c);
   repaint();
 }
 public void setAlignment(int a) {
   alignment = a;
   repaint();
 }
 public void setMarginWidth(int mw) {
   margin_width = mw;
   repaint();
 }
 public void setMarginHeight(int mh) {
   margin_height = mh;
   repaint();
 }
 public int getAlignment() {
   return alignment;
 }
 public int getMarginWidth() {
   return margin_width;
 }
 public int getMarginHeight() {
   return margin_height;
 }
 // This method is invoked after our Canvas is first created
 // but before it can actually be displayed. After we"ve
 // invoked our superclass"s addNotify() method, we have font
 // metrics and can successfully call measure() to figure out
 // how big the label is.
 public void addNotify() {
   super.addNotify();
   measure();
 }
 // This method is called by a layout manager when it wants to
 // know how big we"d like to be.
 public Dimension getPreferredSize() {
   return new Dimension(max_width + 2 * margin_width, num_lines
       * line_height + 2 * margin_height);
 }
 // This method is called when the layout manager wants to know
 // the bare minimum amount of space we need to get by.
 public Dimension getMinimumSize() {
   return new Dimension(max_width, num_lines * line_height);
 }
 // This method draws the label (applets use the same method).
 // Note that it handles the margins and the alignment, but that
 // it doesn"t have to worry about the color or font--the superclass
 // takes care of setting those in the Graphics object we"re passed.
 public void paint(Graphics g) {
   int x, y;
   Dimension d = getSize();
   y = line_ascent + (d.height - num_lines * line_height) / 2;
   for (int i = 0; i < num_lines; i++, y += line_height) {
     switch (alignment) {
     case LEFT:
       x = margin_width;
       break;
     case CENTER:
     default:
       x = (d.width - line_widths[i]) / 2;
       break;
     case RIGHT:
       x = d.width - margin_width - line_widths[i];
       break;
     }
     g.drawString(lines[i], x, y);
   }
 }

}


 </source>
   
  
 
  



Multi Line Label extends JComponent

   <source lang="java">
 

/*

* IzPack - Copyright 2001-2008 Julien Ponge, All Rights Reserved.
* 
* http://izpack.org/
* http://izpack.codehaus.org/
* 
* Copyright 1997,2002 Elmar Grom
* 
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* 
*     http://www.apache.org/licenses/LICENSE-2.0
*     
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

import javax.swing.*; import java.awt.*; import java.util.Vector; /*---------------------------------------------------------------------------*/ /**

* 
* MultiLineLabel may be used in place of javax.swing.JLabel.
*
* This class implements a component that is capable of displaying multiple lines of text. Line * breaks are inserted automatically whenever a line of text extends beyond the predefined maximum * line length. Line breaks will only be inserted between words, except where a single word is * longer than the maximum line length. Line breaks may be forced at any location in the text by * inserting a newline (\n). White space that is not valuable (i.e. is placed at the beginning of a * new line or at the very beginning or end of the text) is removed.
*
* Note: you can set the maximum width of the label either through one of the constructors * or you can call setMaxWidth() explicitly. If this is not set, * MultiLineLabel will derive its width from the parent component. * * @author Elmar Grom * @version 1.0 / 04-13-02 */

/*---------------------------------------------------------------------------*

* Reviving some old code here that was written before there was swing.
* The original was written to work with awt. I had to do some masaging to
* make it a JComponent and I hope it behaves like a reasonably good mannered
* swing component.
*---------------------------------------------------------------------------*/

public class MultiLineLabel extends JComponent {

   /**
    *
    */
   private static final long serialVersionUID = 4051045255031894837L;
   public static final int LEFT = 0; // alignment constants
   public static final int CENTER = 1;
   public static final int RIGHT = 2;
   public static final int DEFAULT_MARGIN = 10;
   public static final int DEFAULT_ALIGN = LEFT;
   public static final int LEAST_ALLOWED = 200; // default setting for
   // maxAllowed
   private static final int FOUND = 0; // constants for string search.
   private static final int NOT_FOUND = 1;
   private static final int NOT_DONE = 0;
   private static final int DONE = 1;
   private static final char[] WHITE_SPACE = {" ", "\n", "\t"};
   private static final char[] SPACES = {" ", "\t"};
   private static final char NEW_LINE = "\n";
   protected Vector<String> line = new Vector<String>();// text lines to display
   protected String labelText; // text lines to display
   protected int numLines; // the number of lines
   protected int marginHeight; // top and bottom margins
   protected int marginWidth; // left and right margins
   protected int lineHeight; // total height of the font
   protected int lineAscent; // font height above the baseline
   protected int lineDescent; // font hight below the baseline
   protected int[] lineWidth; // width of each line
   protected int maxWidth; // width of the widest line
   private int maxAllowed = LEAST_ALLOWED; // max width allowed to use
   private boolean maxAllowedSet = false; // signals if the max allowed width
   // has been explicitly set
   protected int alignment = LEFT; // default text alignment
   /*-------------------------------------------------------------------*/
   /**
    * Constructor
    *
    * @param text       the text to be displayed
    * @param horMargin  the horizontal margin for the label
    * @param vertMargin the vertical margin for the label
    * @param maxWidth   the maximum allowed width of the text
    * @param justify    the text alignment for the label
    */
   /*-------------------------------------------------------------------*
    * <detailed description / implementation details if applicable>
    *-------------------------------------------------------------------*/
   public MultiLineLabel(String text, int horMargin, int vertMargin, int maxWidth, int justify)
   {
       this.labelText = text;
       this.marginWidth = horMargin;
       this.marginHeight = vertMargin;
       this.maxAllowed = maxWidth;
       this.maxAllowedSet = true;
       this.alignment = justify;
   }
   /*-------------------------------------------------------------------*/
   /**
    * Constructor using default max-width and alignment.
    *
    * @param label        the text to be displayed
    * @param marginWidth  the horizontal margin for the label
    * @param marginHeight the vertical margin for the label
    */
   /*-------------------------------------------------------------------*
    * <detailed description / implementation details if applicable>
    *-------------------------------------------------------------------*/
   public MultiLineLabel(String label, int marginWidth, int marginHeight)
   {
       this.labelText = label;
       this.marginWidth = marginWidth;
       this.marginHeight = marginHeight;
   }
   /*-------------------------------------------------------------------*/
   /**
    * Constructor using default max-width, and margin.
    *
    * @param label     the text to be displayed
    * @param alignment the text alignment for the label
    */
   /*-------------------------------------------------------------------*
    * <detailed description / implementation details if applicable>
    *-------------------------------------------------------------------*/
   public MultiLineLabel(String label, int alignment)
   {
       this.labelText = label;
       this.alignment = alignment;
   }
   /*-------------------------------------------------------------------*/
   /**
    * Constructor using default max-width, alignment, and margin.
    *
    * @param label the text to be displayed
    */
   /*-------------------------------------------------------------------*
    * <detailed description / implementation details if applicable>
    *-------------------------------------------------------------------*/
   public MultiLineLabel(String label)
   {
       this.labelText = label;
   }
   /*-------------------------------------------------------------------*/
   /**
    * This method searches the target string for occurences of any of the characters in the source
    * string. The return value is the position of the first hit. Based on the mode parameter the
    * hit position is either the position where any of the source characters first was found or the
    * first position where none of the source characters where found.
    *
    * @param target the text to be searched
    * @param start  the start position for the search
    * @param source the list of characters to be searched for
    * @param mode   the search mode FOUND = reports first found NOT_FOUND = reports first not found
    * @return position of the first occurence
    */
   /*-------------------------------------------------------------------*
    * <detailed description / implementation details if applicable>
    *-------------------------------------------------------------------*/
   int getPosition(String target, int start, char[] source, int mode)
   {
       int status;
       int position;
       int scan;
       int targetEnd;
       int sourceLength;
       char temp;
       targetEnd = (target.length() - 1);
       sourceLength = source.length;
       position = start;
       if (mode == FOUND)
       {
           status = NOT_DONE;
           while (status != DONE)
           {
               position++;
               if (!(position < targetEnd)) // end of string reached, the
               // next
               { // statement would cause a runtime error
                   return (targetEnd);
               }
               temp = target.charAt(position);
               for (scan = 0; scan < sourceLength; scan++) // walk through the
               // source
               { // string and compare each char
                   if (source[scan] == temp)
                   {
                       status = DONE;
                   }
               }
           }
           return (position);
       }
       else if (mode == NOT_FOUND)
       {
           status = NOT_DONE;
           while (status != DONE)
           {
               position++;
               if (!(position < targetEnd)) // end of string reached, the
               // next
               { // statement would cause a runtime error
                   return (targetEnd);
               }
               temp = target.charAt(position);
               status = DONE;
               for (scan = 0; scan < sourceLength; scan++) // walk through the
               // source
               { // string and compare each char
                   if (source[scan] == temp)
                   {
                       status = NOT_DONE;
                   }
               }
           }
           return (position);
       }
       return (0);
   }
   /*-------------------------------------------------------------------*/
   /**
    * This method scans the input string until the max allowed width is reached. The return value
    * indicates the position just before this happens.
    *
    * @param word word to break
    * @return position character position just before the string is too long
    */
   /*-------------------------------------------------------------------*
    * <detailed description / implementation details if applicable>
    *-------------------------------------------------------------------*/
   int breakWord(String word, FontMetrics fm)
   {
       int width;
       int currentPos;
       int endPos;
       width = 0;
       currentPos = 0;
       endPos = word.length() - 1;
       // make sure we don"t end up with a negative position
       if (endPos <= 0)
       {
           return (currentPos);
       }
       // seek the position where the word first is longer than allowed
       while ((width < maxAllowed) && (currentPos < endPos))
       {
           currentPos++;
           width = fm.stringWidth(labelText.substring(0, currentPos));
       }
       // adjust to get the chatacter just before (this should make it a bit
       // shorter than allowed!)
       if (currentPos != endPos)
       {
           currentPos--;
       }
       return (currentPos);
   }
   /*-------------------------------------------------------------------*/
   /**
    * This method breaks the label text up into multiple lines of text. Line breaks are established
    * based on the maximum available space. A new line is started whenever a line break is
    * encountered, even if the permissible length is not yet reached. Words are broken only if a
    * single word happens to be longer than one line.
    */
   /*-------------------------------------------------------------------*/
   private void divideLabel()
   {
       int width;
       int startPos;
       int currentPos;
       int lastPos;
       int endPos;
       line.clear();
       FontMetrics fm = this.getFontMetrics(this.getFont());
       startPos = 0;
       currentPos = startPos;
       lastPos = currentPos;
       endPos = (labelText.length() - 1);
       while (currentPos < endPos)
       {
           width = 0;
           // ----------------------------------------------------------------
           // find the first substring that occupies more than the granted
           // space.
           // Break at the end of the string or a line break
           // ----------------------------------------------------------------
           while ((width < maxAllowed) && (currentPos < endPos)
                   && (labelText.charAt(currentPos) != NEW_LINE))
           {
               lastPos = currentPos;
               currentPos = getPosition(labelText, currentPos, WHITE_SPACE, FOUND);
               width = fm.stringWidth(labelText.substring(startPos, currentPos));
           }
           // ----------------------------------------------------------------
           // if we have a line break we want to copy everything up to
           // currentPos
           // ----------------------------------------------------------------
           if (labelText.charAt(currentPos) == NEW_LINE)
           {
               lastPos = currentPos;
           }
           // ----------------------------------------------------------------
           // if we are at the end of the string we want to copy everything up
           // to
           // the last character. Since there seems to be a problem to get the
           // last
           // character if the substring definition ends at the very last
           // character
           // we have to call a different substring function than normal.
           // ----------------------------------------------------------------
           if (currentPos == endPos && width <= maxAllowed)
           {
               lastPos = currentPos;
               String s = labelText.substring(startPos);
               line.addElement(s);
           }
           // ----------------------------------------------------------------
           // in all other cases copy the substring that we have found to fit
           // and
           // add it as a new line of text to the line vector.
           // ----------------------------------------------------------------
           else
           {
               // ------------------------------------------------------------
               // make sure it"s not a single word. If so we must break it at
               // the
               // proper location.
               // ------------------------------------------------------------
               if (lastPos == startPos)
               {
                   lastPos = startPos + breakWord(labelText.substring(startPos, currentPos), fm);
               }
               String s = labelText.substring(startPos, lastPos);
               line.addElement(s);
           }
           // ----------------------------------------------------------------
           // seek for the end of the white space to cut out any unnecessary
           // spaces
           // and tabs and set the new start condition.
           // ----------------------------------------------------------------
           startPos = getPosition(labelText, lastPos, SPACES, NOT_FOUND);
           currentPos = startPos;
       }
       numLines = line.size();
       lineWidth = new int[numLines];
   }
   /*-------------------------------------------------------------------*/
   /**
    * This method finds the font size, each line width and the widest line.
    */
   /*-------------------------------------------------------------------*/
   protected void measure()
   {
       if (!maxAllowedSet)
       {
           maxAllowed = getParent().getSize().width;
       }
       // return if width is too small
       if (maxAllowed < (20))
       {
           return;
       }
       FontMetrics fm = this.getFontMetrics(this.getFont());
       // return if no font metrics available
       if (fm == null)
       {
           return;
       }
       divideLabel();
       this.lineHeight = fm.getHeight();
       this.lineDescent = fm.getDescent();
       this.maxWidth = 0;
       for (int i = 0; i < numLines; i++)
       {
           this.lineWidth[i] = fm.stringWidth(this.line.elementAt(i));
           if (this.lineWidth[i] > this.maxWidth)
           {
               this.maxWidth = this.lineWidth[i];
           }
       }
   }
   /*-------------------------------------------------------------------*/
   /**
    * This method draws the label.
    *
    * @param graphics the device context
    */
   /*-------------------------------------------------------------------*/
   public void paint(Graphics graphics)
   {
       int x;
       int y;
       measure();
       Dimension d = this.getSize();
       y = lineAscent + (d.height - (numLines * lineHeight)) / 2;
       for (int i = 0; i < numLines; i++)
       {
           y += lineHeight;
           switch (alignment)
           {
               case LEFT:
                   x = marginWidth;
                   break;
               case CENTER:
                   x = (d.width - lineWidth[i]) / 2;
                   break;
               case RIGHT:
                   x = d.width - marginWidth - lineWidth[i];
                   break;
               default:
                   x = (d.width - lineWidth[i]) / 2;
           }
           graphics.drawString(line.elementAt(i), x, y);
       }
   }
   /*-------------------------------------------------------------------*/
   /**
    * This method may be used to set the label text
    *
    * @param labelText the text to be displayed
    */
   /*-------------------------------------------------------------------*/
   public void setText(String labelText)
   {
       this.labelText = labelText;
       repaint();
   }
   /*-------------------------------------------------------------------*/
   /**
    * This method may be used to set the font that should be used to draw the label
    *
    * @param font font to be used within the label
    */
   /*-------------------------------------------------------------------*/
   public void setFont(Font font)
   {
       super.setFont(font);
       repaint();
   }
   /*-------------------------------------------------------------------*/
   /**
    * This method may be used to set the color in which the text should be drawn
    *
    * @param color the text color
    */
   /*-------------------------------------------------------------------*/
   public void setColor(Color color)
   {
       super.setForeground(color);
       repaint();
   }
   /*-------------------------------------------------------------------*/
   /**
    * This method may be used to set the text alignment for the label
    *
    * @param alignment the alignment, possible values are LEFT, CENTER, RIGHT
    */
   /*-------------------------------------------------------------------*/
   public void setJustify(int alignment)
   {
       this.alignment = alignment;
       repaint();
   }
   /*-------------------------------------------------------------------*/
   /**
    * This method may be used to set the max allowed line width
    *
    * @param width the max allowed line width in pixels
    */
   /*-------------------------------------------------------------------*/
   public void setMaxWidth(int width)
   {
       this.maxAllowed = width;
       this.maxAllowedSet = true;
       repaint();
   }
   /*-------------------------------------------------------------------*/
   /**
    * This method may be used to set the horizontal margin
    *
    * @param margin the margin to the left and to the right of the label
    */
   /*-------------------------------------------------------------------*/
   public void setMarginWidth(int margin)
   {
       this.marginWidth = margin;
       repaint();
   }
   /*-------------------------------------------------------------------*/
   /**
    * This method may be used to set the vertical margin for the label
    *
    * @param margin the margin on the top and bottom of the label
    */
   /*-------------------------------------------------------------------*/
   public void setMarginHeight(int margin)
   {
       this.marginHeight = margin;
       repaint();
   }
   /*-------------------------------------------------------------------*/
   /**
    * Moves and resizes this component. The new location of the top-left corner is specified by
    * x and y, and the new size is specified by width
    * and height.
    *
    * @param x      The new x-coordinate of this component.
    * @param y      The new y-coordinate of this component.
    * @param width  The new width of this component.
    * @param height The new height of this component.
    */
   /*-------------------------------------------------------------------*/
   public void setBounds(int x, int y, int width, int height)
   {
       super.setBounds(x, y, width, height);
       this.maxAllowed = width;
       this.maxAllowedSet = true;
   }
   /*-------------------------------------------------------------------*/
   /**
    * This method may be used to retrieve the text alignment for the label
    *
    * @return alignment the text alignment currently in use for the label
    */
   /*-------------------------------------------------------------------*/
   public int getAlignment()
   {
       return (this.alignment);
   }
   /*-------------------------------------------------------------------*/
   /**
    * This method may be used to retrieve the horizontal margin for the label
    *
    * @return marginWidth the margin currently in use to the left and right of the label
    */
   /*-------------------------------------------------------------------*/
   public int getMarginWidth()
   {
       return (this.marginWidth);
   }
   /*-------------------------------------------------------------------*/
   /**
    * This method may be used to retrieve the vertical margin for the label
    *
    * @return marginHeight the margin currently in use on the top and bottom of the label
    */
   /*-------------------------------------------------------------------*/
   public int getMarginHeight()
   {
       return (this.marginHeight);
   }
   /*-------------------------------------------------------------------*/
   /**
    * This method is typically used by the layout manager, it reports the necessary space to
    * display the label comfortably.
    */
   /*-------------------------------------------------------------------*/
   public Dimension getPreferredSize()
   {
       measure();
       return (new Dimension(maxAllowed, (numLines * (lineHeight + lineAscent + lineDescent))
               + (2 * marginHeight)));
   }
   /*-------------------------------------------------------------------*/
   /**
    * This method is typically used by the layout manager, it reports the absolute minimum space
    * required to display the entire label.
    */
   /*-------------------------------------------------------------------*/
   public Dimension getMinimumSize()
   {
       measure();
       return (new Dimension(maxAllowed, (numLines * (lineHeight + lineAscent + lineDescent))
               + (2 * marginHeight)));
   }
   /*-------------------------------------------------------------------*/
   /**
    * This method is called by the system after this object is first created.
    */
   /*-------------------------------------------------------------------*/
   public void addNotify()
   {
       super.addNotify(); // invoke the superclass
   }

} /*---------------------------------------------------------------------------*/


 </source>
   
  
 
  



Multi Line Label extends JPanel

   <source lang="java">
 

/*

This file is part of the BlueJ program. 
Copyright (C) 1999-2009  Michael K�lling and John Rosenberg 

This program is free software; you can redistribute it and/or 
modify it under the terms of the GNU General Public License 
as published by the Free Software Foundation; either version 2 
of the License, or (at your option) any later version. 

This program is distributed in the hope that it will be useful, 
but WITHOUT ANY WARRANTY; without even the implied warranty of 
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
GNU General Public License for more details. 

You should have received a copy of the GNU General Public License 
along with this program; if not, write to the Free Software 
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. 

This file is subject to the Classpath exception as provided in the  
LICENSE.txt file that accompanied this code.
*/

import java.awt.Color; import java.awt.ruponent; import java.awt.Font; import java.util.ArrayList; import java.util.List; import javax.swing.Box; import javax.swing.BoxLayout; import javax.swing.JLabel; import javax.swing.JPanel; /**

** @version $Id: MultiLineLabel.java 6164 2009-02-19 18:11:32Z polle $
** @author Justin Tan
** A multi-line Label-like AWT component.
**/

public class MultiLineLabel extends JPanel {

   protected int fontAttributes = Font.PLAIN;
   protected float alignment;
   protected Color col = null;
 protected int spacing = 0;
   
   /**
    ** Constructor - make a multiline label
    **/
   public MultiLineLabel(String text, float alignment)
   {
       this.alignment = alignment;
       setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
       if(text != null)
           setText(text);
   }
   /**
    ** Constructor, defaults to centered text
    **/
   public MultiLineLabel(String text)
   {
       this(text, LEFT_ALIGNMENT);
   }
   /**
    * Constructor, empty with the given alignment
    */
   public MultiLineLabel(float alignment)
   {
       this(null, alignment);
   }
   /**
    * Constructor, empty with the given alignment and line spacing
    */
   public MultiLineLabel(float alignment, int spacing)
   {
       this(null, alignment);
       this.spacing = spacing;
   }
   /**
    ** Constructor - make an empty multiline label
    **/
   public MultiLineLabel()
   {
       this(null, LEFT_ALIGNMENT);
   }
 
   public void setText(String text)
   {
       // clear the existing lines from the panel
       removeAll();
       addText(text);
   }
 
   public void addText(String text)
   {
       addText(text, 12);
   }
   
   public void addText(String text, int size)
   {
       if(spacing > 0)
           add(Box.createVerticalStrut(spacing));
       String strs[] = splitLines(text);
       JLabel l;
       Font font = new Font("SansSerif", fontAttributes, size);
       for (int i = 0; strs != null && i < strs.length; i++) {
           l = new JLabel(strs[i]);
           l.setFont(font);
           l.setAlignmentX(alignment);
           if (col != null)
               l.setForeground(col);
           add(l);
       }   
   }
   /**
    * Splits "string" by "Delimiter"
    * 
    * @param str - the string to be split
    * @param delimiter - the field delimiter within str
    * @returns an array of Strings
    */
   public static String[] split(String str, String delimiter)
   {
       List<String> strings = new ArrayList<String>();
       int start = 0;
       int len = str.length();
       int dlen = delimiter.length();
       int offset = str.lastIndexOf(delimiter); // First of all, find the
       // Last occurance of the Delimiter
       // Stop empty delimiters
       if (dlen < 1)
           return null;
       else if (offset < 0) // one element
       {
           String[] result = {str};
           return result;
       }
       //
       // Append the delimiter onto the end if it doesn"t already exit
       //
       if (len > offset + dlen) {
           str += delimiter;
           len += dlen;
       }
       do {
           // Get the new Offset
           offset = str.indexOf(delimiter, start);
           strings.add(str.substring(start, offset));
           // Get the new Start position
           start = offset + dlen;
       } while ((start < len) && (offset != -1));
       // Convert the list into an Array of Strings
       String result[] = new String[strings.size()];
       strings.toArray(result);
       return result;
   }
   /**
    * Splits "string" into lines (stripping end-of-line characters)
    * 
    * @param str - the string to be split
    * @returns an array of Strings
    */
   public static String[] splitLines(String str)
   {
       return (str == null ? null : split(str, "\n"));
   }
   public void addText(String text, boolean bold, boolean italic)
   {
       int oldAttributes = fontAttributes;
       setBold(bold);
       setItalic(italic);
       addText(text);
       fontAttributes = oldAttributes;
   }
   public void setForeground(Color col)
   {
       this.col = col;    
       Component[] components = this.getComponents();
       for (int i = 0; i < components.length; i++) {
     Component component = components[i];
     component.setForeground(col);
   }
   }
     
   public void setItalic(boolean italic)
   {
       if(italic)
          fontAttributes |= Font.ITALIC;
       else
           fontAttributes &= ~Font.ITALIC;
   }
 
   public void setBold(boolean bold)
   {
       if(bold)
           fontAttributes |= Font.BOLD;
       else
           fontAttributes &= ~Font.BOLD;
   }

}


 </source>
   
  
 
  



URL Label

   <source lang="java">
 

//The contents of this file are subject to the Mozilla Public License Version 1.1 //(the "License"); you may not use this file except in compliance with the //License. You may obtain a copy of the License at http://www.mozilla.org/MPL/ // //Software distributed under the License is distributed on an "AS IS" basis, //WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License //for the specific language governing rights and //limitations under the License. // //The Original Code is "The Columba Project" // //The Initial Developers of the Original Code are Frederik Dietz and Timo Stich. //Portions created by Frederik Dietz and Timo Stich are Copyright (C) 2003. // //All Rights Reserved. import java.awt.Color; import java.awt.Cursor; import java.awt.Graphics; import java.awt.Rectangle; import java.awt.event.MouseEvent; import java.net.URL; import javax.swing.JLabel; public class URLLabel extends JLabel {

 boolean entered = false;
 boolean mousehover;
 public URLLabel(URL url) {
   this(url, url.toString());
 }
 public URLLabel(URL url, String str) {
   super(str);
   setForeground(Color.blue);
   mousehover = false;
 }
 public void mouseEntered(MouseEvent e) {
   setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
   entered = true;
   if (mousehover) {
     repaint();
   }
 }
 public void mouseExited(MouseEvent e) {
   setCursor(Cursor.getDefaultCursor());
   entered = false;
   if (mousehover) {
     repaint();
   }
 }
 public void mousePressed(MouseEvent e) {
 }
 public void mouseReleased(MouseEvent e) {
 }
 public void paint(Graphics g) {
   super.paint(g);
   if (entered || !mousehover) {
     Rectangle r = g.getClipBounds();
     g.drawLine(0, r.height - this.getFontMetrics(this.getFont()).getDescent(), this
         .getFontMetrics(this.getFont()).stringWidth(this.getText()), r.height
         - this.getFontMetrics(this.getFont()).getDescent());
   }
 }

}


 </source>
   
  
 
  



Vertical Label UI

   <source lang="java">
 

/*

* The contents of this file are subject to the Sapient Public License
* Version 1.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
* http://carbon.sf.net/License.html.
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
* the specific language governing rights and limitations under the License.
*
* The Original Code is The Carbon Component Framework.
*
* The Initial Developer of the Original Code is Sapient Corporation
*
* Copyright (C) 2003 Sapient Corporation. All Rights Reserved.
*/

import java.awt.Dimension; import java.awt.FontMetrics; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Insets; import java.awt.Rectangle; import java.awt.geom.AffineTransform; import javax.swing.Icon; import javax.swing.JComponent; import javax.swing.JLabel; import javax.swing.plaf.basic.BasicLabelUI; /**

*

This is the template for Classes.

*
*
* @since carbon 1.0
* @author Greg Hinkle, January 2002
* @version $Revision: 1.4 $($Author: dvoet $ / $Date: 2003/05/05 21:21:27 $)
* @copyright 2002 Sapient
*/

public class VerticalLabelUI extends BasicLabelUI {

   static {
       labelUI = new VerticalLabelUI(false);
   }
   protected boolean clockwise;
   public VerticalLabelUI(boolean clockwise) {
       super();
       this.clockwise = clockwise;
   }
   public Dimension getPreferredSize(JComponent c) {
       Dimension dim = super.getPreferredSize(c);
       return new Dimension( dim.height, dim.width );
   }
   private static Rectangle paintIconR = new Rectangle();
   private static Rectangle paintTextR = new Rectangle();
   private static Rectangle paintViewR = new Rectangle();
   private static Insets paintViewInsets = new Insets(0, 0, 0, 0);
   public void paint(Graphics g, JComponent c) {
       JLabel label = (JLabel)c;
       String text = label.getText();
       Icon icon = (label.isEnabled()) ? label.getIcon() : label.getDisabledIcon();
       if ((icon == null) && (text == null)) {
           return;
       }
       FontMetrics fm = g.getFontMetrics();
       paintViewInsets = c.getInsets(paintViewInsets);
       paintViewR.x = paintViewInsets.left;
       paintViewR.y = paintViewInsets.top;
       // Use inverted height & width
       paintViewR.height = c.getWidth() - (paintViewInsets.left + paintViewInsets.right);
       paintViewR.width = c.getHeight() - (paintViewInsets.top + paintViewInsets.bottom);
       paintIconR.x = paintIconR.y = paintIconR.width = paintIconR.height = 0;
       paintTextR.x = paintTextR.y = paintTextR.width = paintTextR.height = 0;
       String clippedText =
           layoutCL(label, fm, text, icon, paintViewR, paintIconR, paintTextR);
       Graphics2D g2 = (Graphics2D) g;
       AffineTransform tr = g2.getTransform();
       if (clockwise) {
           g2.rotate( Math.PI / 2 );
           g2.translate( 0, - c.getWidth() );
       } else {
           g2.rotate( - Math.PI / 2 );
           g2.translate( - c.getHeight(), 0 );
       }
       if (icon != null) {
           icon.paintIcon(c, g, paintIconR.x, paintIconR.y);
       }
       if (text != null) {
           int textX = paintTextR.x;
           int textY = paintTextR.y + fm.getAscent();
           if (label.isEnabled()) {
               paintEnabledText(label, g, clippedText, textX, textY);
           } else {
               paintDisabledText(label, g, clippedText, textX, textY);
           }
       }
       g2.setTransform( tr );
   }

}


 </source>