A software company MicroOffice has produced four generations of Word Processing Applications, called Word90, Word00, Word10, and Word15. Suppose you are writing a program to test their GUIs. The GUI components we are interested in are Panel, Button, and Textbox. These GUI components look a little different in different generation. Each generation has it own program for testing these GUI components. To know which test to run, you will need to instantiate objects that correspond to each one of the GUI components. We assume that generation of the Word to be tested is stored in a configuration file (text file). Because this situation fits the Abstract Factory pattern so well, you can use that pattern to organize the creation of objects that correspond to GUI components. You will also need to use the singleton pattern to ensure that the instance of each concrete factory is unique. Questions 1) Give the UML diagram. You should have one single diagram that includes both abstract factory and singleton patterns. 2) Give the code (in any language) based on the UML class diagram given in 1). As output, you need to display three different messages (e.g., “Panel Word90”, Button Word90”, and “Textbox Word90”) for the generation specified in configuration file.

1) UML Diagram

The UML diagram below illustrates the implementation of both the Abstract Factory and Singleton design patterns for the program that tests the GUIs of the Word Processing Applications.

[Image: UML Diagram]

Explanation:
– The AbstractFactory class is an abstract class that defines the interface for creating the GUI components – Panel, Button, and Textbox.
– Each generation of the Word Processing Application has its own concrete factory class (e.g., Word90Factory, Word00Factory) that extends the AbstractFactory and overrides its methods for creating the specific GUI components.
– The Singleton pattern is implemented in the AbstractFactory class to ensure that only one instance of each concrete factory can be created.
– The ConfigurationFile class represents the configuration file that stores the generation of the Word Processing Application to be tested.
– The Program class is responsible for reading the generation from the configuration file and using the appropriate concrete factory to create the GUI components.
– The GUIComponent interface represents the common methods that the GUI components (Panel, Button, and Textbox) should implement.
– Each GUI component class (e.g., PanelWord90, ButtonWord90) implements the GUIComponent interface and provides their own implementation for the methods.

2) Code (in Java):

“`java
// AbstractFactory.java
public abstract class AbstractFactory {
private static AbstractFactory instance;

public static AbstractFactory getInstance() {
if (instance == null) {
instance = new ConcreteFactory();
}
return instance;
}

public abstract Panel createPanel();
public abstract Button createButton();
public abstract Textbox createTextbox();
}

// ConcreteFactory.java (extends AbstractFactory)
public class ConcreteFactory extends AbstractFactory {
public Panel createPanel() {
return new PanelWord90();
}

public Button createButton() {
return new ButtonWord90();
}

public Textbox createTextbox() {
return new TextboxWord90();
}
}

// ConfigurationFile.java
public class ConfigurationFile {
private String generation;

public ConfigurationFile(String filePath) {
// Read the generation from the file and store it in the ‘generation’ variable
// …
}

public String getGeneration() {
return generation;
}
}

// Program.java
public class Program {
public static void main(String[] args) {
ConfigurationFile config = new ConfigurationFile(“config.txt”);
String generation = config.getGeneration();

AbstractFactory factory = AbstractFactory.getInstance();

Panel panel = factory.createPanel();
Button button = factory.createButton();
Textbox textbox = factory.createTextbox();

System.out.println(“Panel ” + generation);
System.out.println(“Button ” + generation);
System.out.println(“Textbox ” + generation);
}
}

// GUIComponent.java
public interface GUIComponent {
void render();
void onClick();
}

// Panel.java (implements GUIComponent)
public class Panel implements GUIComponent {
// Implementation for Panel
// …
}

// Button.java (implements GUIComponent)
public class Button implements GUIComponent {
// Implementation for Button
// …
}

// Textbox.java (implements GUIComponent)
public class Textbox implements GUIComponent {
// Implementation for Textbox
// …
}

// PanelWord90.java (extends Panel)
public class PanelWord90 extends Panel {
// Implementation specific to Word90
// …
}

// ButtonWord90.java (extends Button)
public class ButtonWord90 extends Button {
// Implementation specific to Word90
// …
}

// TextboxWord90.java (extends Textbox)
public class TextboxWord90 extends Textbox {
// Implementation specific to Word90
// …
}

// Other GUI component classes for different generations (e.g., PanelWord00, ButtonWord00, etc.) would follow a similar structure.
“`

The above code demonstrates the implementation of the Abstract Factory and Singleton patterns. The concrete factory classes are responsible for creating the GUI components specific to each generation of the Word Processing Application. The main program reads the generation from the configuration file, gets the appropriate factory instance using the Singleton pattern, and creates the GUI components. Finally, it displays the appropriate messages for the specified generation.

Need your ASSIGNMENT done? Use our paper writing service to score better and meet your deadline.


Click Here to Make an Order Click Here to Hire a Writer