jsugar

Added the begin of the JavaDoc for the JList creator method.

Author
Vngngdn
Date
Aug. 10, 2016, 6:36 p.m.
Hash
fc46395293130814d070142e129f82b8939d32f2
Parent
7539cb4c37ba221b16cc1a5963ef58a3c6349e9b
Modified file
Window.java

Window.java

5 additions and 1 deletion.

View changes Hide changes
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
 * TODO list:
20
20
 * - JList
21
21
 * - JSlider
22
-
 * - JTable (And a JScrollBar to accompany it)
+
22
 * - JTable (And a JScrollBar to accompany it)
23
23
 * - JFileChooser (?)
24
24
 * DONE list:
25
25
 * - JLabel
26
26
 * - JText
27
27
 * - JButton
28
28
 * - JDialogBoxes (you know, everything dialog related)
29
29
 * - JCheckbox
30
30
 * - JRadioButton (properly grouping them has been taken care of as well)
31
31
 * - JSpinner
32
32
 * - JComboBox
33
33
 */
34
34
35
35
/**
36
36
 * Window class for the program.
37
37
 *
38
38
 * Window contains the necessary data and methods to present the user with what
39
39
 * he's familiar with as being a "window". To make it functional, the developer
40
40
 * can make use of a series of methods to add components to said window, remove
41
41
 * components, and so on.
42
42
 * Currently, Window also contains methods to show dialogs. This will be cleaned
43
43
 * in the near future.
44
44
 * @author Maarten Vangeneugden
45
45
 */
