Perl Scripting And Developing, Ecommerce Web Host Blog

Chapter 13 Graphical User Interface Components: Part 2 797 JSliders generate ChangeEvents (package javax.swing.event) when the user interacts with a JSlider. A ChangeListener (package javax.swing.event) defines method stateChanged that can respond to ChangeEvents. Method getValue of class JSlider returns the current thumb position. A JFrame is a window with a title bar and a border. Class JFrame is a subclass of java.awt.Frame (which is a subclass of java.awt.Window). Class JFrame supports three operations when the user closes the window. By default, a JFrame is hidden when the user closes a window. This can be controlled with JFrame method setDefaultCloseOperation. Interface WindowConstants (package javax.swing) defines three constants for use with this method DISPOSE_ON_CLOSE, DO_NOTHING_ON_CLOSE and HIDE_ON_CLOSE (the default). By default, a window is not displayed on the screen until its setVisible method is called with true as an argument. A window can also be displayed by calling its show method. A window s size should be set with a call to method setSize. The position of a window when it appears on the screen is specified with method setLocation. All windows generate window events when the user manipulates the window. Event listeners are registered for window events with method addWindowListener of class Window. The WindowListener interface provides seven methods for handling window events windowActivated (called when the window is made active by clicking the window), windowClosed (called after the window is closed), windowClosing (called when the user initiates closing of the window), windowDeactivated (called when another window is made active), window- Iconified(called when the user minimizes a window), windowDeiconified (called when a window is restored from being minimized) and windowOpened(called when a window is first displayed on the screen). The command-line arguments are automatically passed to main as the array of Strings called args. The first argument after the application class name is the first String in the array args, and the length of the array is the total number of command-line arguments. Menus are an integral part of GUIs. Menus allow the user to perform actions without unnecessarily cluttering a graphical user interface with extra GUI components. In Swing GUIs, menus can be attached only to objects of the classes that provide method set- JMenuBar. Two such classes are JFrameand JApplet. The classes used to define menus are JMenuBar, JMenuItem, JMenu, JCheckBoxMenu- Item and class JRadioButtonMenuItem. A JMenuBaris a container for menus. A JMenuItem is a GUI component inside a menu that, when selected, causes an action to be performed. A JMenuItem can be used to initiate an action or it can be a submenu that provides more menu items from which the user can select. A JMenu contains menu items and can be added to a JMenuBar or to other JMenus as submenus. When a menu is clicked, the menu expands to show its list of menu items. When a JCheckBoxMenuItem is selected, a check appears to the left of the menu item. When the JCheckBoxMenuItemis selected again, the check to the left of the menu item is removed. When multiple JRadioButtonMenuItems are maintained as part of a ButtonGroup, only one item in the group can be selected at a given time. When a JRadioButtonMenuItem is selected, a filled circle appears to the left of the menu item. When another JRadioButtonMenu- Item is selected, the filled circle to the left of the previously selected menu item is removed. JFrame method setJMenuBar attaches a menu bar to a JFrame.
Note: In case you are looking for affordable and reliable webhost to host and run your business application check Vision ftp web hosting services

