Loading...

Type: Bug
Resolution: Fixed
Priority: P4
Fix Version/s: 1.4.1
Affects Version/s: 1.2.2, 1.3.0, 1.3.1, 1.3.1_01
Component/s: client-libs
Labels:
- webbug

Subcomponent:
2d
Resolved In Build:
1.4.1
CPU:

x86
OS:

windows_98

Name: stC104175 Date: 05/12/2000

java version "1.3.0"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.3.0-C)
Java HotSpot(TM) Client VM (build 1.3.0-C, mixed mode)

The Java 2 implementation of AWT appears to execute fillRect asynchronously but
it fails to serialize properly with certain subsequent graphics primitives
executed on the same thread -- specifically drawChars and drawString. This
severe "semantic bug" results in a "race condition": the text specified by
drawChars or drawString randomly appears over the background specified by
fillRect (as intended) or else the background is drawn last and the text is
"blank".

(This bug also happens if "clearRect" is used instead of "fillRect".)

This bug severely impacts an entire class of popular Java applets/applications,
specifically terminal emulators such as IBM's Host On-Demand or OpenConnect's
OC://WebConnect. Such applications typically present all or most of their user
interface via a simple Canvas-like "terminal screen" upon which characters from
a fixed-width font are drawn and over-drawn cell-by-cell, sometimes with a
different foreground and/or background color than previously. Thus the
fillRect/drawChars and/or fillRect/drawString paradigm, repeated cell-by-cell
over all or portions of the Canvas, is typical. For example:

g.setColor(Color.white);
g.fillRect(x, y, cell_width, cell_height);
g.setColor(Color.black);
g.drawChars(array, 0, 1, x, y + cell_base);

  To demonstrate that this fails in Java 2, consider the following simple applet.
This applet draws all 256 pages of a Unicode font, one page at a time. The
keys to control this applet are not shown "on screen". They are as follows:

right arrow = next Unicode page
left arrow = previous Unicode page
up arrow = larger font
down arrow = smaller font
scroll lock = toggles between "Courier" and "Monospaced" fonts

This test case works perfectly under all of Sun's Java 1.1 JDKs, and it even
works under Netscape Communicator and Microsoft Internet Exploder. But it
produces "random blank cells" on its "screen" when executed under either Java 2
SDK v1.2.2 or Java 2 SDK v1.3 (FCS) (Windows 95/98 platform). The randomness
disappears if the fillRect calls are commented out -- but that is not a workable
solution because subsequent updates to the same character cell are then written
on top of the earlier character, creating a big mess!

Following are the HTML file and the Java source code for the test applet:

<HTML>
<HEAD>
<TITLE>Font Test</TITLE>
</HEAD>
<BODY>
<CENTER>
<H3>Font Test</H3>
</CENTER>

<CENTER>
<APPLET CODE="fonts.class" WIDTH=728 HEIGHT=466>
</APPLET>
</CENTER>

</BODY>
</HTML>

import java.applet.Applet;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.*;

