AT&T Home | AT&T Labs | Research
AT&T Labs, Inc. - Research

The Yoix® Scripting Language

Home | What's New | Grammar | Documentation | Download | License | YChart | YDAT | YWAIT | Byzgraf | FAQs
JProgressBar typedict
 
A JProgressBar is the interface to the Java Swing JProgressBar Component. Yoix programs normally interact with a JProgressBar using event handlers and by reading or writing the following fields:
background The Color that is used to paint the background of the progressbar. It is also the color used to paint the portion of the text that is drawn over the bar that is displayed by the progressbar. Reading returns a snapshot of the current color. Writing immediately changes the background to the new color. Storing NULL in background is special and means use the background of the nearest component that contains the progressbar and was assigned a background color other than NULL; if no component qualifies the progressbar uses VM.screen.background.
border An Object that should be a Border, Insets, Number, or String that describes the border that is drawn around this progressbar. A NULL value, which is the default, means no border. A border that is an Insets or Number is an easy way to describe margins (i.e., an EmptyBorder), in units of 72 dots per inch, that are left around the sides of this progressbar. A border that is a String is a quick way to surround this progressbar with a border that uses the String as its title. Reading returns a snapshot of the current border. Writing immediately sets the progressbar's border to the new value.
cursor An Object that should be an int, Image, or String that selects the cursor shown when the pointer is over the progressbar. A cursor that is an int should be one of the cursors defined in the yoix.awt.Cursor dictionary. A cursor that is an Image can describe the cursor using its size and hotspot fields and often draws it using its paint function. A cursor that is a String should be the name of a cursor that is already defined in yoix.awt.Cursor or the name a local a file or URL that contains a GIF or JPEG image that will be used as the cursor.

Reading returns the current cursor. Writing immediately changes the progressbar's cursor to the new value. Storing STANDARD_CURSOR (the default) or NULL in cursor is special and means use the cursor assigned to the nearest component that contains the progressbar and was assigned a cursor other than STANDARD_CURSOR; if no component qualifies the progressbar uses DEFAULT_CURSOR.

