Kadangkala, dalam membuat suatu program yang mengharuskan user mengisi suatu textfield, kita perlu membatasi jumlah karakter yang diketikkan. Dalam Java, class JTextField biasa tidak didesain untuk secara otomatis melakukannya. Coba saja Anda ketikkan satu juta karakter di sana, pasti masih bisa terpampang di layar. Nah, coba bayangkan kalau yang harus diinputkan adalah field kode barang, atau nomor telepon, atau apapun yang memiliki batas panjang. Tentu akan merepotkan kalau di program harus mengecek itu.

Untuk itu lebih mudah jika kita membatasi jumlah karakter yang bisa diinputkan dalam JTextField. Salah satu gunanya adalah saat field yang Anda perlukan itu harus disimpan dalam kolom database yang memiliki lebar karakter terbatas. Dalam HQLibrary, saya juga berencana membuat utility yang menangani hal simpel ini. Yah, meskipun ini sebenarnya hal sederhana, rasanya tetap perlu dimasukkan untuk mempermudah nantinya.

Oke, langsung masuk ke class yang saya buat. Class pertama, seperti biasa adalah Utility. Kali ini Class yang saya buat saya beri nama HQTextFieldUtil, yang nantinya akan berisi semua utility yang berhubungan dengan textfield.

/**
 * DO NOT REMOVE THIS LICENSE
 *
 * This source code is created by Muhammad Fauzil Haqqi.
 * You can use and modify this source code freely but
 * you are forbidden to change or remove this license.
 *
 * Nick  : Haqqi
 * YM    : xp_guitarist
 * Email : fauzil.haqqi@gmail.com
 * Blog  : http://www.fauzilhaqqi.net
 */
package hq.utility;

import javax.swing.JTextField;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.PlainDocument;

/**
 *
 * @author Haqqi
 */
public final class HQTextFieldUtil {
  // *******variables area****** //

  // *****constructors area***** //
  private HQTextFieldUtil() {
  }

  // ********methods area******* //
  public static void limitTextFieldChar(JTextField field, final int numChar) {
    if (numChar == 0) {
      field.setDocument(new PlainDocument());
      return;
    }

    PlainDocument pd = new PlainDocument() {

      private static final long serialVersionUID = 1L;
      private int limit = numChar;

      @Override
      public void insertString(int offs, String str, AttributeSet a)
          throws BadLocationException {
        if (str == null) {
          return;
        }
        if ((getLength() + str.length()) <= limit) {
          super.insertString(offs, str, a);
        }
      }
    };
    field.setDocument(pd);
  }
}

Pada method limitTextFieldChar(), akan dilakukan pembuatan suatu dokumen. Bagi yang belum mengerti, pada JTextField, sebenarnya kita tidak mengetikkan atau menyimpan hasil ketikan langsung di class milik swing tersebut. Alih-alih demikian, karakter-karakter yang kita ketikkan akan disimpan dalam suatu class yang bernama document. Nah, strategi dari pembatasan jumlah karakter ini adalah dengan mengeset dokumen baru ke textfield yang ada, dengan pengaturan sedemikian rupa. Saya melakukan override pada method insertString() untuk mengecek apakah karakter yang akan diketikkan akan menghasilkan panjang yang lebih dari limitasi.

Setelah membuat class ini, Anda bisa secara manual memanggilnya dengan

HQTextFieldUtil.limitTextFieldChar(suatuTextField, suatuAngka);

Tapi karena saya lebih suka mendesain GUI dengan NetBeans, saya akan membuat class HQLimitedTextField.

/**
 * DO NOT REMOVE THIS LICENSE
 *
 * This source code is created by Muhammad Fauzil Haqqi.
 * You can use and modify this source code freely but
 * you are forbidden to change or remove this license.
 *
 * Nick  : Haqqi
 * YM    : xp_guitarist
 * Email : fauzil.haqqi@gmail.com
 * Blog  : http://www.fauzilhaqqi.net
 */
package hq.widget;

import hq.utility.HQTextFieldUtil;
import javax.swing.JTextField;

/**
 *
 * @author Haqqi
 */
