jsugar | Gitar

Window.java: Added an addComponent() method, so that a user can add components himself, but also an easy way to add components made by Window itself, as it automatically updates the GUI.

Author: Vngngdn
Date: July 17, 2016, 12:32 p.m.
Hash: 44274335ba7708f829b41feed4164af7077170dd
Parent: 807d67f05369fda64ade9860e2e51368e71a6f7b
Modified file: Window.java

Window.java ¶

17 additions and 3 deletions.

View changes Hide changes

 * Window.java - Module to create a new window with JSugar.
 * Copyright © 2016 Maarten "Vngngdn" Vangeneugden
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

/**
 * Window class for the program.
 *
 * Window contains the necessary data and methods to present the user with what
 * he's familiar with as being a "window". To make it functional, the developer
 * can make use of a series of methods to add components to said window, remove
 * components, and so on.
 * Currently, Window also contains methods to show dialogs. This will be cleaned
 * in the near future.
 * @author Maarten Vangeneugden
 */
import javax.swing.*; // FIXME: Maybe namespacing it to "javax.swing;" is a better idea.
import java.util.NoSuchElementException;
import java.lang.reflect.Method;

class Window {
	private JPanel panel; // The panel that contains all the components.
	private JFrame frame; // The "window" being presented to the user.

	/**
	 * Constructor of Window.
	 * By creating a new Window instance, this constructor will automatically
	 * start the initialization of the GUI. After doing so, the caller can
	 * start adding components to the window as pleased.
	 * @param title The title to be shown in the window's title bar.
	 */
	public Window() {
		this.panel = new JPanel();
		// TODO: The current title is "Hello world!" but that will become caller
		// defined soon.
		JFrame frame = new JFrame("Hello world!");
		// Makes it so that if the user clicks the X in the titlebar, the window
		// closes:
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		//frame.getContentPane().add(lblHelloWorld); // So you use a get() in order to set() data? #JavaWTF
		frame.setContentPane(this.panel); // Connecting the component panel to the window.
		// Makes the window fit to the necessary width and height, so it can show all "subcomponents".
		frame.pack(); 	
		frame.setVisible(true); // Makes the window visible to the user.
		this.frame = frame;
	}

	/**
	 * Resizes the window to fit all components.
	 * By calling this method, the window will evaluate the currently visible
	 * components, and resize itself so that all components become properly
	 * visible.
	 */
	private void updateWindow() {
		this.frame.pack();
	}

	/**
	 * A series of tests for method and class handling.
	 * When a caller presents certain methods with data concerning reflection,
	 * the Java classes you need to use for that are quite opaque, and don't
	 * offer much safety in any way.
	 * The solution therefore, is run some validation checks, but these take up
	 * a decent amount of space in terms of LoC.
	 * This method takes care of all that. Call this function whenever data
	 * needs to be validated.
	 * @param methodName The name of the method, as it is declared in object.
	 * @param object The class instance in where this method will be called.
	 * @return The method that could be derived from the supplied data, or null
	 * if that wasn't possible.
	 * @throws NullPointerException if either methodName or object are null
	 * pointers.
	 * @throws IllegalArgumentException if methodName is empty, or the method
	 * does not appear to be declared in the given object, or object is not a
	 * class.
	 */
	// All unchecked typecasts are safe, and the use of raw types is taken care
	// of.
	@SuppressWarnings({"unchecked","rawtypes"})
	private Method handleReflectionData(String methodName, Object object) {
		// Null pointer checking:
		if (methodName == null || object == null) {
			throw new NullPointerException("One or more of the given parameters are null pointers.");
		}

		// XXX: Some might say the next line should be in an else{} block. But
		// Scoping rules require that I'd then have to wrap the rest of the
		// method in the same else to use it.
		Class methodClass = object.getClass(); 
		if (methodName.equals("")) {
			throw new IllegalArgumentException("The given methodName was empty.");
		}
		Method method;
		try { // First: Look if there's a method without parameters.
			method = methodClass.getMethod(methodName, null);
		}
		catch (NoSuchMethodException exception) {
			try {
				// It's possible that the method requires an event parameter, so
				// check for that as well:
				Class<?>[] parameters = {java.awt.event.ActionEvent.class};
				method = methodClass.getMethod(methodName, parameters);
			}
			catch (NoSuchMethodException e) {
				throw new IllegalArgumentException("The given method does not appear in the given class. Be aware that the given method mustn't have any parameters, or only 1 parameter, which has to be of type java.awt.event.ActionEvent.");
			}
		}
		// At this stage, the given data has been validated, and we've been able
		// to retrieve the method itself.
		return method;
	}