796 Graphical User Interface Components: Part 2 Chapter 13 The horizontal and vertical scrollbar policies for a JScrollPane are set when a JScroll- Pane is constructed or with methods setHorizontalScrollBarPolicy and setVerticalScrollBarPolicy of class JScrollPane. A JPanel can be used as a dedicated drawing area that can receive mouse events and is often extended to create new GUI components. Swing components that inherit from class JComponent contain method paintComponent, which helps them draw properly in the context of a Swing GUI. JComponentmethod paint- Component should be overridden to call to the superclass version of paintComponent as the first statement in its body. Classes JFrameand JApplet are not subclasses of JComponent; therefore, they do not contain method paintComponent(they have method paint). Calling repaint for a Swing GUI component indicates that the component should be painted as soon as possible. The background of the GUI component is cleared only if the component is opaque. Most Swing components are transparent by default. JComponentmethod setOpaque can be passed a boolean argument indicating whether the component is opaque (true) or transparent (false). The GUI components of package java.awt are different from Swing components in that repaint results in a call to Component method update (which clears the component s background) and update calls method paint (rather than paintComponent). Method setTitle displays a String in a window s title bar. Drawing on any GUI component is performed with coordinates that are measured from the upper- left corner (0, 0) of that GUI component. Layout managers often use a GUI component s getPreferredSizemethod to determine the preferred width and height of a component when laying out that component as part of a GUI. If a new component has a preferred width and height, it should override method getPreferred- Size to return that width and height as an object of class Dimension (package java.awt). The default size of a JPanel object is 0 pixels wide and 0 pixels tall. A mouse drag operation begins with a mouse-pressed event. All subsequent mouse drag events (for which mouseDragged will be called) are sent to the GUI component that received the original mouse-pressed event. JSliders enable the user to select from a range of integer values. JSliders can display major tick marks, minor tick marks and labels for the tick marks. They also support snap-to ticks, where positioning the thumb between two tick marks causes the thumb to snap to the closest tick mark. Most Swing GUI components support user interactions through both the mouse and the keyboard. If a JSlider has the focus, the left arrow key and right arrow key cause the thumb of the JSlider to decrease or increase by 1. The down arrow key and up arrow key also cause the thumb of the JSlider to decrease or increase by 1, respectively. The PgDn key (page down) and PgUp key (page up) cause the thumb of the JSliderto decrease or increase by block increments of one-tenth of the range of values, respectively. The Home key moves the thumb to the minimum value of the JSlider and the End key moves the thumb to the maximum value of the JSlider. JSliders have either a horizontal orientation or a vertical orientation. For a horizontal JSlider, the minimum value is at the extreme left and the maximum value is at the extreme right of the JSlider. For a vertical JSlider, the minimum value is at the extreme bottom and the maximum value is at the extreme top of the JSlider. The relative position of the thumb indicates the current value of the JSlider. Method setMajorTickSpacing of class JSlider sets the spacing for tick marks on a JSlider. Method setPaintTickswith a trueargument indicates that the tick marks should be displayed.
Note: In case you are looking for affordable webhost to host and run your web application check Vision http web server services

Chapter 13 Graphical User Interface Components: Part 2 795 tainer object s method setLayout to assign the FlowLayout object to the Containerobject. In this example, the FlowLayout provides the strategy for laying out the components. Template Method The Template Method design pattern also deals with algorithms. The Strategy design pattern allows several objects to contain distinct algorithms. However, the Template Method design pattern requires all objects to share a single algorithm defined by a superclass. For example, consider the design of Fig. 13.23, which we mentioned in the Observer design pattern discussion. Objects of classes TextDisplay, BarGraphDisplay and PieChartDisplay use the same basic algorithm for acquiring and displaying the data get all statements from the BankStatementData object, parse the statements then display the statements. The Template Method design pattern allows us to create an abstract superclass called BankStatementDisplay that provides the central algorithm for displaying the data. In this example, the algorithm comprises abstract methods get- Data, parseData and displayData comprise the algorithm. Classes TextDisplay, BarGraphDisplay and PieChartDisplay extend class BankStatementDisplay to inherit the algorithm, so each object can use the same algorithm. Each BankStatementDisplay subclass then overrides each method in a way specific to that subclass, because each class implements the algorithm differently from one another. For example, classes TextDisplay, BarGraphDisplay and Pie- ChartDisplay might get and parse the data identically, but each class displays that data differently. The Template Method design pattern allows us to extend the algorithm to other Bank- StatementDisplay subclasses e.g., we could create classes, such as LineGraph- Display or class 3DimensionalDisplay, that use the same algorithm inherited from class BankStatementDisplay. 13.18.4 Conclusion In this Discovering Design Patterns section, we discussed how Swing components take advantage of design patterns and how developers can integrate design patterns with GUI applications in Java. In Discovering Design Patterns Section 15.13, we discuss concurrency design patterns, which are particularly useful for developing multithreaded systems. SUMMARY JTextAreas provide an area for manipulating multiple lines of text. Like class JTextField, class JTextArea inherits from JTextComponent. An external event (i.e., an event generated by a different GUI component) normally indicates when the text in a JTextArea should be processed. Scrollbars are provided for a JTextArea by attaching it to a JScrollPaneobject. Method getSelectedTextreturns the selected text from a JTextArea. Text is selected by dragging the mouse over the desired text to highlight it. Method setText sets the text in a JTextArea. To provide automatic word wrap in a JTextArea, attach it to a JScrollPane with horizontal scrollbar policy JScrollPane.HORIZONTAL_SCROLLBAR_NEVER.
Note: If you are looking for cheap webhost to host and run your apache application check Vision apache web hosting services