public class HQLimitedTextField extends JTextField {

  private static final long serialVersionUID = 1L;
  // *******variables area****** //
  private int limit;

  // *****constructors area***** //
  // ********methods area******* //
  /**
   * Get the value of limit
   *
   * @return the value of limit
   */
  public int getLimit() {
    return limit;
  }

  /**
   * Set the value of limit
   *
   * @param limit new value of limit
   */
  public void setLimit(int limit) {
    this.limit = limit;
    firePropertyChange("limit", getLimit(), limit);
    HQTextFieldUtil.limitTextFieldChar(this, limit);
  }
}

Dengan demikian, setelah proses drag and drop, saya bisa mengatur limitnya menggunakan panel properties yang ada pada NetBeans. Sangat mudah bukan? Happy coding

Sebenarnya saya akan meng-extend-kan class ini dari HQTextField yang telah diubah tampilannya. Tujuannya adalah agar semua turunannya seragam. Tapi sudahlah, karena memang belum jadi ya ini dulu.

Recently, I just wrote posts about my own world. For now, I will write about another Java Tutorial. Still in the progress of HQLibrary that is suspended, this is another simple class in my library. From the image you can see beside, you will understand that I will show you how to make a label that automatically create a reflection if we add an icon. More over, this class can be used in NetBeans GUI form, so you can add an icon using the parameter panel.

Before we go to create an extended class of JLabel, first we need to know how to automatically create a reflection of an image. Using Java 2D API, we can easily finish that problem. Those useful class packaged in java.awt package. We need to do simple 2D manipulation to create a new image that has reflection. So, I created some methods in another class (not in extended JLabel), with static modifier, so that it can be used by another class. I wrapped that methods in a class named HQIconUtil.

Here is the source code:

/**
 * DO NOT REMOVE THIS LICENSE
 *
 * This source code is created by Muhammad Fauzil Haqqi.
 * You can use and modify this source code freely but
 * you are forbidden to change or remove this license.
 *
 * Nick  : Haqqi
 * YM    : xp_guitarist
 * Email : fauzil.haqqi@gmail.com
 * Blog  : http://www.fauzilhaqqi.net
 */
package hq.utility;

import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.image.BufferedImage;

/**
 *
 * @author Haqqi
 */
public final class HQIconUtil {
  // *******variables area****** //

  // *****constructors area***** //
  private HQIconUtil() {}

  // ********methods area******* //
  public static BufferedImage convertToBufferedImage(Image image) {
    // get image size
    int width = image.getWidth(null);
    int height = image.getHeight(null);

    // create new buffered image
    BufferedImage result = new BufferedImage(width, height,
        BufferedImage.TYPE_INT_ARGB);
    Graphics2D g = result.createGraphics();
    g.drawImage(image, 0, 0, null);
    g.dispose();

    // return the result
    return result;
  }

  public static BufferedImage
      createReflectionBufferedImage(BufferedImage image) {
    // create result image
    BufferedImage result = new BufferedImage(image.getWidth(),
        image.getHeight() * 6 / 4, BufferedImage.TYPE_INT_ARGB);

    Graphics2D g = result.createGraphics();

    // paints original image
    g.drawImage(image, 0, 0, null);

    // paints mirrored image
    g.scale(1.0, -1.0);
    g.drawImage(image, 0, -image.getHeight() * 2, null);
    g.scale(1.0, -1.0);

    // move to mirror's origin
    g.translate(0, image.getHeight());

    // create gradien mask
    GradientPaint mask = new GradientPaint(0, 0, new Color(1f, 1f, 1f, 0.5f),
        0, image.getHeight() / 2, new Color(1f, 1f, 1f, 0f));
    g.setPaint(mask);

    // set alpha composite
    g.setComposite(AlphaComposite.DstIn);

    // paint the mask
    g.fillRect(0, 0, image.getWidth(), image.getHeight());

    g.dispose();
    return result;
  }

  public static BufferedImage
      createReflectionBufferedImage(Image image) {
    return createReflectionBufferedImage(convertToBufferedImage(image));
  }
}