	/**
	 * Creates a button in the GUI for interaction.
	 * This function offers a convenient way to create a button, that can be
	 * directly interacted with by the user. After creation, the button itself
	 * is returned to the caller, if he wishes to do something else with it.
	 * @param text The text that will be displayed in the button.
	 * @param action The action that will be returned to the action listener.
	 * @param methodName The name of the method that will be called when an
	 * action is triggered.
	 * @param objectInstance The object instance that contains the given method.
	 * This may only be a null pointer if triggerMethod is not an instance
	 * method.
	 * performed. This method may accept an ActionEvent parameter as its only
	 * parameter, or no parameters at all.
	 * @throws NullPointerException if triggerMethod is a null pointer, or
	 * the empty String was given.
	 * @throws IllegalArgumentException if triggerMethod has more than 1
	 * parameter, or the 1 required parameter is not of type ActionEvent.
	 * @return The button that was created.
	 * @see java.awt.event.ActionEvent
	 * @see java.lang.reflect.Method.invoke()
	 */
	public JButton createButton(String text, String action, String methodName, Object triggerObject) {
		Method triggerMethod = this.handleReflectionData(methodName, triggerObject);

		// For starters, we first assert that the given parameters are valid:
		if (text == null) {
			text = "";
		}
		if (action == null) {
			action = "";
		}
		
		// When the method gets here, everything's been validated correctly.
		JButton button = new JButton(text);
		button.setActionCommand(action);
		button.addActionListener(
				new java.awt.event.ActionListener() {
					public void actionPerformed(java.awt.event.ActionEvent event) {
						try {
							triggerMethod.setAccessible(true);
							if (triggerMethod.getParameterTypes().length == 0) {
								// FIXME: Next line throws a warning?
								triggerMethod.invoke(triggerObject, null);
							}
							else {
								triggerMethod.invoke(triggerObject, new Object[]{event});
							}
						}
						catch (Exception useless) {
							/*
							 * XXX: Some info on why I don't just throw said
							 * Exception to the caller:
							 * Java has this awful language constraint, which
							 * forces every damn exception that isn't a subclass
							 * of RuntimeException, to be declared in the method
							 * declaration. This tends to infect all underlying
							 * methods as well, and all that for reasons I can't
							 * comprehend. In order to keep JSugar a simple and
							 * clean library, I'll rather just handle it here,
							 * and throw a RuntimeException with appropriate
							 * details.
							 */
							throw new IllegalArgumentException("triggerMethod is not accessible from this context.");
						}
					}
				});
		this.panel.add(button);
		this.frame.pack();
		return button;
		return button;
	}

	/**
	 * Ask the user for input through a dialog box.
	 * This method presents the user with an input field, that can accept
	 * textual input. The method will return the given input after the user's
	 * clicked a button to send.
	 * @param text The text/question to be asked to the user.
	 * @return A String, equal to what the user entered.
	 * @throws NullPointerException if text is a null pointer.
	 */
	public String inputDialog(String text) {
		if (text == null) {
			throw new NullPointerException("The given text/question was a null pointer.");
		}
		return JOptionPane.showInputDialog(text);
	}

	/**
	 * Give the user a dialog box.
	 * This method can be used to provide a simple dialog to the user.
	 * This will show the user the given question, after which a boolean value
	 * is returned, holding the choice.
	 * @param text The text/question to be asked to the user.
	 * @return True if the user confirms, False if he denies.
	 * @throws NullPointerException if text is a null pointer.
	 */
	public boolean confirmDialog(String text) {
		if (text == null) {
			throw new NullPointerException("The given text/question was a null pointer.");
		}
		final int ACCEPTED = 0;
		final int DENIED = 1;
		int result = this.choiceDialog(text, new String[]{"Confirm", "Deny"});
		if (result == ACCEPTED) {
			return true;
		}
		else {
			return false;
		}
	}