794 Graphical User Interface Components: Part 2 Chapter 13 The Java API contains classes that use the Observer design pattern. Class java.util.Observable represents a subject. Class Observable provides method addObserver, which takes a java.util.Observer argument. Interface Observer allows the Observable object to notify the Observer when the Observable objects changes state. The Observer can be an instance of any class that implements interface Observer; because the Observable object invokes methods defined in interface Observer, the objects remain loosely coupled. If a developer changes the way in which a particular Observer responds to changes in the Observable object, the developer does not need to change the Observable object. The Observable object interacts with its Observers only through interface Observer, which enables the loose coupling. The optional elevator simulation case study in the Thinking About Objects sections uses the Observer design pattern to allow the ElevatorModel object (the subject) to notify the ElevatorView object (the observer) of changes in the ElevatorModel. The simulation does not use class Observable and interface Observer from the Java library rather, it uses a custom interface ElevatorModelListener that provides functionality similar to that of interface Observable. The Swing GUI components use the Observer design pattern. GUI components collaborate with their listeners to respond to user interactions. For example, an ActionListener observes state changes in a JButton (the subject) by registering to handle that JButton s events. When pressed by the user, the JButton notifies its ActionListener objects (the observers) that the JButton s state has changed (i.e., the JButton has been pressed). Strategy The Strategy design pattern is similar to the State design pattern (discussed in Section 9.24.3). We mentioned that the State design pattern contains a state object, which encapsulates the state of a context object. The Strategy design pattern contains a strategy object, which is analogous to the State design pattern s state object. The key difference between a state object and a strategy object is that the strategy object encapsulates an algorithm rather than state information. For example, java.awt.Container components implement the Strategy design pattern using LayoutManagers (discussed in Section 12.14) as strategy objects. In package java.awt, classes FlowLayout, BorderLayout and GridLayout implement interface LayoutManager. Each class uses method addLayoutComponent to add GUI components to a Container object however, each method uses a different algorithm to display these GUI components: a FlowLayout displays components in a left-to-right sequence; a BorderLayout displays components in five regions; and a GridLayout displays components in row-column format. Class Container contains a reference to a LayoutManager object (the strategy object). Because an interface reference (i.e., the reference to the LayoutManager object) can hold references to objects of classes that implement that interface (i.e., the Flow- Layout, BorderLayoutor GridLayout objects), the LayoutManager object can reference a FlowLayout, BorderLayout or GridLayout at any one time. Class Container can change this reference through method setLayout to select different layouts at run time. Class FlowLayoutDemo (Fig. 12.24) demonstrates the application of the Strategy pattern line 16 declares a new FlowLayout object and line 19 invokes the Con
Note: In case you are looking for affordable webhost to host and run your servlet application check Vision servlet hosting services

Chapter 13 Graphical User Interface Components: Part 2 793 then be added to a menu, toolbar, popup menu or other mechanisms. This design pattern is called Command because it defines a user command, or instruction. This pattern allows a designer to encapsulate a command, so that the command may be used among several objects. Observer Suppose we want to design a program for viewing bank account information. This system includes class BankStatementData to store data pertaining to bank statements, and classes TextDisplay, BarGraphDisplay and PieChartDisplay to display the data.2 Figure 13.23 shows the design for our system. Class TextDisplay displays the data in text format, class BarGraphDisplay displays the data in bar-graph format and class PieChartDisplaydisplays the data as a pie chart. We want to design the system so that the BankStatementData object notifies the objects displaying the data of a change in the data. We also want to design the system to loosen coupling the degree to which classes depend on each other in a system. Software Engineering Observation 13.9 Loosely-coupled classes are easier to reuse and modify than are tightly-coupled classes, which depend heavily on each other. A modification in a class in a tightly-coupled system usually results in modifying other classes in that system. A modification to one of a group of loosely-coupled classes would require little or no modification to the other classes in the group. The Observer design pattern is appropriate for systems like that of Fig. 13.23. This pattern promotes loose coupling between a subject object and observer objects a subject notifies the observers when the subject changes state. When notified by the subject, the observers change in response to the change in the subject. In our example, the Bank- StatementData object is the subject, and the objects displaying the data are the observers. A subject can notify several observers; therefore, the subject contains a one-tomany relationship with the observers. notifies notifies notifies BankStatementData TextDisplay BarGraphDisplay PieChartDisplay Fig. 13.23Basis for the Observer design pattern. 13.23 2. This approach is the basis for the Model-View-Controller architecture pattern, discussed in Sections 13.17 and 17.11.
Note: In case you are looking for affordable and reliable webhost to host and run your j2ee application check Vision web design programs services