doublebuffered An int that is 1 when the progressbar uses double-buffering to draw itself, 0 when it does not, and starts with a default value that is selected by Java for the progressbar. Reading returns the current double-buffering behavior. Writing immediately sets the progressbar's double-buffering behavior to the new value. Note that double-buffering may be required when transparent components are used.
dragenabled An int that should be set to 1 when this progressbar wants to use the automatic drag handling that Swing provides for some components, and 0 (the default) when it does not. Components that do not provide automatic drag handling always return 0 when their dragenabled field is read, so storing 1 in dragenabled should only be viewed as a request for a service that may not be available. Swing components can always take complete control of their drag and drop handling using their transferhandler field or special drag and drop event handlers.
enabled An Object that is 1 when the progressbar can respond to user input, 0 when it can not respond, and NULL (the default) when the progressbar inherits the value from the nearest lightweight container, like a JPanel, that contains the progressbar and has its enabled field set to something other than NULL. The top-level application window that contains the progressbar always gets the final say, so disabling that window always disables the progressbar. Reading returns the current state. Writing immediately sets the progressbar's state to the new value.
focusowner A read-only int that is non-zero when the progressbar has the focus.
font The Font, or font name if it is a String, used to paint the characters stored in the text field. Reading returns a snapshot of the current font. Writing immediately repaints the text in the new font.
foreground The Color that is used to paint the completed portion of the progressbar. It is also the color used to paint the portion of the text that is not drawn over the bar that is displayed by the progressbar. Reading returns a snapshot of the current color. Writing immediately repaints the progressbar using the new color. Storing NULL in foreground is special and means use the foreground of the nearest component that contains the progressbar and was assigned a foreground color other than NULL; if no component qualifies the progressbar uses VM.screen.foreground.
indeterminate An int that is 1 when the progressbar uses animation to indicate that work is occurring and 0 (the default) when changes in value and text are the only indications of progress. Reading returns the current indeterminate state. Writing immediately sets the progressbar's indeterminate state to the new value. Some version of Java, particularly older ones, do not support the indeterminate state, so changing this value will sometimes have no effect.
layer An int, often a small number between 0 and 99, that identifies the depth of this progressbar when it is added to a JLayeredPane or JDesktopPane. Components assigned to lower numbered layers are drawn before the components in higher numbered layers. Writing immediately changes the progressbar's layer, which usually means the JLayeredPane or JDesktopPane that contains the progressbar will be repainted.
location A Point that determines the location of the progressbar in a coordinate system that has its origin at the upper left corner of the container closest to the progressbar (in the component hierarchy) that actually contains it, positive x to the right, positive y down, and a resolution of 72 dots per inch. Reading returns a snapshot of the current location. Writing is allowed, but layout managers usually get the final say, so setting location should be viewed as a request that may not be honored.
maximum An int that is the largest value represented by the progressbar. Reading returns the current maximum. Writing immediately sets the progressbar's maximum to the new value.
minimum An int that is the smallest value represented by the progressbar. Reading returns the current minimum. Writing immediately sets the progressbar's minimum to the new value.
nextfocus An Object that is the component that receives the focus after this progressbar when the focus traverses from one component to the next (usually by means of the keyboard TAB character). A NULL value indicates that the default Java focus traversal is in effect. Reading returns the value last stored. Writing immediately sets the new focus traversal behavior.
opaque An Object that is 1 when the progressbar is opaque, 0 when it is transparent, and NULL (the default) when the progressbar inherits the value from the nearest component that contains the progressbar and has its opaque field set to something other than NULL.
orientation An int that determines the direction that the progressbar's bar moves. The value should be HORIZONTAL or VERTICAL, which are defined in yoix.swing. Reading returns the current orientation. Writing immediately sets the progressbar's orientation to the new value.
percentcomplete A read-only double that represents the work currently done as percent (i.e., it is a number between 0 and 100). The value can also be calculated directly from the minimum, maximum, and value fields.
popup A JPopupMenu that is associated with the progressbar. Reading returns the current popup menu. Writing immediately shows the popup menu at the point in the progressbar's coordinate system specified by the popup menu's location field, assuming of course that the progressbar is showing on the screen. Storing TRUE in the popup menu's visible field, which was added in release 1.2.0, is an easy way to show the popup menu that currently belongs to the progressbar.
preferredsize A Dimension that is used by layout managers when they need to know the progressbar's preferred size in units of 72 dots per inch. A NULL value means the progressbar has no preference. A non-positive height or width is allowed and simply means the progressbar has no preference for that dimension. Reading returns the current preferred size. Writing changes the preferred size and immediately notifies root.layoutmanager, which means the components contained in root may be repositioned and resized.
requestfocus An int that can be used to request or transfer the keyboard focus. Storing a non-zero value in requestfocus tries to get the focus. Storing 0 tries to transfer the focus. Reading requestfocus does not currently return any useful information.
requestfocusenabled An int that is 1 (the default) when actions, like mouse clicks or changes to the requestfocus field, can steal the keyboard focus and 0 when they can not. Note that this field does not affect acceptance of the keyboard focus during normal focus traversal. Reading returns the current state. Writing immediately sets the progressbar's state to the new value.
root An Object that is automatically updated by the interpreter's layout machinery so it is always the top-level object that contains the progressbar. For example, put a progressbar in a panel and root will be set to that panel; add the panel to a frame and the progressbar's root field will be set to that frame. A progressbar's event handlers can use root when they need to interact with the other components in the container.
showing A read-only int that is non-zero when the progressbar is showing on the screen.
size A Dimension that determines the size of the progressbar in units of 72 dots per inch. Reading returns a snapshot of the current size. Writing is allowed, but layout managers usually get the final say, so setting size should be viewed as a request that may not be honored.
tag A String used to identify the progressbar that is either supplied when the progressbar is declared, or automatically generated otherwise. Add a progressbar to a container, like a JFrame or JPanel, and the interpreter's layout machinery updates the root field so it points at the top-level container and then adds the progressbar, as tag, to the root.components dictionary.
text A String of characters that is displayed by the progressbar. Reading returns the current text. Writing immediately paints the new text.
tooltiptext A String of characters that is displayed in a tightly sized pop-up window that appears near the cursor whenever the cursor lingers over the progressbar. Setting this value to NULL (the default) disables the tooltip mechanism. Reading returns the current tooltip text. Writing immediately sets the new tooltip text.
transferhandler An Object that should be a TransferHandler or String that determines how the progressbar handles data transfer operations like drag and drop. A value that is a String but not "" means the field named by the String should be used as the source and sink of the data that is transferred by the progressbar. The result is the same as assigning the String to the property field in a TransferHandler and then assigning that TransferHandler to transferhandler. The empty String "" is special and refers to the TransferHandler that Swing uses for automatic drag handling, if there is one.

