The document discusses Swing components in Java, including top-level containers like JFrame and JDialog, content panes, menu bars, models, text components, and the document model. It describes the component hierarchy, adding components, models, text editing actions, undo/redo functionality, and the role of the document object.

1. Swing- Introduction Swing provides three generally useful top-level container classes: JFrame , JDialog , and JApplet . Every GUI component must be part of a containment hierarchy . A containment hierarchy is a tree of components that has a top-level container as its root. Each GUI component can be contained only once. If a component is already in a container and you try to add it to another container, the component will be removed from the first container and then added to the second.

2. Swing- Introduction Each top-level container has a content pane that, generally speaking, contains (directly or indirectly) the visible components in that top-level container's GUI. You can optionally add a menu bar to a top-level container. The menu bar is by convention positioned within the top-level container, but outside the content pane.

3. Swing Introduction Adding Components to the Content Pane frame.getContentPane().add(yellowLabel, BorderLayout.CENTER); The default content pane is a simple intermediate container that inherits from JComponent, and that uses a BorderLayout as its layout manager. If you create your own content pane, make sure it's opaque. An opaque JPanel object makes a good content pane. Note that the default layout manager for JPanel is FlowLayout. Create a panel and add components to it. JPanel contentPane = new JPanel(new BorderLayout()); contentPane.setBorder( someBorder ); contentPane.add( someComponent , BorderLayout.CENTER); contentPane.add( anotherComponent , BorderLayout.PAGE_END); //Make it the content pane. contentPane.setOpaque(true); topLevelContainer .setContentPane(contentPane);

4. Swing- Introduction Adding a Menu Bar To add a menu bar to a top-level container, you create a JMenuBar object, populate it with menus, and then call setJMenuBar. frame.setJMenuBar(cyanMenuBar); The Root Pane Each top-level container relies on a reclusive intermediate container called the root pane . The root pane manages the content pane and the menu bar, along with a couple of other containers . The two other components that a root pane adds are a layered pane and a glass pane. The layered pane directly contains the menu bar and content pane, and enables Z-ordering of other components you might add.

5. Swing – Component Models Most noncontainer Swing components have models. A button (JButton), for example, has a model (a ButtonModel object) that stores the button's state — what its keyboard mnemonic is, whether it's enabled, selected, or pressed, and so on. Some components have multiple models. A list (JList), for example, uses a ListModel to hold the list's contents, and a ListSelectionModel to track the list's current selection. You often don't need to know about the models that a component uses. Why then do models exist? The biggest reason is that they give you flexibility in determining how data is stored and retrieved. For example, if you're designing a spreadsheet application that displays data in a sparsely populated table, you can create your own table model that is optimized for such use.

6. Swing - MVC Model Although Swing's model architecture is sometimes referred to as a Model-View-Controller (MVC) design, it really isn't. Swing components are generally implemented so that the view and controller are indivisible, implemented by a single UI object provided by the look and feel. The Swing model architecture is more accurately described as a separable model architecture .

7. Swing – JComponent Class With the exception of top-level containers, all Swing components whose names begin with "J" descend from the JComponent class. For example, JPanel, JScrollPane, JButton, and JTable all inherit from JComponent. However, JFrame and JDialog don't because they implement top-level containers. The JComponent class extends the Container class, which itself extends Component . The Component class includes everything from providing layout hints to supporting painting and events. The Container class has support for adding components to the container and laying them out.

8. Swing – Text Component JTextComponent is the foundation for Swing's text components, and provides these customizable features for all of its descendants: A model, known as a document , to manage the component's content. A view, which is in charge of displaying the component on screen. A controller, known as an editor kit , that can read and write text and that implements editing capabilities with actions . Support for infinite undo and redo. Pluggable caret and support for caret change listeners and navigation filters.

9. Swing – Text Component Associating Text Actions with Menus and Buttons All Swing text components supports standard editing commands such as cut, copy, paste, and inserting characters. Each editing command is represented and implemented by an Action object. textComponent..getActions() returns all the supported by this particular text component. Steps to use actions: Build an hashmap of all the actions with action name as key to stored action object. Make a method getActionByName that action name returns action object. Now to make a cut menu items write following code: JMenu menu = new JMenu("Edit"); menu.add(getActionByName(DefaultEditorKit.cutAction)); DefaultEditorkit kit provides actions for basic text editing and is the superclass for all the editor kits provided by Swing

10. Swing – Text Component Associating Text Actions with Menus and Buttons code that creates the Style menu and puts the Bold menu item in it: protected JMenu createStyleMenu() { JMenu menu = new JMenu("Style"); Action action = new StyledEditorKit.BoldAction(); action.putValue(Action.NAME, "Bold"); menu.add(action); . . . The StyledEditorKit provides Action subclasses to implement editing commands for styled text.

11. Swing – Text Component Associating Text Actions with key strokes In addition to associating an action with a GUI component, you can also associate an action with a key stroke, using a text component's input map. following code adds the CTRL-B key binding to the text pane. InputMap inputMap = textPane.getInputMap(); KeyStroke key = KeyStroke.getKeyStroke(KeyEvent.VK_B, Event.CTRL_MASK); inputMap.put(key, DefaultEditorKit.backwardAction);

12. Swing – Text Component Implementing Undo and Redo Implementing undo and redo has two parts: Remembering undoable edits . Implementing the undo and redo commands and providing a user interface for them. Remembering Undoable Edits To support undo and redo, a text component must remember each edit that occurs, the order of edits, and what it takes to undo each edit. The example program uses an instance of the UndoManager class to manage its list of undoable edits. protected UndoManager undo = new UndoManager(); A document notifies interested listeners whenever an undoable edit occurs on its content. lsd.addUndoableEditListener(new MyUndoableEditListener()); The undoable edit listener used adds the edit to the undo manager's list:

13. Swing – Text Component Implementing Undo and Redo Part2: Implementing Undo and Redo commands JMenu menu = new JMenu("Edit"); //Undo and redo are actions of our own creation undoAction = new UndoAction(); menu.add(undoAction); redoAction = new RedoAction(); menu.add(redoAction); ...

14. Swing – Text Component Implementing Undo and Redo Part2: Implementing Undo and Redo commands The undo and redo actions are implemented by custom AbstractAction subclasses: UndoAction and RedoAction, respectively. When the user invokes the Undo command, UndoAction's actionPerformed method, shown here, gets called: public void actionPerformed(ActionEvent e) { try { undo.undo(); } catch (CannotUndoException ex) { System.out.println("Unable to undo: " + ex); ex.printStackTrace(); } updateUndoState(); redoAction.updateRedoState(); } This method calls the undo manager's undo method and updates the menu items to reflect the new undo/redo state.

15. Swing – Text Component About Document Object A text component's model is known as a document and is an instance of a class that implements the Document interface. A document provides these services for a text component: Contains the text. A document stores the textual content in Element objects, which can represent any logical text structure, such as paragraphs, text runs that share styles, and so on. We do not cover Elements. However, The Swing Connection has at least one article on the subject. Provides support for editing the text through the remove and insertString methods. Notifies document listeners and undoable edit listeners of changes to the text. Manages Position objects, which track a particular location within the text even as the text is modified. Allows you to get information about the text, such as its length, and segments of the text as a string.

16. Swing – Text Component About Document Object Notifies document listeners and undoable edit listeners of changes to the text. Manages Position objects, which track a particular location within the text even as the text is modified. Allows you to get information about the text, such as its length, and segments of the text as a string.