	/**
	 * Give the user a choice dialog box.
	 * This method gives the user a simple dialog with predefined choices.
	 * These choices are to be provided by the caller in a simple array.
	 * Tip: This method works extremely well with arbitrary created choices.
	 * That is: if the outcome of the dialog is trivial (e.g. Only 1 choice),
	 * then that value is immediately returned.
	 * @param text The text/question to be asked to the user.
	 * @param choices An array of Strings, containing the choices the user can
	 * pick.
	 * @return The index value of the picked choice, or -1 if no choices were
	 * given.
	 * @throws NullPointerException if text is a null pointer.
	 */
	public int choiceDialog(String text, String[] choices) {
		if (text == null) {
			throw new NullPointerException("The given text/question was a null pointer.");
		}
		// First: handling the trivial cases:
		if (choices.length == 0) {
			return -1;
		}
		else if (choices.length == 1) {
			return 0;
		}
		int answer = JOptionPane.CLOSED_OPTION;
		// The dialog needs to be shown again until the user has made a possible
		// choice, i.e. Chickening out using the close button is not possible
		// (Because that returns CLOSED_OPTION).
		while (answer == JOptionPane.CLOSED_OPTION) {
				JOptionPane.showOptionDialog(
					null, // The parent component. May become the panel?
					text, // The text/question to describe the goal
					"Dialog", // The text in the title bar
					JOptionPane.DEFAULT_OPTION, // The kind of available options
					JOptionPane.QUESTION_MESSAGE, // The type of message
					null, // The icon to show
					choices, // The possible choices
					choices[0] // The standard choice
					);
		}
		return answer;
	}
		

	/**
	 * Creates a label in the GUI for interaction.
	 * This function offers a convenient way to create a label, that can be
	 * directly interacted with by the user. After creation, the label itself
	 * is returned to the caller, if he wishes to do something else with it.
	 * @param text The text that will be displayed in the label.
	 * @return The label that was created.
	 */
	public JLabel createLabel(String text) {
		JLabel label = new JLabel(text);
		this.panel.add(label);
		return label;
		return label;
	}

	/**
	 * Adds the given component to the GUI.
	 * This method allows its caller to give a pre-made component, so that it
	 * can be added to the GUI. Even though its main use is for the Window class
	 * itself, the user of JSugar can also use it to create components himself,
	 * and then add them. As such, this method doesn't provide parameters for
	 * reflection/action triggering purposes.
	 * @param component The component to be added to the window.
	 * @throws NullPointerException if the given component is a null pointer.
	 */
	public void addComponent(JComponent component) {
		this.panel.add(component); // Throws the exception if null.
		this.updateWindow();
	}

	/**
	 * Removes the given component from the GUI.
	 * This method allows its caller to remove a component from the GUI.
	 * @param component The component to be removed.
	 * @throws NoSuchElementException if the given component does not exist in
	 * the GUI.
	 * @throws NullPointerException if the given component is a null pointer.
	 */
	public void removeComponent(JComponent component) {
		int originalSize = this.panel.getComponentCount();
		this.panel.remove(component);
		int newSize = this.panel.getComponentCount();
		if (originalSize != newSize+1) {
			throw new NoSuchElementException("The given component does not exist in the GUI.");
		}
		this.updateWindow();
	}
}