Swing components that provide automatic drag handling start out with a transferhandler field that is not NULL, but the automatic drag handling is not enabled until 1 is stored in dragenabled. Swing components that provide their own drag and drop event handlers currently must store NULL in transferhandler before those event handlers will start working.

value An int that is the current value of the progressbar, which is forced into the range
minimum <= value <= maximum
and used to determine the length of the bar displayed by the progressbar. Reading returns the current value. Writing immediately sets the new value and updates the bar displayed by the progressbar.
visible An int that is 1 when the progressbar is visible, and 0 otherwise. Reading returns the current visibility. Writing immediately sets the progressbar's visibility to the new state.
Several permanent fields have not been documented and should not be used in Yoix applications. Event handlers are functions that must be added to a progressbar when it is declared. The handlers that work with progressbars are listed below; the names should be familiar if you have done some Java programming. The actionPerformed and itemStateChanged event handlers are only for menus.
 
 Event Handlers:   actionPerformed, componentHidden, componentMoved, componentResized, componentShown, dragDropEnd, dragEnter, dragExit, dragGestureRecognized, dragMouseMoved, dragOver, drop, dropActionChanged, focusGained, focusLost, invocationRun, itemStateChanged, keyPressed, keyReleased, keyTyped, mouseClicked, mouseDragged, mouseEntered, mouseExited, mouseMoved, mousePressed, mouseReleased, mouseWheelMoved
 
 Example:   The program,
import yoix.*.*;

JFrame f = {
    Dimension size = NULL;

    GridBagLayout layoutmanager;
    Array layout = {
        new JProgressBar {
            String tag = "$_progress";
            String text = "this is a test...";
            Color  background = Color.yellow;
            Color  foreground = Color.blue;
            int    maximum = 500;
            int    minimum = 400;
            int    value = 10;

            Increment(int delta) {
                value += delta;
                text = toString((int)percentcomplete) + "%";
            }
        },
        new GridBagConstraints {
            int gridwidth = REMAINDER;
            int weightx = 100;
            int weighty = 100;
            int fill = HORIZONTAL;

            Insets insets = {
                double top = 72.0/2;
                double left = 72.0/4;
                double right = 72.0/4;
            };
        },

        new JCheckBox {
            String text = "indeterminate";
            int    state = 0;

            itemStateChanged(e) {
                root.components.$_progress.indeterminate = state;
            }
        },
        new GridBagConstraints {
            int gridwidth = REMAINDER;
            int anchor = LEFT;

            Insets insets = {
                double left = 72.0/4;
                double right = 72.0/4;
            };
        },

        new JPanel {
            Array layout = {
                new JButton {
                    String text = "Increment";

                    actionPerformed(e) {
                        root.components.$_progress.Increment(10);
                    }
                },
                new JButton {
                    String text = "Decrement";

                    actionPerformed(e) {
                        root.components.$_progress.Increment(-10);
                    }
                },
                new JButton {
                    String text = "Dismiss";

                    actionPerformed(e) {
                        exit(0);
                    }
                },
            };
        },
        new GridBagConstraints {
            int gridwidth = REMAINDER;

            Insets insets = {
                double top = 72.0/4;
                double left = 72.0;
                double bottom = 72.0/8;
                double right = 72.0;
            };
        },
    };
};

f.visible = TRUE;
puts a progressbar in a frame with several buttons and a checkbox that let you experiment with different settings and observe the behavior of the progressbar.
 
 See Also:   appendText, BevelBorder, Border, EmptyBorder, EtchedBorder, invokeLater, JButton, JCanvas, JCheckBox, JCheckBoxMenuItem, JChoice, JColorChooser, JComboBox, JDesktopPane, JDialog, JFileChooser, JFileDialog, JFrame, JInternalFrame, JLabel, JLayeredPane, JList, JMenu, JMenuBar, JMenuItem, JPanel, JPasswordField, JPopupMenu, JRadioButton, JRadioButtonMenuItem, JScrollBar, JScrollPane, JSeparator, JSlider, JSplitPane, JTabbedPane, JTable, JTextArea, JTextCanvas, JTextField, JTextPane, JTextTerm, JToggleButton, JToolBar, JTree, JWindow, LineBorder, MatteBorder, postEvent, SoftBevelBorder, TransferHandler

 

Yoix is a registered trademark of AT&T Inc.