Because we can only do image manipulation using BufferedImage, first of all we need to convert an Image into BufferedImage one. That is the use of the first method, convertToBufferedImage(Image image). After that, we parse it to createReflectionBufferedImage(BufferedImage image) method to get the new image with its reflection. The important thing to understand this method is by studying about masking and compositing of Java 2D. The idea here is to composite destination image with a gradient.

After that, we can create our new class for label. We can easily create it by extending JLabel class of javax.swing package. I use NetBeans to create this class, and others too. So, I just right click and choose to add a new property that saves the reflection icon variable.

Don’t forget to generate setter and getter method, so that it can be used using GUI parameter panel in NetBeans. I named my class as HQLabel, since it will be included in my HQLibrary.

Here is the source code of HQLabel:

/**
 * DO NOT REMOVE THIS LICENSE
 *
 * This source code is created by Muhammad Fauzil Haqqi.
 * You can use and modify this source code freely but
 * you are forbidden to change or remove this license.
 *
 * Nick  : Haqqi
 * YM    : xp_guitarist
 * Email : fauzil.haqqi@gmail.com
 * Blog  : http://www.fauzilhaqqi.net
 */
package hq.widget;

import hq.utility.HQIconUtil;
import java.awt.image.BufferedImage;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.SwingConstants;

/**
 *
 * @author Haqqi
 */
public class HQLabel extends javax.swing.JLabel {
  private static final long serialVersionUID = 1L;
  // *******variables area****** //
  private Icon iconReflect;

  // *****constructors area***** //
  /**
   * Default constructor.
   * Set label's text to the bottom center.
   */
  public HQLabel() {
    super();
    setHorizontalTextPosition(SwingConstants.CENTER);
    setVerticalTextPosition(SwingConstants.BOTTOM);
  }

  // ********methods area******* //
  /**
   * Get icon reflection.
   * @return iconReflect - Icon reflection
   */
  public Icon getIconReflect() {
    return this.iconReflect;
  }

  /**
   * Set the icon reflection. Current icon will be
   * replaced by the icon reflection.
   * @param iconReflect
   */
  public void setIconReflect(Icon iconReflect)
      throws IllegalArgumentException {
    // check whether the argument is null
    if (iconReflect == null) {
      firePropertyChange("iconReflection", getIconReflect(), iconReflect);
      this.iconReflect = iconReflect;
      setIcon(iconReflect);
    } else {
      if (!(iconReflect instanceof ImageIcon)) {
        throw new IllegalArgumentException();
      }
      firePropertyChange("iconReflection", getIconReflect(), iconReflect);
      this.iconReflect = iconReflect;
      BufferedImage img = HQIconUtil.createReflectionBufferedImage(((ImageIcon) iconReflect).getImage());
      setIcon(new ImageIcon(img));
    }
  }
}

Ok, those all the way to create a label class that has an image reflection. If you create it correctly, you will see a new parameter in NetBeans parameter editor panel. You can test it by building it and then adding it to a GUI form such as JPanel in NetBeans. You can do that by simply dragging from the file panel. Happy coding…

Another Java tutorial, hope it will be useful.

Again, this post is from my previous blog post

Coding in Java is my hobby. So I am happy when my subject is about programming in Java. Although I’m still not a great Java programmer, I want to share this tutorial. It is about how to wrap text in to JLabel, so that whenever the text reach the right side of JLabel, it will go to the next line. Sometimes we will face this condition. For example, when we want to create a bunch of information text such as dialog box that display “about” information. We have very long text to display, but if we place it in a JLabel with ordinary process, it will grow horizontally until the end of the text, and never go to the next line.

I created a utility class to solve that problem. This class will be added in my own library, if it is frequently used. Like I have said above, the problem is we have a JLabel and we are confused about how to wrap a String in that label. The concept is simple, we just have to arrange it into html form and place new line tag each time the text reach the right side. Ouch, there is another problem come out, how to detect whether it collide or not. Ok, to answer that question, you can read my source below.

