GRAPHICS DEBUGGING.

GRAPHICS DEBUGGING.

Debugging graphics involves the ability to observe every painting operation as it occur during the rendering of a component and all of its children. Intended for problem finding with rendering, layout and container hierarchies. i.e everything display related.

When graphics debugging is enabled, the graphics object used in painting is an instance of DebugGraphics class which extends the Graphics class. JComponent and every swing component support graphics debugging which can be turned on or off with Jcomponent's setDebugGraphicsOption( ) method. This methods takes an int parameter that details the debug options. This parameter determines how the component should display the information:

if :
1.DebugGraphics.LOG_OPTION – a text message is printed.
2.DebugGraphics.FLASH_OPTION - The display flashes several times.
3.DebugGraphics.BUFFERED_OPTION - It creates an external window that displays the operations performed on this view's offscreen buffer.
4.DebugGraphics.NON_OPTION - Debug disabled.
5.If 0 no change is issued to the debugging option.

Note that these values can be bitwise OR'd into the current value.

Let's explore the options one after the other:

1.DebugGraphices.FLASH_OPTION.

Each paint operation flashes a specified number of times, in a specified flash color, with a specified flash interval.

You set this values with the following methods from the DebugGraphcics static methods :

setFlashTime(int flashTime)
setFlashCount (int flashCount)
setFlashColor (Color flashColor)

to see the flashing as it occurs you must disable buffering like this:

RepaintManager.currentManager(null).setDoubleBuffereingEnabled(false).

After this every component's doubleBuffered properyty will henceforth be ignored.

I loved the flashing at first instance and have been flashing my computer since.

So let me drop a code for that. See how the buttons changed color.

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

public class Property extends JPanel{

//declaring an instance
static Color dColor = new Color(0, 255, 100, 125);

//the dimension
static Dimension dim = new Dimension(400, 400);

static JButton jButton1 = new JButton(" ");
static JTextArea jText;

/** Creates a new instance of Property */
public Property() {
jButton1 = new JButton("click me");
add(jButton1);

//we'll use the instance as foreground.
jButton1.setBackground(dColor);
}

private static void dButton(){
JFrame.setDefaultLookAndFeelDecorated(true);
JFrame frame = new JFrame("Property");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Property nProp = new Property();

//buffering and opaque value for painting and updating
nProp.setOpaque(true);
nProp.setDoubleBuffered(true);

//graphics debugging
nProp.setDebugGraphicsOptions(DebugGraphics.FLASH_OPTION);
DebugGraphics.setFlashColor(Color.red);
DebugGraphics.setFlashCount(5);
DebugGraphics.setFlashTime(10);
RepaintManager.currentManager(null).setDoubleBufferingEnabled(false);


//set max, min and preferred sizes
nProp.setMaximumSize(dim);
nProp.setMinimumSize(dim);
nProp.setPreferredSize(dim);

frame.setContentPane(nProp);

//let the above size stay 4ever
frame.setResizable(false);

frame.pack();
frame.setVisible(true);
}

public static void simplyText(String txt){
jText.append(txt+"\n");

}

public void paintComponent(Graphics g){
super.paintComponent(g);

//counter
int c = 0;

//for use below
int w=0;
int h=0;
int d=0;

//get damaged region
Rectangle r = g.getClipBounds();
int clipx = r.x;
int clipy = r.y;
int clipw = r.width;
int cliph = r.height;

//fill only damaged region
g.setColor(Color.white);
g.fillRect(clipx, clipy, clipw, cliph);

//filled yellow circle only if bounding region is damaged
if (clipx <= 240 && clipy <= 240){
g.setColor(Color.yellow);
g.fillOval(0, 0, 240, 240);
c++;
}

//filled magenta cirlce if bounding region has been damaged
if (clipx + clipw>=160 && clipx<=400 && clipy+cliph>=160 && clipy<=400){
g.setColor(Color.magenta);
g.fillOval(160, 160, 240, 240);
c++;
}


}
public static void main(String[] args){
javax.swing.SwingUtilities.invokeLater(new Runnable(){
public void run(){
dButton();
}
});
}
}

2.DebugGraphics.LOG_OPTION: each paint operation is messaged as they occur and by default are directed to standard output i.e System.out. Note that these output can be redirected with DebugGraphic's static setLogStream() method which method takes a PrintStream instance as a parameter.

we can also instance any string into the log using the debuggraphics static logStream () method.
3.DebugGraphics.BUFFERED_OPTION . This pops up a frame that gives offscreen rendering. Double-buffering must be enabbled.
4.DebugGraphics.NONE_OPTION. Basically shuts down graphics debugging by nullifying the settings.


Caveats in graphics debugging.

You'll notice that the button color changed from the default to brown due to its being blended with the flash color, red. Yeah, that's a caveat in graphics debugging.
1. Where the UI delegate of the component is null. If a component's UI delegate is null, graphics debugging will not work. The best way to go around this is if you declared a class without a UI delegate so as to define a trivial (empty) UI delegate.

2. DebugGraphics does not properly clean up after itself. A flash results in painting over of the color of the components and it does not get erased. This presents a problem because transparent rendering now becomes alpha blended with the flash color. You can hide the flash color though by giving its color an alpha value of invisible, i.e 0 or 0.0. we can sidestep this blending by making the flash time and flashcount to wait long enough between operations.

To implement the above we can rewrite the above code adding the below:


package tests;

import javax.swing.plaf.ComponentUI;
import javax.swing.*;

public class EmptyUI extends ComponentUI {

private static final EmptyUI sharedInstance = new EmptyUI();

public static ComponentUI createUI(JComponent c){
return sharedInstance;
}
}

then to the Property class we add this code as the first line in its constructor:

super.setUI(EmptyUI.createUI(this));