• Post Reply Bookmark Topic Watch Topic
  • New Topic
programming forums Java Mobile Certification Databases Caching Books Engineering Micro Controllers OS Languages Paradigms IDEs Build Tools Frameworks Application Servers Open Source This Site Careers Other Pie Elite all forums
this forum made possible by our volunteer staff, including ...
Marshals:
  • Campbell Ritchie
  • Jeanne Boyarsky
  • Ron McLeod
  • Paul Clapham
  • Liutauras Vilda
Sheriffs:
  • paul wheaton
  • Rob Spoor
  • Devaka Cooray
Saloon Keepers:
  • Stephan van Hulst
  • Tim Holloway
  • Carey Brown
  • Frits Walraven
  • Tim Moores
Bartenders:
  • Mikalai Zaikin

Unicode Display Problem (Urgent!!!)

 
Greenhorn
Posts: 25
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Attached is the code that displays all unicode characters. The code is taken
from David Flanagan's book.
However this doesn�t display multiple East Asian languages at the same time.
Please compile it and run it

1. using �java �Duser.language=ja UnicodeDisplay�
2. using �java �Duser.language=zh UnicodeDisplay�

#1 will show the Japanese characters properly but won�t display the Chinese characters properly.
#2 will do just the reverse.

My question is, is there a way by which I can make this program display both Japanese and Chinese characters (if possible Korean too) at the same time.

By the way, there is a third party java software running on my machine that
displays all east asian languages properly. So I have those languages and fonts installed on my machine and thats definitely not the problem.

Thanks in advance for your help.
-Dan




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

/**
* This program displays Unicode glyphs using user-specified fonts
* and font styles.
**/
public class UnicodeDisplay extends JFrame implements ActionListener {
int page = 0;
UnicodePanel p;
JScrollBar b;
String fontfamily = "Serif";
int fontstyle = Font.PLAIN;

/**
* This constructor creates the frame, menubar, and scrollbar
* that work along with the UnicodePanel class, defined below
**/
public UnicodeDisplay(String name) {
super(name);
p = new UnicodePanel( ); // Create the panel
p.setBase((char)(page * 0x100)); // Initialize it
getContentPane( ).add(p, "Center"); // Center it

// Create and set up a scrollbar, and put it on the right
b = new JScrollBar(Scrollbar.VERTICAL, 0, 1, 0, 0xFF);
b.setUnitIncrement(1);
b.setBlockIncrement(0x10);
b.addAdjustmentListener(new AdjustmentListener( ) {
public void adjustmentValueChanged(AdjustmentEvent e) {
page = e.getValue( );
p.setBase((char)(page * 0x100));
}
});
getContentPane( ).add(b, "East");

// Set things up so we respond to window close requests
this.addWindowListener(new WindowAdapter( ) {
public void windowClosing(WindowEvent e) { System.exit(0); }
});

// Handle Page Up and Page Down and the up and down arrow keys
this.addKeyListener(new KeyAdapter( ) {
public void keyPressed(KeyEvent e) {
int code = e.getKeyCode( );
int oldpage = page;
if ((code == KeyEvent.VK_PAGE_UP) ||
(code == KeyEvent.VK_UP)) {
if (e.isShiftDown( )) page -= 0x10;
else page -= 1;
if (page < 0) page = 0;
}
else if ((code == KeyEvent.VK_PAGE_DOWN) ||
(code == KeyEvent.VK_DOWN)) {
if (e.isShiftDown( )) page += 0x10;
else page += 1;
if (page > 0xff) page = 0xff;
}
if (page != oldpage) { // if anything has changed...
p.setBase((char) (page * 0x100)); // update the display
b.setValue(page); // and update scrollbar to match
}
}
});

// Set up a menu system to change fonts. Use a convenience method.
JMenuBar menubar = new JMenuBar( );
this.setJMenuBar(menubar);
menubar.add(makemenu("Font Family",
new String[ ] {"Serif", "SansSerif", "Monospaced"},
this));
menubar.add(makemenu("Font Style",
new String[ ]{
"Plain","Italic","Bold","BoldItalic"
}, this));
}

/** This method handles the items in the menubars */
public void actionPerformed(ActionEvent e) {
String cmd = e.getActionCommand( );
if (cmd.equals("Serif")) fontfamily = "Serif";
else if (cmd.equals("SansSerif")) fontfamily = "SansSerif";
else if (cmd.equals("Monospaced")) fontfamily = "Monospaced";
else if (cmd.equals("Plain")) fontstyle = Font.PLAIN;
else if (cmd.equals("Italic")) fontstyle = Font.ITALIC;
else if (cmd.equals("Bold")) fontstyle = Font.BOLD;
else if (cmd.equals("BoldItalic")) fontstyle = Font.BOLD + Font.ITALIC;
p.setFont(fontfamily, fontstyle);
}

/** A convenience method to create a Menu from an array of items */
private JMenu makemenu(String name, String[ ] itemnames,
ActionListener listener)
{
JMenu m = new JMenu(name);
for(int i = 0; i < itemnames.length; i++) {
JMenuItem item = new JMenuItem(itemnames[i]);
item.addActionListener(listener);
item.setActionCommand(itemnames[i]); // okay here, though
m.add(item);
}
return m;
}

/** The main( ) program just creates a window, packs it, and shows it */
public static void main(String[ ] args) {
UnicodeDisplay f = new UnicodeDisplay("Unicode Displayer");
f.pack( );
f.show( );
}

/**
* This nested class is the one that displays one "page" of Unicode
* glyphs at a time. Each "page" is 256 characters, arranged into 16
* rows of 16 columns each.
**/
public static class UnicodePanel extends JComponent {
protected char base; // What character we start the display at
protected Font font = new Font("serif", Font.PLAIN, 18);
protected Font headingfont = new Font("monospaced", Font.BOLD, 18);
static final int lineheight = 25;
static final int charspacing = 20;
static final int x0 = 65;
static final int y0 = 40;

/** Specify where to begin displaying, and redisplay */
public void setBase(char base) { this.base = base; repaint( ); }

/** Set a new font name or style, and redisplay */
public void setFont(String family, int style) {
this.font = new Font(family, style, 18);
repaint( );
}

/**
* The paintComponent( ) method actually draws the page of glyphs
**/
public void paintComponent(Graphics g) {
int start = (int)base & 0xFFF0; // Start on a 16-character boundary

// Draw the headings in a special font
g.setFont(headingfont);

// Draw 0..F on top
for(int i=0; i < 16; i++) {
String s = Integer.toString(i, 16);
g.drawString(s, x0 + i*charspacing, y0-20);
}

// Draw column down left.
for(int i = 0; i < 16; i++) {
int j = start + i*16;
String s = Integer.toString(j, 16);
g.drawString(s, 10, y0+i*lineheight);
}

// Now draw the characters
g.setFont(font);
char[ ] c = new char[1];
for(int i = 0; i < 16; i++) {
for(int j = 0; j < 16; j++) {
c[0] = (char)(start + j*16 + i);
g.drawChars(c, 0, 1, x0 + i*charspacing, y0+j*lineheight);
}
}
}

/** Custom components like this one should always have this method */
public Dimension getPreferredSize( ) {
return new Dimension(x0 + 16*charspacing,
y0 + 16*lineheight);
}
}
}
 
With a little knowledge, a cast iron skillet is non-stick and lasts a lifetime.
reply
    Bookmark Topic Watch Topic
  • New Topic