public class fonts extends Applet implements FocusListener, KeyListener
  {
  Font screen_font;
  int width, height;
  int cell_width, cell_height, cell_base;
  int left_margin, top_margin;
  int x, y;
  int font_test_page, font_test_size = 16; boolean font_test_type;
  boolean have_focus, want_focus;
  boolean focus_when_stopped = true;

  public void init()
    {
    setBackground(Color.white);
    width = getSize().width;
    height = getSize().height;
    cell_width = width/32;
    left_margin = (width - 32*cell_width)/2;
    cell_height = height/18;
    top_margin = (height - 18*cell_height)/2;
    this.addFocusListener(this);
    this.addKeyListener(this);
    }

  public void start()
    {
// System.out.println("Applet started");
    want_focus = focus_when_stopped;
    }

  public void stop()
    {
// System.out.println("Applet stopped");
    focus_when_stopped = have_focus;
    }

  public void paint(Graphics g)
    {
    if (screen_font == null)
      {
      int sf_cell_width = width/48;
      int fs = 13;
      screen_font = new Font("Courier", Font.PLAIN, 13);
      int cw = g.getFontMetrics(screen_font).charWidth('0');
      if (cw < sf_cell_width)
        {
        for (fs = 14; fs <= 96; fs++)
          {
          screen_font = new Font("Courier", Font.PLAIN, fs);
          cw = g.getFontMetrics(screen_font).charWidth('0');
          if (cw == sf_cell_width)
            break;
          else if (cw > sf_cell_width)
            {
            screen_font = new Font("Courier", Font.PLAIN, fs - 1);
            cw = g.getFontMetrics(screen_font).charWidth('0');
            break;
            }
          }
        }
      else if (cw > sf_cell_width)
        {
        for (fs = 12; fs >= 1; fs--)
          {
          screen_font = new Font("Courier", Font.PLAIN, fs);
          cw = g.getFontMetrics(screen_font).charWidth('0');
          if (cw <= sf_cell_width)
            break;
          }
        }
      int ds = g.getFontMetrics(screen_font).getDescent();
      cell_base = cell_height - 1 - ds;
// System.out.println("width: " + width + "; height: " + height
// + "; sf_cell_width: " + sf_cell_width + "; cell_height: " +
cell_height
// + "; font size: " + fs + "; actual cell width: " + cw
// + "; descent: " + ds);
// System.out.println("screen_font: " + screen_font);
      }

    if (want_focus)
      {
      want_focus = false;
      requestFocus();
      }

    font_test(g);
    }

  public void update(Graphics g)
    {
    font_test(g);
    }

  void font_test(Graphics g)
    {
    g.setFont(screen_font);
    y = top_margin;
    g.setColor(Color.white);
    g.fillRect(left_margin, y, 32*cell_width, 2*cell_height);
    g.setColor(Color.black);
    g.drawString(" Unicode Page " + font_test_page
        + (font_test_type ? " [Monospaced" : " [Courier")
        + ", size " + font_test_size + "]",
        left_margin, y + cell_base + 8);
    y += 2*cell_height;
// Font test_font = new Font("ZapfDingbats", Font.PLAIN, font_test_size);
    Font test_font = new Font(font_test_type ? "Monospaced" : "Courier",
        Font.PLAIN, font_test_size);
    if (test_font == null)
      {
      System.out.println("Test font is null!");
      System.exit(0);
      }
    else
      {
// int fw = g.getFontMetrics(test_font).charWidth('0');
// System.out.println("test_font: " + test_font + "; cell width: " + fw);
      g.setFont(test_font);
      char[] array = new char[1];
      for (int i = 0; i < 16; i++)
        {
        x = left_margin;
        for (int j = 0; j < 16; j++)
          {
          g.setColor(Color.white);
          g.fillRect(x, y, 2*cell_width, cell_height);
          g.setColor(Color.black);
          array[0] = (char)(256*font_test_page + 16*j + i);
          g.drawChars(array, 0, 1, x + cell_width/2, y + cell_base + 2);
          x += 2*cell_width;
          }
        y += cell_height;
        }
      }
    }

  public void focusGained(FocusEvent e)
    {
// System.out.println("Focus gained: " + e);
    have_focus = true;
    }

  public void focusLost(FocusEvent e)
    {
// System.out.println("Focus lost: " + e);
    have_focus = false;
    }

  public void keyPressed(KeyEvent e)
    {
    int key = e.getKeyCode();

    switch (key)
      {
      case KeyEvent.VK_SHIFT:
      case KeyEvent.VK_CONTROL:
      case KeyEvent.VK_ALT:
        return;
      }

    int modifiers = e.getModifiers();

    switch (key)
      {
      case KeyEvent.VK_UP:
        if (++font_test_size == 49)
          font_test_size = 1;
        repaint();
        break;
      case KeyEvent.VK_DOWN:
        if (--font_test_size == 0)
          font_test_size = 48;
        repaint();
        break;
      case KeyEvent.VK_LEFT:
        if (--font_test_page == -1)
          font_test_page = 255;
        repaint();
        break;
      case KeyEvent.VK_RIGHT:
        if (++font_test_page == 256)
          font_test_page = 0;
        repaint();
        break;
      case KeyEvent.VK_SCROLL_LOCK:
        font_test_type ^= true;
        repaint();
        break;
      default:
        break;
      }
    }

  public void keyTyped(KeyEvent e)
    {
    }

  public void keyReleased(KeyEvent e)
    {
    }
  }
