Swing Component Issues and Resolutions

This section addresses potential problems encountered when using Swing components.

Issue: Difficulty implementing a model or similar functionality.

• Solution: Refer to the Java SE source code distributed with the JDK for examples of model implementation and event firing.

Issue: Text field size changes whenever its text is updated.

• Solution: Specify the preferred width by indicating the number of columns, using either the int parameter in the JTextField constructor or the setColumns method.

Issue: Parts of the content pane appear distorted during repaint.

• Solution: Ensure the content pane is opaque by calling setOpaque(true). Verify custom painting implementations. Check for thread safety issues.

Issue: Program exhibits timing-related odd behavior.

• Solution: Ensure code is thread-safe. Refer to Swing concurrency documentation.

Issue: Modal dialog is obscured by other windows.

• Solution: If the dialog lacks a parent, assign it to a valid frame or component upon creation.

Issue: Scrollbar policies do not function as advertised.

• Solution: Use the latest Swing version. Ensure the scroll pane's client dynamically changes size correctly. Verify the correct policy is specified for the intended orientation.

Issue: Scroll pane lacks scrollbars.

• Solution: Use VERTICAL_SCROLLBAR_ALWAYS or HORIZONTAL_SCROLLBAR_ALWAYS to always show scrollbars. To show as needed, ensure the scroll pane's preferred size is set or implement a scrollable class returning a smaller getPreferredScrollableViewportSize value.

Issue: Divider in split pane does not move.

• Solution: Set the minimum size for at least one component within the split pane.

Issue: JSplitPane.setDividerLocation method has no effect.

• Solution: The setDividerLocation(double) method is ineffective if the split pane has no size (typically before being shown). Use setDividerLocation(int) or specify preferred sizes and resize weights.

Issue: Borders appear too thick on nested split panes.

• Solution: Set border to null on any split pane placed inside another to prevent cumulative borders.

Issue: Buttons in toolbar are excessively large.

• Solution: Reduce button margins, for example: component.setMargin(new Insets(0,0,0,0));

Issue: Incorrect component layering in a layered pane.

• Solution: Ensure component depth is added using Integer objects rather than primitive int values.

Issue: JColorChooser.setPreviewPanel(null) does not remove the preview panel as expected.

• Solution: A null argument specifies the default panel. To remove it, set the preview panel to an empty JPanel.

Swing Concurrency Fundamentals

Swing applications utilize several thread types for responsive interfaces:

• Initial Thread: Executes the initial application code.
• Event Dispatch Thread (EDT): Executes all event-handling code. Most interactions with Swing components must occur here.
• Worker Threads: Perform long-running background tasks.

GUI creation tasks should be scheduled on the EDT using SwingUtilities.invokeLater or SwingUtilities.invokeAndWait.

The javax.swing.SwingWorker class manages background tasks, offering features like result communication, progress updates, and cancellation. It implements the Future interface.

Simple Background Task Example:

SwingWorker<BufferedImage[], Void> task = new SwingWorker<>() {
    @Override
    protected BufferedImage[] doInBackground() throws Exception {
        BufferedImage[] loadedImages = new BufferedImage[count];
        for (int i = 0; i < count; i++) {
            loadedImages[i] = ImageIO.read(new File("image" + i + ".png"));
        }
        return loadedImages;
    }
    @Override
    protected void done() {
        try {
            BufferedImage[] result = get();
            // Update UI with loaded images
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
};
task.execute();

Intermediate Results with publish/process:

public class DataTask extends SwingWorker<Void, DataPoint> {
    @Override
    protected Void doInBackground() {
        while (!isCancelled()) {
            DataPoint point = generateData();
            publish(point); // Send intermediate result
            Thread.sleep(100);
        }
        return null;
    }
    @Override
    protected void process(List<DataPoint> chunks) {
        // Process latest data point on the EDT
        DataPoint latest = chunks.get(chunks.size() - 1);
        updateDisplay(latest);
    }
}

Task Cancellation:

• Use SwingWorker.cancel(boolean).
• The task should check isCancelled() periodical or handle InterruptedException.

Bound Properties: SwingWorker supports progress and state bound properties. Listeners can track changes to these properties on the EDT.

Advanced Swing Features

Desktop Class Integration

Use the java.awt.Desktop class to interact with default desktop applications.

if (Desktop.isDesktopSupported()) {
    Desktop desktop = Desktop.getDesktop();
    if (desktop.isSupported(Desktop.Action.BROWSE)) {
        desktop.browse(new URI("https://docs.oracle.com/javase/tutorial"));
    }
    if (desktop.isSupported(Desktop.Action.MAIL)) {
        desktop.mail(new URI("mailto:test@example.com"));
    }
    if (desktop.isSupported(Desktop.Action.OPEN)) {
        desktop.open(new File("document.pdf"));
    }
}

Translucent and Shaped Windows

Requires JDK 7+. Check platform capabilities first.

Uniform Translucency:

if (gd.isWindowTranslucencySupported(TRANSLUCENT)) {
    JFrame frame = new JFrame("Translucent");
    frame.setOpacity(0.7f); // 70% opaque
}

Per-pixel Translucency:

if (gd.isWindowTranslucencySupported(PERPIXEL_TRANSLUCENT)) {
    JFrame frame = new JFrame("Gradient");
    frame.setBackground(new Color(0, 0, 0, 0)); // Transparent background
    // Custom painting in content pane for gradient
}

Shaped Windows:

if (gd.isWindowTranslucencySupported(PERPIXEL_TRANSPARENT)) {
    JFrame frame = new JFrame("Shaped");
    frame.setUndecorated(true);
    frame.addComponentListener(new ComponentAdapter() {
        @Override
        public void componentResized(ComponentEvent e) {
            frame.setShape(new Ellipse2D.Double(0, 0, frame.getWidth(), frame.getHeight()));
        }
    });
}

Decorating Components with JLayer

The JLayer class decorates components without subclassing.

// Custom LayerUI for drawing
class HighlightUI extends LayerUI<JComponent> {
    @Override
    public void paint(Graphics g, JComponent c) {
        super.paint(g, c);
        Graphics2D g2 = (Graphics2D) g.create();
        g2.setColor(new Color(255, 255, 0, 64));
        g2.fillRect(10, 10, c.getWidth()-20, c.getHeight()-20);
        g2.dispose();
    }
}
// Usage
JTextField field = new JTextField();
LayerUI<JComponent> layerUI = new HighlightUI();
JLayer<JComponent> decoratedField = new JLayer<>(field, layerUI);
frame.add(decoratedField);

Using Action Objects

Action objects centralize functionality and state for components.

Action saveAction = new AbstractAction("Save", new ImageIcon("save.png")) {
    @Override
    public void actionPerformed(ActionEvent e) {
        // Save logic
    }
};
saveAction.putValue(Action.SHORT_DESCRIPTION, "Save document");
saveAction.putValue(Action.MNEMONIC_KEY, KeyEvent.VK_S);

JButton saveButton = new JButton(saveAction);
JMenuItem saveMenuItem = new JMenuItem(saveAction);
// Both components share the same action state
saveAction.setEnabled(false); // Disables both button and menu item

Swing Timer

Use javax.swing.Timer for delayed or repeated GUI tasks executed on the EDT.

Timer timer = new Timer(1000, new ActionListener() { // Every second
    private int count = 0;
    @Override
    public void actionPerformed(ActionEvent e) {
        label.setText("Count: " + count++);
        if (count >= 10) {
            ((Timer)e.getSource()).stop();
        }
    }
});
timer.setInitialDelay(2000); // Start after 2 seconds
timer.start();

Accessibility Support

Make Swing applications usable with assistive technologies.

Basic Rules:

1. Set accessible names for non-text components: component.getAccessibleContext().setAccessibleName("Description");
2. Provide tooltip text: component.setToolTipText("Explanation of function");
3. Support keyboard alternatives (mnemonics, key bindings).
4. Ensure custom components implement the Accessible interface.

Custom Component Example:

public class CustomPanel extends JPanel implements Accessible {
    @Override
    public AccessibleContext getAccessibleContext() {
        if (accessibleContext == null) {
            accessibleContext = new AccessibleCustomPanel();
        }
        return accessibleContext;
    }
    protected class AccessibleCustomPanel extends AccessibleJComponent {
        @Override
        public AccessibleRole getAccessibleRole() {
            return AccessibleRole.PANEL;
        }
        @Override
        public String getAccessibleName() {
            return "Custom Data Panel";
        }
    }
}