46
46
import javax.swing.*; // FIXME: Maybe namespacing it to "javax.swing;" is a better idea.
47
47
import java.util.NoSuchElementException;
48
48
import java.lang.reflect.Method;
49
49
50
50
class Window {
51
51
	private JPanel panel; // The panel that contains all the components.
52
52
	private JFrame frame; // The "window" being presented to the user.
53
53
54
54
	/**
55
55
	 * Constructor of Window.
56
56
	 * By creating a new Window instance, this constructor will automatically
57
57
	 * start the initialization of the GUI. After doing so, the caller can
58
58
	 * start adding components to the window as pleased.
59
59
	 * @param title The title to be shown in the window's title bar.
60
60
	 */
61
61
	public Window() {
62
62
		this.panel = new JPanel();
63
63
		// TODO: The current title is "Hello world!" but that will become caller
64
64
		// defined soon.
65
65
		JFrame frame = new JFrame("Hello world!");
66
66
		// Makes it so that if the user clicks the X in the titlebar, the window
67
67
		// closes:
68
68
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
69
69
		//frame.getContentPane().add(lblHelloWorld); // So you use a get() in order to set() data? #JavaWTF
70
70
		frame.setContentPane(this.panel); // Connecting the component panel to the window.
71
71
		// Makes the window fit to the necessary width and height, so it can show all "subcomponents".
72
72
		frame.pack(); 	
73
73
		frame.setVisible(true); // Makes the window visible to the user.
74
74
		this.frame = frame;
75
75
	}
76
76
77
77
	/**
78
78
	 * Resizes the window to fit all components.
79
79
	 * By calling this method, the window will evaluate the currently visible
80
80
	 * components, and resize itself so that all components become properly
81
81
	 * visible.
82
82
	 */
83
83
	private void updateWindow() {
84
84
		this.frame.pack();
85
85
	}
86
86
87
87
	/**
88
88
	 * A series of tests for method and class handling.
89
89
	 * When a caller presents certain methods with data concerning reflection,
90
90
	 * the Java classes you need to use for that are quite opaque, and don't
91
91
	 * offer much safety in any way.
92
92
	 * The solution therefore, is run some validation checks, but these take up
93
93
	 * a decent amount of space in terms of LoC.
94
94
	 * This method takes care of all that. Call this function whenever data
95
95
	 * needs to be validated.
96
96
	 * @param methodName The name of the method, as it is declared in object.
97
97
	 * @param object The class instance in where this method will be called.
98
98
	 * @return The method that could be derived from the supplied data, or null
99
99
	 * if that wasn't possible.
100
100
	 * @throws NullPointerException if either methodName or object are null
101
101
	 * pointers.
102
102
	 * @throws IllegalArgumentException if methodName is empty, or the method
103
103
	 * does not appear to be declared in the given object, or object is not a
104
104
	 * class.
105
105
	 */
106
106
	// All unchecked typecasts are safe, and the use of raw types is taken care
107
107
	// of.
108
108
	@SuppressWarnings({"unchecked","rawtypes"})
109
109
	private Method handleReflectionData(String methodName, Object object) {
110
110
		// Null pointer checking:
111
111
		if (methodName == null || object == null) {
112
112
			throw new NullPointerException("One or more of the given parameters are null pointers.");
113
113
		}
114
114
115
115
		// XXX: Some might say the next line should be in an else{} block. But
116
116
		// Scoping rules require that I'd then have to wrap the rest of the
117
117
		// method in the same else to use it.
118
118
		Class methodClass = object.getClass(); 
119
119
		if (methodName.equals("")) {
120
120
			throw new IllegalArgumentException("The given methodName was empty.");
121
121
		}
122
122
		Method method;
123
123
		try { // First: Look if there's a method without parameters.
124
124
			method = methodClass.getMethod(methodName, null);
125
125
		}
126
126
		catch (NoSuchMethodException exception) {
127
127
			try {
128
128
				// It's possible that the method requires an event parameter, so
129
129
				// check for that as well:
130
130
				Class<?>[] parameters = {java.awt.event.ActionEvent.class};
131
131
				method = methodClass.getMethod(methodName, parameters);
132
132
			}
133
133
			catch (NoSuchMethodException e) {
134
134
				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.");
135
135
			}
136
136
		}
137
137
		// At this stage, the given data has been validated, and we've been able
138
138
		// to retrieve the method itself.
139
139
		return method;
140
140
	}
141
141
142
142
	/**
143
143
	 * Creates a button in the GUI for interaction.
144
144
	 * This function offers a convenient way to create a button, that can be
145
145
	 * directly interacted with by the user. After creation, the button itself
146
146
	 * is returned to the caller, if he wishes to do something else with it.
147
147
	 * @param text The text that will be displayed in the button.
148
148
	 * @param action The action that will be returned to the action listener.
149
149
	 * @param methodName The name of the method that will be called when an
150
150
	 * action is triggered.
151
151
	 * @param objectInstance The object instance that contains the given method.
152
152
	 * This may only be a null pointer if triggerMethod is not an instance
153
153
	 * method.
154
154
	 * performed. This method may accept an ActionEvent parameter as its only
155
155
	 * parameter, or no parameters at all.
156
156
	 * @throws NullPointerException if triggerMethod is a null pointer, or
157
157
	 * the empty String was given.
158
158
	 * @throws IllegalArgumentException if triggerMethod has more than 1
159
159
	 * parameter, or the 1 required parameter is not of type ActionEvent.
160
160
	 * @return The button that was created.
161
161
	 * @see java.awt.event.ActionEvent
162
162
	 * @see java.lang.reflect.Method.invoke()
163
163
	 */
164
164
	public JButton createButton(String text, String action, String methodName, Object triggerObject) {
165
165
		Method triggerMethod = this.handleReflectionData(methodName, triggerObject);
166
166
167
167
		// For starters, we first assert that the given parameters are valid:
168
168
		if (text == null) {
169
169
			text = "";
170
170
		}
171
171
		if (action == null) {
172
172
			action = "";
173
173
		}
174
174
		
175
175
		// When the method gets here, everything's been validated correctly.
176
176
		JButton button = new JButton(text);
177
177
		button.setActionCommand(action);
178
178
		button.addActionListener(
179
179
				new java.awt.event.ActionListener() {
180
180
					public void actionPerformed(java.awt.event.ActionEvent event) {
181
181
						try {
182
182
							triggerMethod.setAccessible(true);
183
183
							if (triggerMethod.getParameterTypes().length == 0) {
184
184
								// FIXME: Next line throws a warning?
185
185
								triggerMethod.invoke(triggerObject, null);
186
186
							}
187
187
							else {
188
188
								triggerMethod.invoke(triggerObject, new Object[]{event});
189
189
							}
190
190
						}
191
191
						catch (Exception useless) {
192
192
							/*
193
193
							 * XXX: Some info on why I don't just throw said
194
194
							 * Exception to the caller:
195
195
							 * Java has this awful language constraint, which
196
196
							 * forces every damn exception that isn't a subclass
197
197
							 * of RuntimeException, to be declared in the method
198
198
							 * declaration. This tends to infect all underlying
199
199
							 * methods as well, and all that for reasons I can't
200
200
							 * comprehend. In order to keep JSugar a simple and
201
201
							 * clean library, I'll rather just handle it here,
202
202
							 * and throw a RuntimeException with appropriate
203
203
							 * details.
204
204
							 */
205
205
							throw new IllegalArgumentException("triggerMethod is not accessible from this context.");
206
206
						}
207
207
					}
208
208
				});
209
209
		this.addComponent(button);
210
210
		return button;
211
211
	}
212
212
213
213
	/**
214
214
	 * Ask the user for input through a dialog box.
215
215
	 * This method presents the user with an input field, that can accept
216
216
	 * textual input. The method will return the given input after the user's
217
217
	 * clicked a button to send.
218
218
	 * @param text The text/question to be asked to the user.
219
219
	 * @return A String, equal to what the user entered.
220
220
	 * @throws NullPointerException if text is a null pointer.
221
221
	 */
222
222
	public String inputDialog(String text) {
223
223
		if (text == null) {
224
224
			throw new NullPointerException("The given text/question was a null pointer.");
225
225
		}
226
226
		return JOptionPane.showInputDialog(text);
227
227
	}
228
228
229
229
	/**
230
230
	 * Give the user a dialog box.
231
231
	 * This method can be used to provide a simple dialog to the user.
232
232
	 * This will show the user the given question, after which a boolean value
233
233
	 * is returned, holding the choice.
234
234
	 * @param text The text/question to be asked to the user.
235
235
	 * @return True if the user confirms, False if he denies.
236
236
	 * @throws NullPointerException if text is a null pointer.
237
237
	 */
238
238
	public boolean confirmDialog(String text) {
239
239
		if (text == null) {
240
240
			throw new NullPointerException("The given text/question was a null pointer.");
241
241
		}
242
242
		final int ACCEPTED = 0;
243
243
		//final int DENIED = 1; // Not used in the current context.
244
244
		int result = this.choiceDialog(text, new String[]{"Confirm", "Deny"});
245
245
		if (result == ACCEPTED) {
246
246
			return true;
247
247
		}
248
248
		else {
249
249
			return false;
250
250
		}
251
251
	}
252
252
253
253
	/**
254
254
	 * Give the user a choice dialog box.
255
255
	 * This method gives the user a simple dialog with predefined choices.
256
256
	 * These choices are to be provided by the caller in a simple array.
257
257
	 *
258
258
	 * Tip: This method works extremely well with arbitrary created choices.
259
259
	 * That is: if the outcome of the dialog is trivial (e.g. Only 1 choice),
260
260
	 * then that value is immediately returned.
261
261
	 * @param text The text/question to be asked to the user.
262
262
	 * @param choices An array of Strings, containing the choices the user can
263
263
	 * pick.
264
264
	 * @return The index value of the picked choice, or -1 if no choices were
265
265
	 * given.
266
266
	 * @throws NullPointerException if text is a null pointer.
267
267
	 */
268
268
	public int choiceDialog(String text, String[] choices) {
269
269
		if (text == null) {
270
270
			throw new NullPointerException("The given text/question was a null pointer.");
271
271
		}
272
272
		// First: handling the trivial cases:
273
273
		if (choices.length == 0) {
274
274
			return -1;
275
275
		}
276
276
		else if (choices.length == 1) {
277
277
			return 0;
278
278
		}
279
279
		int answer = JOptionPane.CLOSED_OPTION;
280
280
		// The dialog needs to be shown again until the user has made a possible
281
281
		// choice, i.e. Chickening out using the close button is not possible
282
282
		// (Because that returns CLOSED_OPTION).
283
283
		while (answer == JOptionPane.CLOSED_OPTION) {
284
284
				JOptionPane.showOptionDialog(
285
285
					null, // The parent component. May become the panel?
286
286
					text, // The text/question to describe the goal
287
287
					"Dialog", // The text in the title bar
288
288
					JOptionPane.DEFAULT_OPTION, // The kind of available options
289
289
					JOptionPane.QUESTION_MESSAGE, // The type of message
290
290
					null, // The icon to show
291
291
					choices, // The possible choices
292
292
					choices[0] // The standard choice
293
293
					);
294
294
		}
295
295
		return answer;
296
296
	}
297
297
		
298
298
299
299
	/**
300
300
	 * Creates a label in the GUI for interaction.
301
301
	 * This function offers a convenient way to create a label, that can be
302
302
	 * directly interacted with by the user. After creation, the label itself
303
303
	 * is returned to the caller, if he wishes to do something else with it.
304
304
	 * @param text The text that will be displayed in the label.
305
305
	 * @return The label that was created.
306
306
	 */
307
307
	public JLabel createLabel(String text) {
308
308
		JLabel label = new JLabel(text);
309
309
		this.addComponent(label);
310
310
		return label;
311
311
	}
312
312
313
313
	/**
314
314
	 * Adds a checkbox to the window.
315
315
	 * By providing a String, you can use this method to easily
316
316
	 * create a checkbox, and add it to the window. 
317
317
	 */
318
318
	public JCheckBox createCheckbox(String text) {
319
319
		JCheckBox checkbox = new JCheckBox(text);
320
320
		this.addComponent(checkbox);
321
321
		return checkbox;
322
322
	}
323
323
324
324
	/**
325
325
	 * Adds radio buttons to the window.
326
326
	 * Given a list of Strings, this method will create the same amount of radio
327
327
	 * buttons.
328
328
	 *
329
329
	 * The radio buttons will silently be grouped in a ButtonGroup object,
330
330
	 * making them automatically disable each other, so only 1 radio button can
331
331
	 * be enabled. This ButtonGroup is immutable.
332
332
	 *
333
333
	 * If you need a mutable ButtonGroup, create your own, and use the {@link
334
334
	 * #addComponent()} method to add the radio buttons manually.
335
335
	 * @param text An array of Strings. The length of the array will determine
336
336
	 * the amount of radio buttons that will be created.
337
337
	 * @return An array of radio buttons, in the same order as text.
338
338
	 */
339
339
	public JRadioButton[] createRadioButtons(String text[]) {
340
340
		JRadioButton[] radioButtons = new JRadioButton[text.length];
341
341
		ButtonGroup buttonGroup = new ButtonGroup();
342
342
		for (int i=0; i<radioButtons.length; i++) {
343
343
			radioButtons[i].setText(text[i]);
344
344
			buttonGroup.add(radioButtons[i]);
345
345
			this.addComponent(radioButtons[i]);
346
346
		}
347
347
348
348
		assert radioButtons.length == buttonGroup.getButtonCount() : "The amount of radio buttons ("+ radioButtons.length +") differs from the amount of buttons in buttonGroup ("+ buttonGroup.getButtonCount() +").";
349
349
		return radioButtons;
350
350
	}
351
351
352
352
	/**
353
353
	 * Adds a number spinner component to the GUI.
354
354
	 * This method allows the caller to create a so-called "spinner component"
355
355
	 * to the window. This spinner is an input box, in which only integers can
356
356
	 * be put.
357
357
	 *
358
358
	 * The caller can set a range, a start value, and a step size.
359
359
	 *
360
360
	 * The spinner created with this method may modify itself based on the
361
361
	 * parameters.
362
362
	 * For example: If the minimum and maximum value are equal, the spinner will
363
363
	 * be disabled.
364
364
	 *
365
365
	 * @param minimum The minimum value that can be selected.
366
366
	 * @param maximum The maximum value that can be selected.
367
367
	 * @param start The value that will initially be shown in the component.
368
368
	 * @param stepSize The step size when the user increases/decreases the
369
369
	 * value.
370
370
	 * @throws IllegalArgumentException if minimum is larger than maximum, 
371
371
	 * start is not in the range of the selectable values, or stepsize is not a
372
372
	 * natural number.
373
373
	 * @return The JSpinner that was added to the window.
374
374
	 */
375
375
	public JSpinner createSpinner(int minimum, int maximum, int start, int stepSize) {
376
376
		// As usual, we begin with checking the contract:
377
377
		if(minimum > maximum) {
378
378
			throw new IllegalArgumentException("The minimum value ("+ minimum +") was larger than the maximum value ("+ maximum +")");
379
379
		}
380
380
		// The "start ∉ [minimum, maximum]" is done by the SpinnerNumberModel
381
381
		// constructor, which will be constructed later.
382
382
		if(stepSize <= 0) { // stepSize ∉ ℕ¹ (In Belgium: ℕ₀)
383
383
			throw new IllegalArgumentException("The stepSize ("+ stepSize +") is not a natural number (excluding 0).");
384
384
		}
385
385
		// If the contract is valid, we can begin:
386
386
		/*
387
387
		 * I'd like to interject here, because this is a nice example of why
388
388
		 * JSugar was a good idea:
389
389
		 * If you want a spinner, you'll typically want an integer spinner. But
390
390
		 * in Swing, when you create a JSpinner, it creates a JSpinner, with a
391
391
		 * predefined 'SpinnerNumberModel' attached to it.
392
392
		 * It's this model you then have to extract from the created spinner, on
393
393
		 * which you need to apply the configuration.
394
394
		 * What you actually have to do, is create a SpinnerNumberModel
395
395
		 * yourself, put your settings on that, and then, create a JSpinner to
396
396
		 * which you give that SpinnerNumberModel.
397
397
		 * In essence: The entire Java framework is shit.
398
398
		 */
399
399
		SpinnerNumberModel spinnerSettings = new SpinnerNumberModel(
400
400
				start,
401
401
				minimum,
402
402
				maximum,
403
403
				stepSize
404
404
				);
405
405
		JSpinner spinner = new JSpinner(spinnerSettings);
406
406
		if(minimum == maximum) { // Trivial value is set already, --> disable.
407
407
			spinner.setEnabled(false);
408
408
		}
409
409
		this.addComponent(spinner);
410
410
		return spinner;
411
411
	}
412
412
413
413
	/**
414
414
	 * Adds a number spinner component to the GUI.
415
415
	 * This method allows the caller to create a so-called "spinner component"
416
416
	 * to the window. This spinner is an input box, in which only integers can
417
417
	 * be put.
418
418
	 * 
419
419
	 * Tip: This method is a convenience method, and works extremely well with
420
420
	 * arbitrary data.
421
421
	 * For example: The start value is automatically set to the minimal possible
422
422
	 * value, and the step size defaults to 1.
423
423
	 * If the minimum and maximum are equal, the component will be disabled, and
424
424
	 * thus, be locked on the only (trivially) possible value.
425
425
	 * If minimum is larger than maximum, the method will notify you of this,
426
426
	 * but also swap the values. So you can rest assured that the spinner will
427
427
	 * handle errors, but also, inform you about it.
428
428
	 * @param minimum The minimum value that can be selected.
429
429
	 * @param maximum The maximum value that can be selected.
430
430
	 * @return The JSpinner component that was added to the window.
431
431
	 */
432
432
	public JSpinner createSpinner(int minimum, int maximum) {
433
433
		// The disabling of equal values is done in the full createSpinner(), so
434
434
		// this is merely switching values if they need to be swapped.
435
435
		if(minimum > maximum) {
436
436
			System.err.println("minimum ("+ minimum +") was larger than maximum ("+ maximum +").");
437
437
			// FIXME: Consider whether it's appropriate to print a stacktrace
438
438
			// here, which may be convenient for debugging.
439
439
			
440
440
			// XXX: I know you don't need the help variable when swapping
441
441
			// integers, because you can also do basic arithmetics. Change it if
442
442
			// it causes too much eye burn for you.
443
443
			int swapValue = minimum;
444
444
			minimum = maximum;
445
445
			maximum = swapValue;
446
446
		}
447
447
448
448
		// Yeah, these 2 variables make you cringe huh, performance addicts?
449
449
		// Drown me in the tears of your useless performance-related opinions.
450
450
		int startValue = minimum;
451
451
		int stepSize = 1;
452
452
		return this.createSpinner(minimum, maximum, startValue, stepSize);
453
453
	}
454
454
455
455
	/**
456
456
	 * Adds a combobox to the GUI.
457
457
	 * Allows the caller to create a combobox by providing the values that
458
458
	 * should be put in it.
459
459
	 *
460
460
	 * This method can only be used for String values. If that is not what you
461
461
	 * need, consider creating your own combobox and adding it manually. Or, if
462
462
	 * you need a combobox for integers, consider {@link #createSpinner()}.
463
463
	 *
464
464
	 * WARNING: {@see JComboBox#getSelectedItem()} returns an object, not a
465
465
	 * String. You need to manually typecast this. This is a constraint of the
466
466
	 * Swing framework.
467
467
	 * @param items An array of Strings that will be put in the combobox.
468
468
	 * @throws NullPointerException if one of the values in items is a null
469
469
	 * pointer.
470
470
	 * @throws IllegalArgumentException if items is empty.
471
471
	 * @return The JCombobox that was added to the window.
472
472
	 */
473
473
	public JComboBox<String> addComboBox(String[] items) {
474
474
		// Contract validation:
475
475
		if(items.length == 0) {
476
476
			throw new IllegalArgumentException("The given array of items was empty.");
477
477
		}
478
478
		for(String item : items) {
479
479
			if(item == null) {
480
480
				throw new NullPointerException("One of the given Strings is a null pointer.");
481
481
			}
482
482
		}
483
483
		// Contract validated, create the component:
484
484
		JComboBox<String> comboBox = new JComboBox<String>(items);
485
485
		comboBox.setSelectedIndex(0);
486
486
		if(comboBox.getItemCount() == 1) { // Trivial selection
487
487
			comboBox.setEnabled(false);
488
488
		}
489
489
		this.addComponent(comboBox);
490
490
		return comboBox;
491
491
	}
492
492
493
493
	/**
+
494
	 * Creates a list of the given data, and adds it to the GUI.
+
495
	 * This will create a JList component, containing the given data. 
+
496
+
497
	/**
494
498
	 * Adds the given component to the GUI.
495
499
	 * This method allows its caller to give a pre-made component, so that it
496
500
	 * can be added to the GUI. Even though its main use is for the Window class
497
501
	 * itself, the user of JSugar can also use it to create components himself,
498
502
	 * and then add them. As such, this method doesn't provide parameters for
499
503
	 * reflection/action triggering purposes.
500
504
	 * @param component The component to be added to the window.
501
505
	 * @throws NullPointerException if the given component is a null pointer.
502
506
	 */
503
507
	public void addComponent(JComponent component) {
504
508
		int originalSize = this.panel.getComponentCount();
505
509
		this.panel.add(component); // Throws the exception if null.
506
510
		this.updateWindow();
507
511
508
512
		assert originalSize == this.panel.getComponentCount()-1 : "A component was supposed to be added to the window, but the total amount of components was unchanged after the addition.";
509
513
	}
510
514
511
515
	/**
512
516
	 * Removes the given component from the GUI.
513
517
	 * This method allows its caller to remove a component from the GUI.
514
518
	 * @param component The component to be removed.
515
519
	 * @throws NoSuchElementException if the given component does not exist in
516
520
	 * the GUI.
517
521
	 * @throws NullPointerException if the given component is a null pointer.
518
522
	 */
519
523
	public void removeComponent(JComponent component) {
520
524
		int originalSize = this.panel.getComponentCount();
521
525
		this.panel.remove(component);
522
526
		int newSize = this.panel.getComponentCount();
523
527
		if (originalSize != newSize+1) {
524
528
			throw new NoSuchElementException("The given component does not exist in the GUI.");
525
529
		}
526
530
		this.updateWindow();
527
531
	}
528
532
}
529
533