(Review ID: 104731)
======================================================================
sean.tompkins@eng 2000-08-29
Date: Tue, 29 Aug 2000 12:08:14 -0700
From: ###@###.### (William McCain)
X-Accept-Language: en
To: "Sean Tompkins[CONTRACTOR]" <###@###.###>
Subject: Re: Your bug submitted with ID: 4337823
Content-Transfer-Encoding: 7bit

Sean:

YES!!! The bug disappears when I use the "-J-Dsun.java2d.noddraw=true"
flag with "appletviewer"!

So it is definitely related to "DirectDraw" support! When I discovered
that this bug is related to hardware acceleration, I began to suspect
that AWT had been recoded in Java 2 to utilize Microsoft's DirectDraw --
which is intended for VIDEO GAMES -- rather than the standard "GDI"
API. This appears to confirm my suspicions.

The video card that I use is ATI Rage 128 XPERT 128, also known by the
marketing name "ATI Rage Fury". My machine has Windows 98 SE, Pentium
III 800 MHz. I am using the video drivers that came with the ATI card,
which Windows lists as:
     ATI Rage 128 XPERT 128 (English)
     Manufacturer: ATI Tech. - Enhanced
     Features: DirectDraw 1.00
     Software version: 4.00
     Current files: ATI2DRAA.DRV,*vdd,*vflatd,ATI2VXAA.VXD,ati3

BINGO!!! I ran the JTable demo in "SwingSet2", as you suggested. I got
the same results as reported in that bug: squashed, streaky scrolling
(really, really BAD, in fact).

Then I ran the exact same test with "appletviewer", but specifying the
"-J-Dsun.java2d.noddraw=true" flag. And it worked perfectly. No
streaks, no squashed graphics, just plain perfect.

CONCLUSION: You got bad bugs in your use of DirectDraw -- in fact, I
question whether or not you should even be using a video game interface
at all. At BEST you will need to redesign your DirectDraw support so
that it actually works -- that is, if it even CAN be made to work
properly in a non-gaming environment. And even then, I personally would
prefer that the default should be for DirectDraw support to be "false",
for the sake of backward compatibility.

NOTE that while both 4337823 and 4314208 are clearly related to the use
or non-use of DirectDraw support (on video cards that actually support
this feature), the two bugs were reported in widely divergent
circumstances. MY maddeningly simple bug scenario (drawing characters
on a recently-filled background, using hairy old AWT primitives and no
Swing stuff at all) is almost light-years removed from the 4314208 bug
scenario (a Swing applet that scrolls a table full of small cells).

The bugs were reported by users with two different brands of video card
("ATI Rage Fury" and "3dfx Voodoo3"). The problem with the JTable demo
in "SwingSet2" has also been reported with Matrox G400 video cards (see
4314208). ATI, Voodoo, and Matrox are three of the most popular
high-end video cards, especially popular with "gamers". So it would
seem that Java2's DirectDraw support has run into serious problems when
used with the high-end cards that actually implement DirectDraw as a
hardware-accelerated feature!

William C. McCain
Palo Alto, California
(650) 327-4369

duplicates

JDK-4314208 JTable: cell contents vertically distorted/chopped when scrolling (cf. Stylepad)

Closed

JDK-4381598 Firefly:SwingSet2, Win98 Hebrew/Arabic enabled, window messed up after scrolling

Closed

JDK-4349156 fillRect appears to execute asynchronously in Java 2 applets

Closed

relates to

JDK-6406177 REGRESSION: Graphics2D drawText often does not draw String completely

Resolved

Details

Description

Attachments

Issue Links

Activity

People

Dates