792 Graphical User Interface Components: Part 2 Chapter 13 13.18.3 Behavioral Design Patterns In this section, we continue our discussion on behavioral design patterns. We discuss the Chain-of-Responsibility, Command, Observer, Strategy and Template Method design patterns. Chain-of-Responsibility In object-oriented systems, objects interact by sending messages to one another. Often, a system needs to determine at run time the object that will handle a particular message. For example, consider the design of a three-line office phone system. When a person calls the office, the first line handles the call if the first line is busy, the second line handles the call, and if the second line is busy, the third line handles the call. If all lines in the system are busy, an automated speaker instructs that person to wait for the next available line when a line becomes available, that line handles the call. The Chain-of-Responsibility design pattern enables a system to determine at run time the object that will handle a message. This pattern allows an object to send a message to several objects in a chain of objects. Each object in the chain either may handle the message or pass the message to the next object in the chain. For instance, the first line in the phone system is the first object in the chain of responsibility, the second line is the second object, the third line is the third object, and the automated speaker is the fourth object. Note that this mechanism is not the final object in the chain the next available line handles the message, and that line is the final object in the chain. The chain is created dynamically in response to the presence or absence of specific message handlers. Several Java AWT GUI components use the Chain-of-Responsibility design pattern to handle certain events. For example, class java.awt.Button overrides method processEvent of class java.awt.Component to process AWTEvent objects. Method processEvent attempts to handle the AWTEvent upon receiving this event as an argument. If method processEvent determines that the AWTEvent is an ActionEvent (i.e., the Button has been pressed), the method handles the event by invoking method processActionEvent, which informs any ActionListener registered with the Button that the Button has been pressed. If method processEvent determines that the AWTEvent is not an ActionEvent, the method is unable to handle the event and passes the AWTEvent to method processEvent of superclass Component (the next object in the chain). Command Applications often provide users with several ways to perform a given task. For example, in a word processor there might be an Edit menu with menu items for cutting, copying and pasting text. There could also be a toolbar and/or a popup menu offering the same items. The functionality the application provides is the same in each case the different interface components for invoking the functionality are provided for the user’s convenience. However, the same GUI component instance (e.g., JButton) cannot be used for menus and toolbars and popup menus, so the developer must code the same functionality three times. If there were many such interface items, repeating this functionality would become tedious and error-prone. The Command design pattern solves this problem by enabling developers to specify the desired functionality (e.g., copying text) once in a reusable object; that functionality can
Note: If you are looking for high quality webhost to host and run your jsp application check Vision florida web design services

Chapter 13 Graphical User Interface Components: Part 2 791 Composite Designers often organize components into hierarchical structures (e.g., a hierarchy of directories and files on a hard drive) each node in the structure represents a component (e.g., a file or directory). Each node can contain references to other nodes. A node is called a branch if it contains a reference to one or more nodes (e.g., a directory containing files). A node is called a leaf if it does not contain a reference to another node (e.g., a file). Occasionally, a structure contains objects from several different classes (e.g., a directory can contain files and directories). When an object called a client wants to traverse the structure, the client must determine the particular class for each node. Making this determination can be time consuming, and the structure can become hard to maintain. In the Composite design pattern, each component in a hierarchical structure implements the same interface or extends a common superclass. This polymorphism (introduced in Section 9.10) ensures that clients can traverse all elements branch or leaf uniformly in the structure. Using this pattern, a client traversing the structure does not have to determine each component type, because all components implement the same interface or extend the same superclass. Java GUI components use the Composite design pattern. Consider the Swing component class JPanel, which extends class JComponent. Class JComponent extends class java.awt.Container, which extends class java.awt.Component (Fig. 13.22). Class Container provides method add, which appends a Component object (or Componentsubclass object) to that Containerobject. Therefore, a JPanel object may be added to any object of a Componentsubclass, and any object from a Componentsubclass may be added to that JPanelobject. A JPanelobject can contain any GUI component while remaining unaware of that component s specific type. A client, such as a JPanelobject, can traverse all components uniformly in the hierarchy. For example, if the JPanel object calls method repaint of superclass Container, method repaintdisplays the JPanelobject and all components added to the JPanel object. Method repaint does not have to determine each component s type, because all components inherit from superclass Container, which contains method repaint. javax.swing.JComponent javax.swing.JPanel java.awt.Container java.awt.Component Fig. 13.22 Inheritance hierarchy for class JPanel.
Note: In case you are looking for affordable and reliable webhost to host and run your business application check Vision ftp web hosting services