/**
 * DO NOT REMOVE THIS LICENSE
 *
 * This source code is created by Muhammad Fauzil Haqqi.
 * You can use and modify this source code freely but
 * you are forbidden to change or remove this license.
 *
 * Nick  : Haqqi
 * YM    : xp_guitarist
 * Email : fauzil.haqqi@gmail.com
 * Blog  : http://www.fauzilhaqqi.net
 */

import java.awt.FontMetrics;
import java.text.BreakIterator;
import javax.swing.JLabel;
import javax.swing.SwingUtilities;

/**
 *
 * @author Haqqi
 */
public class LabelUtil {
  // *******variables area****** //

  // *****constructors area***** //
  /**
   * To prevent the creation of the object
   */
  private LabelUtil() {}

  // ********methods area******* //
  /**
   * Wrap array of String into a label
   * @param label
   * @param text
   */
  public static void wrapTextToLabel(JLabel label, String[] text) {
    // measure the length of font in pixel
    FontMetrics fm = label.getFontMetrics(label.getFont());
    // get container width, you must set the fixed width of
    // the container, i.e. JPanel
    int contWidth = label.getParent().getWidth();
    // to find the word separation
    BreakIterator boundary = BreakIterator.getWordInstance();
    // main string to be added
    StringBuffer m = new StringBuffer("<html>");
    // loop each index of array
    for(String str : text) {
      boundary.setText(str);
      // save each line
      StringBuffer line = new StringBuffer();
      // save each paragraph
      StringBuffer par = new StringBuffer();
      int start = boundary.first();
      // wrap loop
      for(int end = boundary.next(); end != BreakIterator.DONE;
          start = end, end = boundary.next()) {
        String word = str.substring(start,end);
        line.append(word);
        // compare width with font metrics
        int trialWidth = SwingUtilities
            .computeStringWidth(
            fm, line.toString());
        // if bigger, add new line
        if(trialWidth > contWidth) {
          line = new StringBuffer(word);
          par.append("<br />");
        }
        // add new word to paragraphs
        par.append(word);
      }
      // add new line each paragraph
      par.append("<br />");
      // add paragraph into main string
      m.append(par);
    }
    // closed tag
    m.append("</html>");
    label.setText(m.toString());
  }

  /**
   * Wrap a String into a label
   * @param label
   * @param text
   */
  public static void wrapTextToLabel(JLabel label, String text) {
    String[] newText = new String[] {text};
    wrapTextToLabel(label, newText);
  }
}

There are two methods, first is with array of String parameter, and second with single String parameter. There is no difference, just an ordinary overload method. In order to make that method works, there are some adding sequence that you must follow:

1. Create a container (for example, JPanel) with specific width by call setSize(width, height) method.
2. Create an empty JLabel then add it to the panel.
3. After getting the String (from where you get, it’s up to you), call LabelUtil.wrapTextToLabel() method.

For example, I use this text file to create “about” dialog box.

HQ Library v0.001
http://www.fauzilhaqqi.net – 2010

Author: Muhammad Fauzil Haqqi

This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing.

This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing.

This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing. This text is just for testing.

If you have some recomendation, please be free to tell me.

And then, here is an example of main method to show how LabelUtil works.

import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.BorderFactory;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.UIManager;

/**
 *
 * @author Haqqi
 */
public class Tester {
  // *******variables area****** //

  // *****constructors area***** //

  // ********methods area******* //
  public static void main(String[] args) {
    // get default look and feel
    try {
      UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
    } catch (Exception ex) {
      Logger.getLogger(Tester.class.getName()).log(Level.SEVERE, null, ex);
    }
    // create new JPanel
    JPanel p = new JPanel();
    // set the border
    p.setBorder(BorderFactory.createEtchedBorder());
    // just set its width
    p.setSize(450, 0);
    // get the text from file. you can change this with your own way
    String[] text = FileUtil.fileRead(FileUtil.setFile("data/about.me"));
    // create new JLabel
    JLabel label = new JLabel();
    // first, add to the panel
    p.add(label);
    // wrap the text
    LabelUtil.wrapTextToLabel(label, text);
    // finally, show the dialog
    JOptionPane.showMessageDialog(null, p, "About this Program",
        JOptionPane.PLAIN_MESSAGE);
  }
}

