You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1047 lines
36 KiB
1047 lines
36 KiB
/*
|
|
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
|
|
|
|
package javax.swing;
|
|
|
|
|
|
|
|
import java.io.*;
|
|
import java.awt.BorderLayout;
|
|
import java.awt.Frame;
|
|
import java.awt.Dialog;
|
|
import java.awt.Window;
|
|
import java.awt.Component;
|
|
import java.awt.Container;
|
|
import java.beans.PropertyChangeEvent;
|
|
import java.beans.PropertyChangeListener;
|
|
import java.awt.event.WindowListener;
|
|
import java.awt.event.WindowAdapter;
|
|
import java.awt.event.WindowEvent;
|
|
|
|
import java.awt.IllegalComponentStateException;
|
|
import java.awt.Point;
|
|
import java.awt.Rectangle;
|
|
import java.text.*;
|
|
import java.util.Locale;
|
|
import javax.accessibility.*;
|
|
import javax.swing.event.*;
|
|
import javax.swing.text.*;
|
|
|
|
|
|
/** A class to monitor the progress of some operation. If it looks
|
|
* like the operation will take a while, a progress dialog will be popped up.
|
|
* When the ProgressMonitor is created it is given a numeric range and a
|
|
* descriptive string. As the operation progresses, call the setProgress method
|
|
* to indicate how far along the [min,max] range the operation is.
|
|
* Initially, there is no ProgressDialog. After the first millisToDecideToPopup
|
|
* milliseconds (default 500) the progress monitor will predict how long
|
|
* the operation will take. If it is longer than millisToPopup (default 2000,
|
|
* 2 seconds) a ProgressDialog will be popped up.
|
|
* <p>
|
|
* From time to time, when the Dialog box is visible, the progress bar will
|
|
* be updated when setProgress is called. setProgress won't always update
|
|
* the progress bar, it will only be done if the amount of progress is
|
|
* visibly significant.
|
|
*
|
|
* <p>
|
|
*
|
|
* For further documentation and examples see
|
|
* <a
|
|
href="https://docs.oracle.com/javase/tutorial/uiswing/components/progress.html">How to Monitor Progress</a>,
|
|
* a section in <em>The Java Tutorial.</em>
|
|
*
|
|
* @see ProgressMonitorInputStream
|
|
* @author James Gosling
|
|
* @author Lynn Monsanto (accessibility)
|
|
*/
|
|
public class ProgressMonitor implements Accessible
|
|
{
|
|
private ProgressMonitor root;
|
|
private JDialog dialog;
|
|
private JOptionPane pane;
|
|
private JProgressBar myBar;
|
|
private JLabel noteLabel;
|
|
private Component parentComponent;
|
|
private String note;
|
|
private Object[] cancelOption = null;
|
|
private Object message;
|
|
private long T0;
|
|
private int millisToDecideToPopup = 500;
|
|
private int millisToPopup = 2000;
|
|
private int min;
|
|
private int max;
|
|
|
|
|
|
/**
|
|
* Constructs a graphic object that shows progress, typically by filling
|
|
* in a rectangular bar as the process nears completion.
|
|
*
|
|
* @param parentComponent the parent component for the dialog box
|
|
* @param message a descriptive message that will be shown
|
|
* to the user to indicate what operation is being monitored.
|
|
* This does not change as the operation progresses.
|
|
* See the message parameters to methods in
|
|
* {@link JOptionPane#message}
|
|
* for the range of values.
|
|
* @param note a short note describing the state of the
|
|
* operation. As the operation progresses, you can call
|
|
* setNote to change the note displayed. This is used,
|
|
* for example, in operations that iterate through a
|
|
* list of files to show the name of the file being processes.
|
|
* If note is initially null, there will be no note line
|
|
* in the dialog box and setNote will be ineffective
|
|
* @param min the lower bound of the range
|
|
* @param max the upper bound of the range
|
|
* @see JDialog
|
|
* @see JOptionPane
|
|
*/
|
|
public ProgressMonitor(Component parentComponent,
|
|
Object message,
|
|
String note,
|
|
int min,
|
|
int max) {
|
|
this(parentComponent, message, note, min, max, null);
|
|
}
|
|
|
|
|
|
private ProgressMonitor(Component parentComponent,
|
|
Object message,
|
|
String note,
|
|
int min,
|
|
int max,
|
|
ProgressMonitor group) {
|
|
this.min = min;
|
|
this.max = max;
|
|
this.parentComponent = parentComponent;
|
|
|
|
cancelOption = new Object[1];
|
|
cancelOption[0] = UIManager.getString("OptionPane.cancelButtonText");
|
|
|
|
this.message = message;
|
|
this.note = note;
|
|
if (group != null) {
|
|
root = (group.root != null) ? group.root : group;
|
|
T0 = root.T0;
|
|
dialog = root.dialog;
|
|
}
|
|
else {
|
|
T0 = System.currentTimeMillis();
|
|
}
|
|
}
|
|
|
|
|
|
private class ProgressOptionPane extends JOptionPane
|
|
{
|
|
ProgressOptionPane(Object messageList) {
|
|
super(messageList,
|
|
JOptionPane.INFORMATION_MESSAGE,
|
|
JOptionPane.DEFAULT_OPTION,
|
|
null,
|
|
ProgressMonitor.this.cancelOption,
|
|
null);
|
|
}
|
|
|
|
|
|
public int getMaxCharactersPerLineCount() {
|
|
return 60;
|
|
}
|
|
|
|
|
|
// Equivalent to JOptionPane.createDialog,
|
|
// but create a modeless dialog.
|
|
// This is necessary because the Solaris implementation doesn't
|
|
// support Dialog.setModal yet.
|
|
public JDialog createDialog(Component parentComponent, String title) {
|
|
final JDialog dialog;
|
|
|
|
Window window = JOptionPane.getWindowForComponent(parentComponent);
|
|
if (window instanceof Frame) {
|
|
dialog = new JDialog((Frame)window, title, false);
|
|
} else {
|
|
dialog = new JDialog((Dialog)window, title, false);
|
|
}
|
|
if (window instanceof SwingUtilities.SharedOwnerFrame) {
|
|
WindowListener ownerShutdownListener =
|
|
SwingUtilities.getSharedOwnerFrameShutdownListener();
|
|
dialog.addWindowListener(ownerShutdownListener);
|
|
}
|
|
Container contentPane = dialog.getContentPane();
|
|
|
|
contentPane.setLayout(new BorderLayout());
|
|
contentPane.add(this, BorderLayout.CENTER);
|
|
dialog.pack();
|
|
dialog.setLocationRelativeTo(parentComponent);
|
|
dialog.addWindowListener(new WindowAdapter() {
|
|
boolean gotFocus = false;
|
|
|
|
public void windowClosing(WindowEvent we) {
|
|
setValue(cancelOption[0]);
|
|
}
|
|
|
|
public void windowActivated(WindowEvent we) {
|
|
// Once window gets focus, set initial focus
|
|
if (!gotFocus) {
|
|
selectInitialValue();
|
|
gotFocus = true;
|
|
}
|
|
}
|
|
});
|
|
|
|
addPropertyChangeListener(new PropertyChangeListener() {
|
|
public void propertyChange(PropertyChangeEvent event) {
|
|
if(dialog.isVisible() &&
|
|
event.getSource() == ProgressOptionPane.this &&
|
|
(event.getPropertyName().equals(VALUE_PROPERTY) ||
|
|
event.getPropertyName().equals(INPUT_VALUE_PROPERTY))){
|
|
dialog.setVisible(false);
|
|
dialog.dispose();
|
|
}
|
|
}
|
|
});
|
|
|
|
return dialog;
|
|
}
|
|
|
|
/////////////////
|
|
// Accessibility support for ProgressOptionPane
|
|
////////////////
|
|
|
|
/**
|
|
* Gets the AccessibleContext for the ProgressOptionPane
|
|
*
|
|
* @return the AccessibleContext for the ProgressOptionPane
|
|
* @since 1.5
|
|
*/
|
|
public AccessibleContext getAccessibleContext() {
|
|
return ProgressMonitor.this.getAccessibleContext();
|
|
}
|
|
|
|
/*
|
|
* Returns the AccessibleJOptionPane
|
|
*/
|
|
private AccessibleContext getAccessibleJOptionPane() {
|
|
return super.getAccessibleContext();
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Indicate the progress of the operation being monitored.
|
|
* If the specified value is >= the maximum, the progress
|
|
* monitor is closed.
|
|
* @param nv an int specifying the current value, between the
|
|
* maximum and minimum specified for this component
|
|
* @see #setMinimum
|
|
* @see #setMaximum
|
|
* @see #close
|
|
*/
|
|
public void setProgress(int nv) {
|
|
if (nv >= max) {
|
|
close();
|
|
}
|
|
else {
|
|
if (myBar != null) {
|
|
myBar.setValue(nv);
|
|
}
|
|
else {
|
|
long T = System.currentTimeMillis();
|
|
long dT = (int)(T-T0);
|
|
if (dT >= millisToDecideToPopup) {
|
|
int predictedCompletionTime;
|
|
if (nv > min) {
|
|
predictedCompletionTime = (int)(dT *
|
|
(max - min) /
|
|
(nv - min));
|
|
}
|
|
else {
|
|
predictedCompletionTime = millisToPopup;
|
|
}
|
|
if (predictedCompletionTime >= millisToPopup) {
|
|
myBar = new JProgressBar();
|
|
myBar.setMinimum(min);
|
|
myBar.setMaximum(max);
|
|
myBar.setValue(nv);
|
|
if (note != null) noteLabel = new JLabel(note);
|
|
pane = new ProgressOptionPane(new Object[] {message,
|
|
noteLabel,
|
|
myBar});
|
|
dialog = pane.createDialog(parentComponent,
|
|
UIManager.getString(
|
|
"ProgressMonitor.progressText"));
|
|
dialog.show();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Indicate that the operation is complete. This happens automatically
|
|
* when the value set by setProgress is >= max, but it may be called
|
|
* earlier if the operation ends early.
|
|
*/
|
|
public void close() {
|
|
if (dialog != null) {
|
|
dialog.setVisible(false);
|
|
dialog.dispose();
|
|
dialog = null;
|
|
pane = null;
|
|
myBar = null;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the minimum value -- the lower end of the progress value.
|
|
*
|
|
* @return an int representing the minimum value
|
|
* @see #setMinimum
|
|
*/
|
|
public int getMinimum() {
|
|
return min;
|
|
}
|
|
|
|
|
|
/**
|
|
* Specifies the minimum value.
|
|
*
|
|
* @param m an int specifying the minimum value
|
|
* @see #getMinimum
|
|
*/
|
|
public void setMinimum(int m) {
|
|
if (myBar != null) {
|
|
myBar.setMinimum(m);
|
|
}
|
|
min = m;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the maximum value -- the higher end of the progress value.
|
|
*
|
|
* @return an int representing the maximum value
|
|
* @see #setMaximum
|
|
*/
|
|
public int getMaximum() {
|
|
return max;
|
|
}
|
|
|
|
|
|
/**
|
|
* Specifies the maximum value.
|
|
*
|
|
* @param m an int specifying the maximum value
|
|
* @see #getMaximum
|
|
*/
|
|
public void setMaximum(int m) {
|
|
if (myBar != null) {
|
|
myBar.setMaximum(m);
|
|
}
|
|
max = m;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns true if the user hits the Cancel button in the progress dialog.
|
|
*/
|
|
public boolean isCanceled() {
|
|
if (pane == null) return false;
|
|
Object v = pane.getValue();
|
|
return ((v != null) &&
|
|
(cancelOption.length == 1) &&
|
|
(v.equals(cancelOption[0])));
|
|
}
|
|
|
|
|
|
/**
|
|
* Specifies the amount of time to wait before deciding whether or
|
|
* not to popup a progress monitor.
|
|
*
|
|
* @param millisToDecideToPopup an int specifying the time to wait,
|
|
* in milliseconds
|
|
* @see #getMillisToDecideToPopup
|
|
*/
|
|
public void setMillisToDecideToPopup(int millisToDecideToPopup) {
|
|
this.millisToDecideToPopup = millisToDecideToPopup;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the amount of time this object waits before deciding whether
|
|
* or not to popup a progress monitor.
|
|
*
|
|
* @see #setMillisToDecideToPopup
|
|
*/
|
|
public int getMillisToDecideToPopup() {
|
|
return millisToDecideToPopup;
|
|
}
|
|
|
|
|
|
/**
|
|
* Specifies the amount of time it will take for the popup to appear.
|
|
* (If the predicted time remaining is less than this time, the popup
|
|
* won't be displayed.)
|
|
*
|
|
* @param millisToPopup an int specifying the time in milliseconds
|
|
* @see #getMillisToPopup
|
|
*/
|
|
public void setMillisToPopup(int millisToPopup) {
|
|
this.millisToPopup = millisToPopup;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the amount of time it will take for the popup to appear.
|
|
*
|
|
* @see #setMillisToPopup
|
|
*/
|
|
public int getMillisToPopup() {
|
|
return millisToPopup;
|
|
}
|
|
|
|
|
|
/**
|
|
* Specifies the additional note that is displayed along with the
|
|
* progress message. Used, for example, to show which file the
|
|
* is currently being copied during a multiple-file copy.
|
|
*
|
|
* @param note a String specifying the note to display
|
|
* @see #getNote
|
|
*/
|
|
public void setNote(String note) {
|
|
this.note = note;
|
|
if (noteLabel != null) {
|
|
noteLabel.setText(note);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Specifies the additional note that is displayed along with the
|
|
* progress message.
|
|
*
|
|
* @return a String specifying the note to display
|
|
* @see #setNote
|
|
*/
|
|
public String getNote() {
|
|
return note;
|
|
}
|
|
|
|
/////////////////
|
|
// Accessibility support
|
|
////////////////
|
|
|
|
/**
|
|
* The <code>AccessibleContext</code> for the <code>ProgressMonitor</code>
|
|
* @since 1.5
|
|
*/
|
|
protected AccessibleContext accessibleContext = null;
|
|
|
|
private AccessibleContext accessibleJOptionPane = null;
|
|
|
|
/**
|
|
* Gets the <code>AccessibleContext</code> for the
|
|
* <code>ProgressMonitor</code>
|
|
*
|
|
* @return the <code>AccessibleContext</code> for the
|
|
* <code>ProgressMonitor</code>
|
|
* @since 1.5
|
|
*/
|
|
public AccessibleContext getAccessibleContext() {
|
|
if (accessibleContext == null) {
|
|
accessibleContext = new AccessibleProgressMonitor();
|
|
}
|
|
if (pane != null && accessibleJOptionPane == null) {
|
|
// Notify the AccessibleProgressMonitor that the
|
|
// ProgressOptionPane was created. It is necessary
|
|
// to poll for ProgressOptionPane creation because
|
|
// the ProgressMonitor does not have a Component
|
|
// to add a listener to until the ProgressOptionPane
|
|
// is created.
|
|
if (accessibleContext instanceof AccessibleProgressMonitor) {
|
|
((AccessibleProgressMonitor)accessibleContext).optionPaneCreated();
|
|
}
|
|
}
|
|
return accessibleContext;
|
|
}
|
|
|
|
/**
|
|
* <code>AccessibleProgressMonitor</code> implements accessibility
|
|
* support for the <code>ProgressMonitor</code> class.
|
|
* @since 1.5
|
|
*/
|
|
protected class AccessibleProgressMonitor extends AccessibleContext
|
|
implements AccessibleText, ChangeListener, PropertyChangeListener {
|
|
|
|
/*
|
|
* The accessibility hierarchy for ProgressMonitor is a flattened
|
|
* version of the ProgressOptionPane component hierarchy.
|
|
*
|
|
* The ProgressOptionPane component hierarchy is:
|
|
* JDialog
|
|
* ProgressOptionPane
|
|
* JPanel
|
|
* JPanel
|
|
* JLabel
|
|
* JLabel
|
|
* JProgressBar
|
|
*
|
|
* The AccessibleProgessMonitor accessibility hierarchy is:
|
|
* AccessibleJDialog
|
|
* AccessibleProgressMonitor
|
|
* AccessibleJLabel
|
|
* AccessibleJLabel
|
|
* AccessibleJProgressBar
|
|
*
|
|
* The abstraction presented to assitive technologies by
|
|
* the AccessibleProgressMonitor is that a dialog contains a
|
|
* progress monitor with three children: a message, a note
|
|
* label and a progress bar.
|
|
*/
|
|
|
|
private Object oldModelValue;
|
|
|
|
/**
|
|
* AccessibleProgressMonitor constructor
|
|
*/
|
|
protected AccessibleProgressMonitor() {
|
|
}
|
|
|
|
/*
|
|
* Initializes the AccessibleContext now that the ProgressOptionPane
|
|
* has been created. Because the ProgressMonitor is not a Component
|
|
* implementing the Accessible interface, an AccessibleContext
|
|
* must be synthesized from the ProgressOptionPane and its children.
|
|
*
|
|
* For other AWT and Swing classes, the inner class that implements
|
|
* accessibility for the class extends the inner class that implements
|
|
* implements accessibility for the super class. AccessibleProgressMonitor
|
|
* cannot extend AccessibleJOptionPane and must therefore delegate calls
|
|
* to the AccessibleJOptionPane.
|
|
*/
|
|
private void optionPaneCreated() {
|
|
accessibleJOptionPane =
|
|
((ProgressOptionPane)pane).getAccessibleJOptionPane();
|
|
|
|
// add a listener for progress bar ChangeEvents
|
|
if (myBar != null) {
|
|
myBar.addChangeListener(this);
|
|
}
|
|
|
|
// add a listener for note label PropertyChangeEvents
|
|
if (noteLabel != null) {
|
|
noteLabel.addPropertyChangeListener(this);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Invoked when the target of the listener has changed its state.
|
|
*
|
|
* @param e a <code>ChangeEvent</code> object. Must not be null.
|
|
* @throws NullPointerException if the parameter is null.
|
|
*/
|
|
public void stateChanged(ChangeEvent e) {
|
|
if (e == null) {
|
|
return;
|
|
}
|
|
if (myBar != null) {
|
|
// the progress bar value changed
|
|
Object newModelValue = myBar.getValue();
|
|
firePropertyChange(ACCESSIBLE_VALUE_PROPERTY,
|
|
oldModelValue,
|
|
newModelValue);
|
|
oldModelValue = newModelValue;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method gets called when a bound property is changed.
|
|
*
|
|
* @param e A <code>PropertyChangeEvent</code> object describing
|
|
* the event source and the property that has changed. Must not be null.
|
|
* @throws NullPointerException if the parameter is null.
|
|
*/
|
|
public void propertyChange(PropertyChangeEvent e) {
|
|
if (e.getSource() == noteLabel && e.getPropertyName() == "text") {
|
|
// the note label text changed
|
|
firePropertyChange(ACCESSIBLE_TEXT_PROPERTY, null, 0);
|
|
}
|
|
}
|
|
|
|
/* ===== Begin AccessileContext ===== */
|
|
|
|
/**
|
|
* Gets the accessibleName property of this object. The accessibleName
|
|
* property of an object is a localized String that designates the purpose
|
|
* of the object. For example, the accessibleName property of a label
|
|
* or button might be the text of the label or button itself. In the
|
|
* case of an object that doesn't display its name, the accessibleName
|
|
* should still be set. For example, in the case of a text field used
|
|
* to enter the name of a city, the accessibleName for the en_US locale
|
|
* could be 'city.'
|
|
*
|
|
* @return the localized name of the object; null if this
|
|
* object does not have a name
|
|
*
|
|
* @see #setAccessibleName
|
|
*/
|
|
public String getAccessibleName() {
|
|
if (accessibleName != null) { // defined in AccessibleContext
|
|
return accessibleName;
|
|
} else if (accessibleJOptionPane != null) {
|
|
// delegate to the AccessibleJOptionPane
|
|
return accessibleJOptionPane.getAccessibleName();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Gets the accessibleDescription property of this object. The
|
|
* accessibleDescription property of this object is a short localized
|
|
* phrase describing the purpose of the object. For example, in the
|
|
* case of a 'Cancel' button, the accessibleDescription could be
|
|
* 'Ignore changes and close dialog box.'
|
|
*
|
|
* @return the localized description of the object; null if
|
|
* this object does not have a description
|
|
*
|
|
* @see #setAccessibleDescription
|
|
*/
|
|
public String getAccessibleDescription() {
|
|
if (accessibleDescription != null) { // defined in AccessibleContext
|
|
return accessibleDescription;
|
|
} else if (accessibleJOptionPane != null) {
|
|
// delegate to the AccessibleJOptionPane
|
|
return accessibleJOptionPane.getAccessibleDescription();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Gets the role of this object. The role of the object is the generic
|
|
* purpose or use of the class of this object. For example, the role
|
|
* of a push button is AccessibleRole.PUSH_BUTTON. The roles in
|
|
* AccessibleRole are provided so component developers can pick from
|
|
* a set of predefined roles. This enables assistive technologies to
|
|
* provide a consistent interface to various tweaked subclasses of
|
|
* components (e.g., use AccessibleRole.PUSH_BUTTON for all components
|
|
* that act like a push button) as well as distinguish between subclasses
|
|
* that behave differently (e.g., AccessibleRole.CHECK_BOX for check boxes
|
|
* and AccessibleRole.RADIO_BUTTON for radio buttons).
|
|
* <p>Note that the AccessibleRole class is also extensible, so
|
|
* custom component developers can define their own AccessibleRole's
|
|
* if the set of predefined roles is inadequate.
|
|
*
|
|
* @return an instance of AccessibleRole describing the role of the object
|
|
* @see AccessibleRole
|
|
*/
|
|
public AccessibleRole getAccessibleRole() {
|
|
return AccessibleRole.PROGRESS_MONITOR;
|
|
}
|
|
|
|
/**
|
|
* Gets the state set of this object. The AccessibleStateSet of an object
|
|
* is composed of a set of unique AccessibleStates. A change in the
|
|
* AccessibleStateSet of an object will cause a PropertyChangeEvent to
|
|
* be fired for the ACCESSIBLE_STATE_PROPERTY property.
|
|
*
|
|
* @return an instance of AccessibleStateSet containing the
|
|
* current state set of the object
|
|
* @see AccessibleStateSet
|
|
* @see AccessibleState
|
|
* @see #addPropertyChangeListener
|
|
*/
|
|
public AccessibleStateSet getAccessibleStateSet() {
|
|
if (accessibleJOptionPane != null) {
|
|
// delegate to the AccessibleJOptionPane
|
|
return accessibleJOptionPane.getAccessibleStateSet();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Gets the Accessible parent of this object.
|
|
*
|
|
* @return the Accessible parent of this object; null if this
|
|
* object does not have an Accessible parent
|
|
*/
|
|
public Accessible getAccessibleParent() {
|
|
return dialog;
|
|
}
|
|
|
|
/*
|
|
* Returns the parent AccessibleContext
|
|
*/
|
|
private AccessibleContext getParentAccessibleContext() {
|
|
if (dialog != null) {
|
|
return dialog.getAccessibleContext();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Gets the 0-based index of this object in its accessible parent.
|
|
*
|
|
* @return the 0-based index of this object in its parent; -1 if this
|
|
* object does not have an accessible parent.
|
|
*
|
|
* @see #getAccessibleParent
|
|
* @see #getAccessibleChildrenCount
|
|
* @see #getAccessibleChild
|
|
*/
|
|
public int getAccessibleIndexInParent() {
|
|
if (accessibleJOptionPane != null) {
|
|
// delegate to the AccessibleJOptionPane
|
|
return accessibleJOptionPane.getAccessibleIndexInParent();
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of accessible children of the object.
|
|
*
|
|
* @return the number of accessible children of the object.
|
|
*/
|
|
public int getAccessibleChildrenCount() {
|
|
// return the number of children in the JPanel containing
|
|
// the message, note label and progress bar
|
|
AccessibleContext ac = getPanelAccessibleContext();
|
|
if (ac != null) {
|
|
return ac.getAccessibleChildrenCount();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Returns the specified Accessible child of the object. The Accessible
|
|
* children of an Accessible object are zero-based, so the first child
|
|
* of an Accessible child is at index 0, the second child is at index 1,
|
|
* and so on.
|
|
*
|
|
* @param i zero-based index of child
|
|
* @return the Accessible child of the object
|
|
* @see #getAccessibleChildrenCount
|
|
*/
|
|
public Accessible getAccessibleChild(int i) {
|
|
// return a child in the JPanel containing the message, note label
|
|
// and progress bar
|
|
AccessibleContext ac = getPanelAccessibleContext();
|
|
if (ac != null) {
|
|
return ac.getAccessibleChild(i);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/*
|
|
* Returns the AccessibleContext for the JPanel containing the
|
|
* message, note label and progress bar
|
|
*/
|
|
private AccessibleContext getPanelAccessibleContext() {
|
|
if (myBar != null) {
|
|
Component c = myBar.getParent();
|
|
if (c instanceof Accessible) {
|
|
return c.getAccessibleContext();
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Gets the locale of the component. If the component does not have a
|
|
* locale, then the locale of its parent is returned.
|
|
*
|
|
* @return this component's locale. If this component does not have
|
|
* a locale, the locale of its parent is returned.
|
|
*
|
|
* @exception IllegalComponentStateException
|
|
* If the Component does not have its own locale and has not yet been
|
|
* added to a containment hierarchy such that the locale can be
|
|
* determined from the containing parent.
|
|
*/
|
|
public Locale getLocale() throws IllegalComponentStateException {
|
|
if (accessibleJOptionPane != null) {
|
|
// delegate to the AccessibleJOptionPane
|
|
return accessibleJOptionPane.getLocale();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/* ===== end AccessibleContext ===== */
|
|
|
|
/**
|
|
* Gets the AccessibleComponent associated with this object that has a
|
|
* graphical representation.
|
|
*
|
|
* @return AccessibleComponent if supported by object; else return null
|
|
* @see AccessibleComponent
|
|
*/
|
|
public AccessibleComponent getAccessibleComponent() {
|
|
if (accessibleJOptionPane != null) {
|
|
// delegate to the AccessibleJOptionPane
|
|
return accessibleJOptionPane.getAccessibleComponent();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Gets the AccessibleValue associated with this object that supports a
|
|
* Numerical value.
|
|
*
|
|
* @return AccessibleValue if supported by object; else return null
|
|
* @see AccessibleValue
|
|
*/
|
|
public AccessibleValue getAccessibleValue() {
|
|
if (myBar != null) {
|
|
// delegate to the AccessibleJProgressBar
|
|
return myBar.getAccessibleContext().getAccessibleValue();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Gets the AccessibleText associated with this object presenting
|
|
* text on the display.
|
|
*
|
|
* @return AccessibleText if supported by object; else return null
|
|
* @see AccessibleText
|
|
*/
|
|
public AccessibleText getAccessibleText() {
|
|
if (getNoteLabelAccessibleText() != null) {
|
|
return this;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/*
|
|
* Returns the note label AccessibleText
|
|
*/
|
|
private AccessibleText getNoteLabelAccessibleText() {
|
|
if (noteLabel != null) {
|
|
// AccessibleJLabel implements AccessibleText if the
|
|
// JLabel contains HTML text
|
|
return noteLabel.getAccessibleContext().getAccessibleText();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/* ===== Begin AccessibleText impl ===== */
|
|
|
|
/**
|
|
* Given a point in local coordinates, return the zero-based index
|
|
* of the character under that Point. If the point is invalid,
|
|
* this method returns -1.
|
|
*
|
|
* @param p the Point in local coordinates
|
|
* @return the zero-based index of the character under Point p; if
|
|
* Point is invalid return -1.
|
|
*/
|
|
public int getIndexAtPoint(Point p) {
|
|
AccessibleText at = getNoteLabelAccessibleText();
|
|
if (at != null && sameWindowAncestor(pane, noteLabel)) {
|
|
// convert point from the option pane bounds
|
|
// to the note label bounds.
|
|
Point noteLabelPoint = SwingUtilities.convertPoint(pane,
|
|
p,
|
|
noteLabel);
|
|
if (noteLabelPoint != null) {
|
|
return at.getIndexAtPoint(noteLabelPoint);
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Determines the bounding box of the character at the given
|
|
* index into the string. The bounds are returned in local
|
|
* coordinates. If the index is invalid an empty rectangle is returned.
|
|
*
|
|
* @param i the index into the String
|
|
* @return the screen coordinates of the character's bounding box,
|
|
* if index is invalid return an empty rectangle.
|
|
*/
|
|
public Rectangle getCharacterBounds(int i) {
|
|
AccessibleText at = getNoteLabelAccessibleText();
|
|
if (at != null && sameWindowAncestor(pane, noteLabel)) {
|
|
// return rectangle in the option pane bounds
|
|
Rectangle noteLabelRect = at.getCharacterBounds(i);
|
|
if (noteLabelRect != null) {
|
|
return SwingUtilities.convertRectangle(noteLabel,
|
|
noteLabelRect,
|
|
pane);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/*
|
|
* Returns whether source and destination components have the
|
|
* same window ancestor
|
|
*/
|
|
private boolean sameWindowAncestor(Component src, Component dest) {
|
|
if (src == null || dest == null) {
|
|
return false;
|
|
}
|
|
return SwingUtilities.getWindowAncestor(src) ==
|
|
SwingUtilities.getWindowAncestor(dest);
|
|
}
|
|
|
|
/**
|
|
* Returns the number of characters (valid indicies)
|
|
*
|
|
* @return the number of characters
|
|
*/
|
|
public int getCharCount() {
|
|
AccessibleText at = getNoteLabelAccessibleText();
|
|
if (at != null) { // JLabel contains HTML text
|
|
return at.getCharCount();
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Returns the zero-based offset of the caret.
|
|
*
|
|
* Note: That to the right of the caret will have the same index
|
|
* value as the offset (the caret is between two characters).
|
|
* @return the zero-based offset of the caret.
|
|
*/
|
|
public int getCaretPosition() {
|
|
AccessibleText at = getNoteLabelAccessibleText();
|
|
if (at != null) { // JLabel contains HTML text
|
|
return at.getCaretPosition();
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Returns the String at a given index.
|
|
*
|
|
* @param part the CHARACTER, WORD, or SENTENCE to retrieve
|
|
* @param index an index within the text
|
|
* @return the letter, word, or sentence
|
|
*/
|
|
public String getAtIndex(int part, int index) {
|
|
AccessibleText at = getNoteLabelAccessibleText();
|
|
if (at != null) { // JLabel contains HTML text
|
|
return at.getAtIndex(part, index);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns the String after a given index.
|
|
*
|
|
* @param part the CHARACTER, WORD, or SENTENCE to retrieve
|
|
* @param index an index within the text
|
|
* @return the letter, word, or sentence
|
|
*/
|
|
public String getAfterIndex(int part, int index) {
|
|
AccessibleText at = getNoteLabelAccessibleText();
|
|
if (at != null) { // JLabel contains HTML text
|
|
return at.getAfterIndex(part, index);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns the String before a given index.
|
|
*
|
|
* @param part the CHARACTER, WORD, or SENTENCE to retrieve
|
|
* @param index an index within the text
|
|
* @return the letter, word, or sentence
|
|
*/
|
|
public String getBeforeIndex(int part, int index) {
|
|
AccessibleText at = getNoteLabelAccessibleText();
|
|
if (at != null) { // JLabel contains HTML text
|
|
return at.getBeforeIndex(part, index);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns the AttributeSet for a given character at a given index
|
|
*
|
|
* @param i the zero-based index into the text
|
|
* @return the AttributeSet of the character
|
|
*/
|
|
public AttributeSet getCharacterAttribute(int i) {
|
|
AccessibleText at = getNoteLabelAccessibleText();
|
|
if (at != null) { // JLabel contains HTML text
|
|
return at.getCharacterAttribute(i);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns the start offset within the selected text.
|
|
* If there is no selection, but there is
|
|
* a caret, the start and end offsets will be the same.
|
|
*
|
|
* @return the index into the text of the start of the selection
|
|
*/
|
|
public int getSelectionStart() {
|
|
AccessibleText at = getNoteLabelAccessibleText();
|
|
if (at != null) { // JLabel contains HTML text
|
|
return at.getSelectionStart();
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Returns the end offset within the selected text.
|
|
* If there is no selection, but there is
|
|
* a caret, the start and end offsets will be the same.
|
|
*
|
|
* @return the index into the text of the end of the selection
|
|
*/
|
|
public int getSelectionEnd() {
|
|
AccessibleText at = getNoteLabelAccessibleText();
|
|
if (at != null) { // JLabel contains HTML text
|
|
return at.getSelectionEnd();
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Returns the portion of the text that is selected.
|
|
*
|
|
* @return the String portion of the text that is selected
|
|
*/
|
|
public String getSelectedText() {
|
|
AccessibleText at = getNoteLabelAccessibleText();
|
|
if (at != null) { // JLabel contains HTML text
|
|
return at.getSelectedText();
|
|
}
|
|
return null;
|
|
}
|
|
/* ===== End AccessibleText impl ===== */
|
|
}
|
|
// inner class AccessibleProgressMonitor
|
|
|
|
}
|