790 Graphical User Interface Components: Part 2 Chapter 13 pattern is similar to an adapter for a plug on an electrical device electrical sockets in Europe are different from those in the United States, so an adapter is needed to plug an American device into a European electrical socket and vice versa. Java provides several classes that use the Adapter design pattern. Objects of these classes act as adapters between objects that generate certain events and those objects that handle these events. For example, a MouseAdapter, which we explained in Section 12.12, adapts an object that generates MouseEvents to an object that handles MouseEvents. Bridge Suppose we are designing class Button for both the Windows and Macintosh operating systems. Class Button contains specific button information such as an ActionListener and a String label. We design classes Win32Button and MacButton to extend class Button. Class Win32Button contains look-and-feel information on how to display a Button on the Windows operating system and class MacButton contains look-and-feel information on how to display a Button on the Macintosh operating system. Two problems arise from this approach. First, if we create new Button subclasses, we must create corresponding Win32Button and MacButton subclasses. For example, if we create class ImageButton (a Button with an overlapping Image) that extends class Button, we must create additional subclasses Win32ImageButton and MacImageButton. In fact, we must create Button subclasses for every operating system we wish to support, which increases development time. The second problem is that when a new operating system enters the market, we must create additional Button subclasses specific to that operating system. The Bridge design pattern avoids these problems by separating an abstraction (e.g., a Button) and its implementations (e.g., Win32Button, MacButton, etc.) into different class hierarchies. For example, the Java AWT classes use the Bridge design pattern to enable designers to create AWT Button subclasses without needing to create corresponding subclasses for each operating system. Each AWT Button maintains a reference to a ButtonPeer, which is the superclass for platform-specific implementations, such as Win32ButtonPeer, MacButtonPeer, etc. When a programmer creates a Button object, class Button calls factory method createButton of class Toolkit to create the platform-specific ButtonPeer object. The Button object stores a reference to its ButtonPeer this reference is the bridge in the Bridge design pattern. When the programmer invokes methods on the Button object, the Button object invokes the appropriate method on its ButtonPeer to fulfill the request. If a designer creates a Button subclass called ImageButton, the designer does not need to create a corresponding Win32ImageButton or MacImageButton with platform-specific image-drawing capabilities. An ImageButton is a Button. Therefore, when an ImageButton needs to display its image, the ImageButton uses its ButtonPeer s Graphics object to render the image on each platform. This design pattern enables designers to create new cross-platform GUI components using a bridge to hide platform-specific details. Portability Tip 13.2 Designers often use the Bridge design pattern to enhance the platform independence of their systems. This design pattern enables designers to create new cross-platform components using a bridge to hide platform-specific details.
Note: If you are looking for cheap and reliable webhost to host and run your mysql application check Vision professional web hosting services