I read the file using another class of my library, called FileUtil that is already posted here. It returns an array of Strings that will be added in LabelUtil method. If your run that program correctly, it should give this display:

Enjoy coding in Java!!

Bahasa keywords: Tutorial Java teks JLabel ganti baris otomatis.

Repost from my previous blog, about Java tutorial.

This post is similar with my post before

Inspired by Eko with his USU Library, now I am creating my own Java library. Of course, I will make it open source, as soon as I think it is finished with version 1.0. Hope that I will focus in this project. I think you who are a programmer should make your own library too. Because it will be useful whenever you get a project, and it will be your trademark. You know, although you decide that your library will become open source, the real author is you. So the only one who know most of your program is YOU. Don’t afraid to be open source.

This is my first Java tutorial in this blog. It’s about one of Java cores, reading and writing into a file. At first, when still newbie in Java, I was confused how to do this thing. Luckily, when reading GTGE, I found a class that is useful for this task. I learnt from it and make my own FileUtil class. Here it is, you can analyze the code.

/**
 * DO NOT REMOVE THIS LICENSE
 *
 * This source code is created by Muhammad Fauzil Haqqi.
 * You can use and modify this source code freely but
 * you are forbidden to change or remove this license.
 *
 * Nick  : Haqqi
 * YM    : xp_guitarist
 * Email : fauzil.haqqi@gmail.com
 * Blog  : http://www.fauzilhaqqi.net
 */

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;

/**
 *
 * @author Haqqi
 */
public class FileUtil {
  // *******variables area****** //

  // *****constructors area***** //
  /**
   * To prevent the creation of object
   */
  private FileUtil() {
  }

  // ********methods area******* //
  /**
   * Set the file based on relative path
   * @param filePath Path of the file
   * @return Generated file
   */
  public static File setFile(String filePath) {
    // create new file object
    File file = null;
    // getting the path from working directory
    // you can check the directory by printing it
    String path = System.getProperty("user.dir")
        + File.separatorChar + filePath;
    try {
      // construct the file based on the path
      file = new File(path);
    } catch (Exception e) {
      e.printStackTrace();
    }
    // if file is not found, then throw exception
    if (file == null) {
      throw new RuntimeException();
    }
    return file;
  }

  /**
   * Write an Array of String into a file. The written
   * file will be just like a text file.
   * @param text Array of String that want to be written
   * @param file File
   * @return true if success and false if not
   */
  public static boolean fileWrite(String[] text, File file) {
    try {
      // create buffer
      BufferedWriter out = new BufferedWriter(new FileWriter(file));
      PrintWriter writeOut = new PrintWriter(out);
      // writing text to file
      for (int i = 0; i < text.length; i++) {
        writeOut.println(text[i]);
      }
      // close the writer
      writeOut.close();
      return true;
    } catch (IOException e) {
      e.printStackTrace();
      return false;
    }
  }

  /**
   * Read file from a file
   * @param file
   * @return
   */
  public static String[] fileRead(File file) {
    try {
      // buffered reader
      BufferedReader readIn = new BufferedReader(new FileReader(file));
      // ArrayList to store the string each line
      ArrayList<String> list = new ArrayList<String>();
      // Temporarily object
      String data;
      // Read each line until end of line
      while ((data = readIn.readLine()) != null) {
        list.add(data);
      }
      // closing reader
      readIn.close();
      // return as Array of String
      return list.toArray(new String[0]);
    } catch (IOException e) {
      e.printStackTrace();
      return null;
    }
  }
}

Using comments I wrote above, you can study how it works by yourself. There are 3 static methods, setFile(), fileWrite(), and fileRead(). The most important thing about reading and writing a file is the location of the file. Using setFile() method, you can easily locate it based on your working directory. After the file is set, you can easily read and write it using another methods above. I think, because my code is already in form of a class, you don’t need to copy several lines and paste into your class. You can copy the whole class and place it in any package of your project.

Oke, I hope this post will help you out from your problem. Please be free to leave a comment. Lets code in Java!!!

Bahasa keywords: Tutorial Java membaca dan menulis file