1	1	* Window.java - Module to create a new window with JSugar.
2	2	* Copyright © 2016 Maarten "Vngngdn" Vangeneugden
3	3	*
4	4	* This program is free software: you can redistribute it and/or modify
5	5	* it under the terms of the GNU General Public License as published by
6	6	* the Free Software Foundation, either version 3 of the License, or
7	7	* (at your option) any later version.
8	8	*
9	9	* This program is distributed in the hope that it will be useful,
10	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	12	* GNU General Public License for more details.
13	13	*
14	14	* You should have received a copy of the GNU General Public License
15	15	* along with this program. If not, see <https://www.gnu.org/licenses/>.
16	16	*/
17	17
18	18	/**
19	19	* Window class for the program.
20	20	*
21	21	* Window contains the necessary data and methods to present the user with what
22	22	* he's familiar with as being a "window". To make it functional, the developer
23	23	* can make use of a series of methods to add components to said window, remove
24	24	* components, and so on.
25	25	* Currently, Window also contains methods to show dialogs. This will be cleaned
26	26	* in the near future.
27	27	* @author Maarten Vangeneugden
28	28	*/
29	29	import javax.swing.*; // FIXME: Maybe namespacing it to "javax.swing;" is a better idea.
30	30	import java.util.NoSuchElementException;
31	31	import java.lang.reflect.Method;
32	32
33	33	class Window {
34	34	private JPanel panel; // The panel that contains all the components.
35	35	private JFrame frame; // The "window" being presented to the user.
36	36
37	37	/**
38	38	* Constructor of Window.
39	39	* By creating a new Window instance, this constructor will automatically
40	40	* start the initialization of the GUI. After doing so, the caller can
41	41	* start adding components to the window as pleased.
42	42	* @param title The title to be shown in the window's title bar.
43	43	*/
44	44	public Window() {
45	45	this.panel = new JPanel();
46	46	// TODO: The current title is "Hello world!" but that will become caller
47	47	// defined soon.
48	48	JFrame frame = new JFrame("Hello world!");
49	49	// Makes it so that if the user clicks the X in the titlebar, the window
50	50	// closes:
51	51	frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
52	52	//frame.getContentPane().add(lblHelloWorld); // So you use a get() in order to set() data? #JavaWTF
53	53	frame.setContentPane(this.panel); // Connecting the component panel to the window.
54	54	// Makes the window fit to the necessary width and height, so it can show all "subcomponents".
55	55	frame.pack();
56	56	frame.setVisible(true); // Makes the window visible to the user.
57	57	this.frame = frame;
58	58	}
59	59
60	60	/**
61	61	* Resizes the window to fit all components.
62	62	* By calling this method, the window will evaluate the currently visible
63	63	* components, and resize itself so that all components become properly
64	64	* visible.
65	65	*/
66	66	private void updateWindow() {
67	67	this.frame.pack();
68	68	}
69	69
70	70	/**
71	71	* A series of tests for method and class handling.
72	72	* When a caller presents certain methods with data concerning reflection,
73	73	* the Java classes you need to use for that are quite opaque, and don't
74	74	* offer much safety in any way.
75	75	* The solution therefore, is run some validation checks, but these take up
76	76	* a decent amount of space in terms of LoC.
77	77	* This method takes care of all that. Call this function whenever data
78	78	* needs to be validated.
79	79	* @param methodName The name of the method, as it is declared in object.
80	80	* @param object The class instance in where this method will be called.
81	81	* @return The method that could be derived from the supplied data, or null
82	82	* if that wasn't possible.
83	83	* @throws NullPointerException if either methodName or object are null
84	84	* pointers.
85	85	* @throws IllegalArgumentException if methodName is empty, or the method
86	86	* does not appear to be declared in the given object, or object is not a
87	87	* class.
88	88	*/
89	89	// All unchecked typecasts are safe, and the use of raw types is taken care
90	90	// of.
91	91	@SuppressWarnings({"unchecked","rawtypes"})
92	92	private Method handleReflectionData(String methodName, Object object) {
93	93	// Null pointer checking:
94	94	if (methodName == null \|\| object == null) {
95	95	throw new NullPointerException("One or more of the given parameters are null pointers.");
96	96	}
97	97
98	98	// XXX: Some might say the next line should be in an else{} block. But
99	99	// Scoping rules require that I'd then have to wrap the rest of the
100	100	// method in the same else to use it.
101	101	Class methodClass = object.getClass();
102	102	if (methodName.equals("")) {
103	103	throw new IllegalArgumentException("The given methodName was empty.");
104	104	}
105	105	Method method;
106	106	try { // First: Look if there's a method without parameters.
107	107	method = methodClass.getMethod(methodName, null);
108	108	}
109	109	catch (NoSuchMethodException exception) {
110	110	try {
111	111	// It's possible that the method requires an event parameter, so
112	112	// check for that as well:
113	113	Class<?>[] parameters = {java.awt.event.ActionEvent.class};
114	114	method = methodClass.getMethod(methodName, parameters);
115	115	}
116	116	catch (NoSuchMethodException e) {
117	117	throw new IllegalArgumentException("The given method does not appear in the given class. Be aware that the given method mustn't have any parameters, or only 1 parameter, which has to be of type java.awt.event.ActionEvent.");
118	118	}
119	119	}
120	120	// At this stage, the given data has been validated, and we've been able
121	121	// to retrieve the method itself.
122	122	return method;
123	123	}
124	124
125	125	/**
126	126	* Creates a button in the GUI for interaction.
127	127	* This function offers a convenient way to create a button, that can be
128	128	* directly interacted with by the user. After creation, the button itself
129	129	* is returned to the caller, if he wishes to do something else with it.
130	130	* @param text The text that will be displayed in the button.
131	131	* @param action The action that will be returned to the action listener.
132	132	* @param methodName The name of the method that will be called when an
133	133	* action is triggered.
134	134	* @param objectInstance The object instance that contains the given method.
135	135	* This may only be a null pointer if triggerMethod is not an instance
136	136	* method.
137	137	* performed. This method may accept an ActionEvent parameter as its only
138	138	* parameter, or no parameters at all.
139	139	* @throws NullPointerException if triggerMethod is a null pointer, or
140	140	* the empty String was given.
141	141	* @throws IllegalArgumentException if triggerMethod has more than 1
142	142	* parameter, or the 1 required parameter is not of type ActionEvent.
143	143	* @return The button that was created.
144	144	* @see java.awt.event.ActionEvent
145	145	* @see java.lang.reflect.Method.invoke()
146	146	*/
147	147	public JButton createButton(String text, String action, String methodName, Object triggerObject) {
148	148	Method triggerMethod = this.handleReflectionData(methodName, triggerObject);
149	149
150	150	// For starters, we first assert that the given parameters are valid:
151	151	if (text == null) {
152	152	text = "";
153	153	}
154	154	if (action == null) {
155	155	action = "";
156	156	}
157	157
158	158	// When the method gets here, everything's been validated correctly.
159	159	JButton button = new JButton(text);
160	160	button.setActionCommand(action);
161	161	button.addActionListener(
162	162	new java.awt.event.ActionListener() {
163	163	public void actionPerformed(java.awt.event.ActionEvent event) {
164	164	try {
165	165	triggerMethod.setAccessible(true);
166	166	if (triggerMethod.getParameterTypes().length == 0) {
167	167	// FIXME: Next line throws a warning?
168	168	triggerMethod.invoke(triggerObject, null);
169	169	}
170	170	else {
171	171	triggerMethod.invoke(triggerObject, new Object[]{event});
172	172	}
173	173	}
174	174	catch (Exception useless) {
175	175	/*
176	176	* XXX: Some info on why I don't just throw said
177	177	* Exception to the caller:
178	178	* Java has this awful language constraint, which
179	179	* forces every damn exception that isn't a subclass
180	180	* of RuntimeException, to be declared in the method
181	181	* declaration. This tends to infect all underlying
182	182	* methods as well, and all that for reasons I can't
183	183	* comprehend. In order to keep JSugar a simple and
184	184	* clean library, I'll rather just handle it here,
185	185	* and throw a RuntimeException with appropriate
186	186	* details.
187	187	*/
188	188	throw new IllegalArgumentException("triggerMethod is not accessible from this context.");
189	189	}
190	190	}
191	191	});
192	192	this.panel.add(button);
193	-	this.frame.pack();
194	-	return button;
+	193	return button;
195	194	}
196	195
197	196	/**
198	197	* Ask the user for input through a dialog box.
199	198	* This method presents the user with an input field, that can accept
200	199	* textual input. The method will return the given input after the user's
201	200	* clicked a button to send.
202	201	* @param text The text/question to be asked to the user.
203	202	* @return A String, equal to what the user entered.
204	203	* @throws NullPointerException if text is a null pointer.
205	204	*/
206	205	public String inputDialog(String text) {
207	206	if (text == null) {
208	207	throw new NullPointerException("The given text/question was a null pointer.");
209	208	}
210	209	return JOptionPane.showInputDialog(text);
211	210	}
212	211
213	212	/**
214	213	* Give the user a dialog box.
215	214	* This method can be used to provide a simple dialog to the user.
216	215	* This will show the user the given question, after which a boolean value
217	216	* is returned, holding the choice.
218	217	* @param text The text/question to be asked to the user.
219	218	* @return True if the user confirms, False if he denies.
220	219	* @throws NullPointerException if text is a null pointer.
221	220	*/
222	221	public boolean confirmDialog(String text) {
223	222	if (text == null) {
224	223	throw new NullPointerException("The given text/question was a null pointer.");
225	224	}
226	225	final int ACCEPTED = 0;
227	226	final int DENIED = 1;
228	227	int result = this.choiceDialog(text, new String[]{"Confirm", "Deny"});
229	228	if (result == ACCEPTED) {
230	229	return true;
231	230	}
232	231	else {
233	232	return false;
234	233	}
235	234	}
236	235
237	236	/**
238	237	* Give the user a choice dialog box.
239	238	* This method gives the user a simple dialog with predefined choices.
240	239	* These choices are to be provided by the caller in a simple array.
241	240	* Tip: This method works extremely well with arbitrary created choices.
242	241	* That is: if the outcome of the dialog is trivial (e.g. Only 1 choice),
243	242	* then that value is immediately returned.
244	243	* @param text The text/question to be asked to the user.
245	244	* @param choices An array of Strings, containing the choices the user can
246	245	* pick.
247	246	* @return The index value of the picked choice, or -1 if no choices were
248	247	* given.
249	248	* @throws NullPointerException if text is a null pointer.
250	249	*/
251	250	public int choiceDialog(String text, String[] choices) {
252	251	if (text == null) {
253	252	throw new NullPointerException("The given text/question was a null pointer.");
254	253	}
255	254	// First: handling the trivial cases:
256	255	if (choices.length == 0) {
257	256	return -1;
258	257	}
259	258	else if (choices.length == 1) {
260	259	return 0;
261	260	}
262	261	int answer = JOptionPane.CLOSED_OPTION;
263	262	// The dialog needs to be shown again until the user has made a possible
264	263	// choice, i.e. Chickening out using the close button is not possible
265	264	// (Because that returns CLOSED_OPTION).
266	265	while (answer == JOptionPane.CLOSED_OPTION) {
267	266	JOptionPane.showOptionDialog(
268	267	null, // The parent component. May become the panel?
269	268	text, // The text/question to describe the goal
270	269	"Dialog", // The text in the title bar
271	270	JOptionPane.DEFAULT_OPTION, // The kind of available options
272	271	JOptionPane.QUESTION_MESSAGE, // The type of message
273	272	null, // The icon to show
274	273	choices, // The possible choices
275	274	choices[0] // The standard choice
276	275	);
277	276	}
278	277	return answer;
279	278	}
280	279
281	280
282	281	/**
283	282	* Creates a label in the GUI for interaction.
284	283	* This function offers a convenient way to create a label, that can be
285	284	* directly interacted with by the user. After creation, the label itself
286	285	* is returned to the caller, if he wishes to do something else with it.
287	286	* @param text The text that will be displayed in the label.
288	287	* @return The label that was created.
289	288	*/
290	289	public JLabel createLabel(String text) {
291	290	JLabel label = new JLabel(text);
292	291	this.panel.add(label);
293	-	return label;
+	292	return label;
294	293	}
295	294
296	295	/**
+	296	* Adds the given component to the GUI.
+	297	* This method allows its caller to give a pre-made component, so that it
+	298	* can be added to the GUI. Even though its main use is for the Window class
+	299	* itself, the user of JSugar can also use it to create components himself,
+	300	* and then add them. As such, this method doesn't provide parameters for
+	301	* reflection/action triggering purposes.
+	302	* @param component The component to be added to the window.
+	303	* @throws NullPointerException if the given component is a null pointer.
+	304	*/
+	305	public void addComponent(JComponent component) {
+	306	this.panel.add(component); // Throws the exception if null.
+	307	this.updateWindow();
+	308	}
+	309
+	310	/**
297	311	* Removes the given component from the GUI.
298	312	* This method allows its caller to remove a component from the GUI.
299	313	* @param component The component to be removed.
300	314	* @throws NoSuchElementException if the given component does not exist in
301	315	* the GUI.
302	316	* @throws NullPointerException if the given component is a null pointer.
303	317	*/
304	318	public void removeComponent(JComponent component) {
305	319	int originalSize = this.panel.getComponentCount();
306	320	this.panel.remove(component);
307	321	int newSize = this.panel.getComponentCount();
308	322	if (originalSize != newSize+1) {
309	323	throw new NoSuchElementException("The given component does not exist in the GUI.");
310	324	}
311	325	this.updateWindow();
312	326	}
313	327	}
314	328