Chapter 13 Graphical User Interface Components: Part 2 789 should understand better how these components take advantage of design patterns and how developers integrate design patterns with Java GUI applications. 13.18.1 Creational Design Patterns Now, we continue our treatment of creational design patterns, which provide ways to instantiate objects in a system. Factory Method Suppose we are designing a system that opens an image from a specified file. Several different image formats exist, such as GIF and JPEG. We can use method createImageof class java.awt.Component to create an Image object. For example, to create a JPEG and GIF image in an object of a Component subclass such as a JPanel object, we pass the name of the image file to method createImage, which returns an Image object that stores the image data. We can create two Imageobjects, each which contains data for two images having entirely different structures. For example, a JPEG image can hold up to 16.7 million colors, whereas a GIF image can hold up to only 256. Also, a GIF image can contain transparent pixels that are not rendered on screen, whereas a JPEG image cannot contain transparent pixels. Class Image is an abstract class that represents an image we can display on screen. Using the parameter passed by the programmer, method createImage determines the specific Imagesubclass from which to instantiate the Imageobject. We can design systems to allow the user to specify which image to create, and method createImage will determine the subclass from which to instantiate the Image. If the parameter passed to method createImagereferences a JPEG file, method createImage instantiates and returns an object of an Imagesubclass suitable for JPEG images. If the parameter references a GIF file, createImage instantiates and returns an object of an Image subclass suitable for GIF images. Method createImageis an example of the Factory Method design pattern. The sole purpose of this factory method is to create objects by allowing the system to determine which class to instantiate at run time. We can design a system that allows a user to specify what type of image to create at run time. Class Component might not be able to determine which Image subclass to instantiate until the user specifies the image to load. For more information on method createImage, visit www.java.sun.com/j2se/1.3/docs/api/java/awt/Compo nent.html#createImage(java.awt.image.ImageProducer) 13.18.2 Structural Design Patterns We now discuss three more structural design patterns. The Adapter design pattern helps objects with incompatible interfaces collaborate with one another. The Bridge design pattern helps designers enhance platform independence in their systems. The Composite design pattern provides a way for designers to organize and manipulate objects. Adapter The Adapter design pattern provides an object with a new interface that adapts to another object s interface, allowing both objects to collaborate with one another. The adapter in this
Note: In case you are looking for affordable webhost to host and run your servlet application check Vision make web site services

788 Graphical User Interface Components: Part 2 Chapter 13 32 33 // register View for Model events 34 model.setElevatorModelListener( view ); 35 36 // add view and controller to ElevatorSimulation 37 getContentPane().add( view, BorderLayout.CENTER ); 38 getContentPane().add( controller, BorderLayout.SOUTH ); 39 40 } // end ElevatorSimulation constructor 41 42 // main method starts program 43 public static void main( String args[] ) 44 { 45 // instantiate ElevatorSimulation 46 ElevatorSimulation simulation = new ElevatorSimulation(); 47 simulation.setDefaultCloseOperation( EXIT_ON_CLOSE ); 48 simulation.pack(); 49 simulation.setVisible( true ); 50 } 51 } Fig. 13.21 Class ElevatorSimulationis the application for the elevator simulation (part 2 of 2). The class diagram of Fig. 13.19 specifies that class ElevatorSimulation is a subclass of javax.swing.JFrame line 16 declares class ElevatorSimulation as a public class extending class JFrame. Lines 19 21 implement class Elevator- Simulation s aggregation of class ElevatorModel, the ElevatorView and the ElevatorController (shown in Fig. 13.19) by declaring one object from each class. Lines 29 31 of the ElevatorSimulationconstructor initialize these objects. Figure 13.19 and Fig. 13.20 specify that the ElevatorViewis an ElevatorModelListenerfor the ElevatorModel. Line 34 registers the ElevatorViewas a listener for ElevatorModelEvents, so the ElevatorViewcan receive events from the ElevatorModel and properly represent the state of the model. Lines 37 38 add the ElevatorView and the ElevatorController to the ElevatorSimulation. According to the stereotypes in Fig. 13.20, ElevatorSimulation.javacompiles to ElevatorSimulation.class, which is executable lines 43 50 provide method mainthat runs the application. We have completed the design of the components of our system. Thinking About Objects Section 15.12 concludes the design of the model by solving the interaction problems encountered in Fig. 10.26. Finally, Section 22.9 completes the design of the view and describes in greater detail how the ElevatorView receives events from the ElevatorModel. These last two sections will prepare you for the walkthrough of our elevator- simulation implementation in Appendices G, H and I. 13.18 (Optional) Discovering Design Patterns: Design Patterns Used in Packages java.awtand javax.swing We continue our discussion from Section 9.24 on design patterns. This section introduces those design patterns associated with Java GUI components. After reading this section, you
Note: In case you are looking for affordable webhost to host and run your servlet application check Vision make web site services