219156dbdb992b3408beb2bfb0237c50033e6f01
[scilab.git] / scilab / modules / gui / src / java / org / scilab / modules / gui / bridge / editbox / SwingScilabEditBox.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2007-2008 - INRIA - Vincent Couvert
4  * Copyright (C) 2007 - INRIA - Marouane BEN JELLOUL
5  * Copyright (C) 2011 - DIGITEO - Vincent COUVERT
6  *
7  * This file must be used under the terms of the CeCILL.
8  * This source file is licensed as described in the file COPYING, which
9  * you should have received as part of this distribution.  The terms
10  * are also available at
11  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
12  *
13  */
14
15 package org.scilab.modules.gui.bridge.editbox;
16
17 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_SCROLLABLE__;
18 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_MAX__;
19 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_BACKGROUNDCOLOR__;
20 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_MIN__;
21 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_STRING__;
22
23 import java.awt.BorderLayout;
24 import java.awt.Color;
25 import java.awt.Font;
26 import java.awt.KeyboardFocusManager;
27 import java.awt.event.ActionEvent;
28 import java.awt.event.FocusEvent;
29 import java.awt.event.FocusListener;
30 import java.awt.event.KeyEvent;
31 import java.util.ArrayList;
32
33 import javax.swing.AbstractAction;
34 import javax.swing.InputMap;
35 import javax.swing.JPanel;
36 import javax.swing.JScrollPane;
37 import javax.swing.JTextPane;
38 import javax.swing.KeyStroke;
39 import javax.swing.ScrollPaneConstants;
40 import javax.swing.UIManager;
41 import javax.swing.border.Border;
42 import javax.swing.text.AbstractDocument;
43 import javax.swing.text.BoxView;
44 import javax.swing.text.ComponentView;
45 import javax.swing.text.Element;
46 import javax.swing.text.IconView;
47 import javax.swing.text.LabelView;
48 import javax.swing.text.ParagraphView;
49 import javax.swing.text.SimpleAttributeSet;
50 import javax.swing.text.StyleConstants;
51 import javax.swing.text.StyledDocument;
52 import javax.swing.text.StyledEditorKit;
53 import javax.swing.text.View;
54 import javax.swing.text.ViewFactory;
55
56 import org.scilab.modules.graphic_objects.console.Console;
57 import org.scilab.modules.graphic_objects.graphicController.GraphicController;
58 import org.scilab.modules.gui.SwingView;
59 import org.scilab.modules.gui.SwingViewObject;
60 import org.scilab.modules.gui.SwingViewWidget;
61 import org.scilab.modules.gui.editbox.SimpleEditBox;
62 import org.scilab.modules.gui.events.callback.CommonCallBack;
63 import org.scilab.modules.gui.menubar.MenuBar;
64 import org.scilab.modules.gui.textbox.TextBox;
65 import org.scilab.modules.gui.toolbar.ToolBar;
66 import org.scilab.modules.gui.utils.Position;
67 import org.scilab.modules.gui.utils.PositionConverter;
68 import org.scilab.modules.gui.utils.ScilabRelief;
69 import org.scilab.modules.gui.utils.ScilabSwingUtilities;
70 import org.scilab.modules.gui.utils.Size;
71
72 /**
73  * Swing implementation for Scilab EditBox in GUIs
74  * @author Vincent COUVERT
75  */
76 public class SwingScilabEditBox extends JScrollPane implements SwingViewObject, SimpleEditBox {
77
78     private static final long serialVersionUID = 2048261239598753717L;
79
80     private Integer uid;
81
82     private CommonCallBack callback;
83
84     private FocusListener focusListener;
85
86     private Border defaultBorder = null;
87
88     private StyledDocument doc;
89     private SimpleAttributeSet docAttributes = new SimpleAttributeSet();
90
91     private JTextPane textPane = new JTextPane();
92     //use to disable wordwarp
93     private JPanel noWrapPanel = new JPanel(new BorderLayout());
94     private boolean scrollable = false;
95     private boolean isMultiLine = false;
96
97     private Object enterKeyAction;
98     private Object tabKeyAction;
99     private Object shiftTabKeyAction;
100
101
102     private class EditBoxView extends BoxView {
103         public EditBoxView(Element elem, int axis) {
104             super(elem, axis);
105         }
106
107         protected void layoutMajorAxis(int targetSpan, int axis, int[] offsets, int[] spans) {
108             super.layoutMajorAxis(targetSpan, axis, offsets, spans);
109             int textBlockHeight = 0;
110             int offset = 0;
111
112             if (textPane.getAlignmentY() == BOTTOM_ALIGNMENT) {
113                 for (int i = 0; i < spans.length; i++) {
114                     textBlockHeight += spans[i];
115                 }
116                 offset = (targetSpan - textBlockHeight);
117                 for (int i = 0; i < offsets.length; i++) {
118                     offsets[i] += offset;
119                 }
120             } else if (textPane.getAlignmentY() == CENTER_ALIGNMENT) {
121                 for (int i = 0; i < spans.length; i++) {
122                     textBlockHeight += spans[i];
123                 }
124                 offset = (targetSpan - textBlockHeight) / 2;
125                 for (int i = 0; i < offsets.length; i++) {
126                     offsets[i] += offset;
127                 }
128             } else {
129                 // TOP_ALIGNEMENT or other
130                 // default behaviour : do nothing special
131             }
132         }
133     }
134
135     private class EditBoxEditorKit extends StyledEditorKit {
136         private static final long serialVersionUID = -3293325523458217074L;
137
138         public ViewFactory getViewFactory() {
139             return new ViewFactory() {
140                 public View create(Element elem) {
141                     String kind = elem.getName();
142                     if (kind != null) {
143                         if (kind.equals(AbstractDocument.ContentElementName)) {
144                             return new LabelView(elem);
145                         } else if (kind.equals(AbstractDocument.ParagraphElementName)) {
146                             return new ParagraphView(elem);
147                         } else if (kind.equals(AbstractDocument.SectionElementName)) {
148                             return new EditBoxView(elem, View.Y_AXIS);
149                         } else if (kind.equals(StyleConstants.ComponentElementName)) {
150                             return new ComponentView(elem);
151                         } else if (kind.equals(StyleConstants.IconElementName)) {
152                             return new IconView(elem);
153                         }
154                     }
155                     return new LabelView(elem);
156                 }
157             };
158         }
159     }
160
161     /**
162      * Constructor
163      */
164     public SwingScilabEditBox() {
165         super(new JPanel(new BorderLayout()));
166         noWrapPanel = (JPanel) getViewport().getView();
167         textPane = new JTextPane();
168         noWrapPanel.add(textPane, BorderLayout.CENTER);
169
170         setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_NEVER);
171         setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
172
173         textPane.setEditorKit(new EditBoxEditorKit());
174         doc = (StyledDocument) textPane.getDocument();
175
176         // Create a focus listener to call the callback action
177         focusListener = new FocusListener() {
178             public void focusGained(FocusEvent arg0) {
179                 // Do nothing
180             }
181
182             public void focusLost(FocusEvent arg0) {
183                 validateUserInput();
184             }
185         };
186         textPane.addFocusListener(focusListener);
187         KeyStroke enterKey = KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0);
188         KeyStroke tabKey = KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0);
189         KeyStroke shiftTabKey = KeyStroke.getKeyStroke(KeyEvent.VK_TAB, KeyEvent.SHIFT_DOWN_MASK);
190         InputMap map = textPane.getInputMap();
191         enterKeyAction = map.get(enterKey);
192         tabKeyAction = map.get(tabKey);
193         shiftTabKeyAction = map.get(shiftTabKey);
194
195         if (Console.getConsole().getUseDeprecatedLF() == false) {
196             setEditFont(getFont());
197         }
198     }
199
200     /**
201      * Validate UserInput and call Scilab Callback if needed
202      */
203     private void validateUserInput() {
204         // Validates user input
205         if (getParent() != null) { // To avoid to execute the callback when then parent figure is destroyed
206
207             String[] stringProperty = getText().split("\n");
208             GraphicController.getController().setProperty(uid, __GO_UI_STRING__, stringProperty);
209
210             if (SwingView.getFromId(uid) != null && callback != null) {
211                 callback.actionPerformed(null);
212             }
213         }
214     }
215
216     /**
217      * Draws a swing Scilab EditBox
218      * @see org.scilab.modules.gui.uielement.UIElement#draw()
219      */
220     public void draw() {
221         this.setVisible(true);
222         this.doLayout();
223     }
224
225     /**
226      * Gets the dimensions (width and height) of a swing Scilab EditBox
227      * @return the dimensions of the EditBox
228      * @see org.scilab.modules.gui.uielement.UIElement#getDims()
229      */
230     public Size getDims() {
231         return new Size(this.getSize().width, this.getSize().height);
232     }
233
234     /**
235      * Gets the position (X-coordinate and Y-coordinate) of a swing Scilab
236      * EditBox
237      * @return the position of the EditBox
238      * @see org.scilab.modules.gui.uielement.UIElement#getPosition()
239      */
240     public Position getPosition() {
241         return PositionConverter.javaToScilab(getLocation(), getSize(), getParent());
242     }
243
244     /**
245      * Sets the dimensions (width and height) of a swing Scilab EditBox
246      * @param newSize the dimensions we want to set to the EditBox
247      * @see org.scilab.modules.gui.uielement.UIElement#setDims(org.scilab.modules.gui.utils.Size)
248      */
249     public void setDims(Size newSize) {
250         this.setSize(newSize.getWidth(), newSize.getHeight());
251     }
252
253     /**
254      * Sets the position (X-coordinate and Y-coordinate) of a swing Scilab
255      * EditBox
256      * @param newPosition the position we want to set to the EditBox
257      * @see org.scilab.modules.gui.uielement.UIElement#setPosition(org.scilab.modules.gui.utils.Position)
258      */
259     public void setPosition(Position newPosition) {
260         Position javaPosition = PositionConverter.scilabToJava(newPosition, getDims(), getParent());
261         setLocation(javaPosition.getX(), javaPosition.getY());
262     }
263
264     /**
265      * Add a callback to the EditBox
266      * @param cb the callback to set.
267      */
268     public void setCallback(CommonCallBack cb) {
269         this.callback = cb;
270     }
271
272     public void setText(String[] texts) {
273         if (texts.length == 0) {
274             try {
275                 textPane.setText(null);
276                 doc.setParagraphAttributes(0, doc.getLength() - 1, docAttributes, true);
277             } catch (Exception e) {
278                 // Do nothing
279             }
280         } else {
281             StringBuffer newText = new StringBuffer(texts[0]);
282
283             for (int i = 1; i < texts.length; ++i) {
284                 newText.append("\n" + texts[i]);
285             }
286
287             try {
288                 textPane.setText(newText.toString());
289                 doc.setParagraphAttributes(0, doc.getLength() - 1, docAttributes, true);
290             } catch (Exception e) {
291                 // Do nothing
292             }
293         }
294     }
295
296     public void setText(String text) {
297         try {
298             textPane.setText(text);
299             doc.setParagraphAttributes(0, doc.getLength() - 1, docAttributes, true);
300         } catch (Exception e) {
301             // Do nothing
302         }
303     }
304
305     public void setEmptyText() {
306         textPane.setText(null);
307         doc.setParagraphAttributes(0, doc.getLength() - 1, docAttributes, true);
308     }
309
310     /**
311      * Set if the EditBox is enabled or not
312      * @param status true if the EditBox is enabled
313      */
314     public void setEnabled(boolean status) {
315         if (status == isEnabled()) {
316             return;
317         }
318
319         super.setEnabled(status);
320         textPane.setEnabled(status);
321
322         //force background to gray
323         if (status) {
324             SwingViewWidget.update(this, __GO_UI_BACKGROUNDCOLOR__, GraphicController.getController().getProperty(uid, __GO_UI_BACKGROUNDCOLOR__));
325         } else {
326             Color gray = new Color(0.9f,  0.9f,  0.9f);
327             setBackground(gray);
328         }
329
330
331         /* (Des)Activate the callback */
332         if (callback != null) {
333             if (status) {
334                 removeFocusListener(focusListener); /*
335                                                      * To be sure the callback
336                                                      * is not added two times
337                                                      */
338                 //removeActionListener(actionListener); /* To be sure the callback is not added two times */
339                 addFocusListener(focusListener);
340                 //addActionListener(actionListener);
341             } else {
342                 removeFocusListener(focusListener);
343                 //removeActionListener(actionListener);
344             }
345         }
346     }
347
348     /**
349      * Setter for MenuBar
350      * @param menuBarToAdd the MenuBar associated to the Tab.
351      */
352     public void addMenuBar(MenuBar menuBarToAdd) {
353         /* Unimplemented for EditBoxes */
354         throw new UnsupportedOperationException();
355     }
356
357     /**
358      * Setter for ToolBar
359      * @param toolBarToAdd the ToolBar associated to the Tab.
360      */
361     public void addToolBar(ToolBar toolBarToAdd) {
362         /* Unimplemented for EditBoxes */
363         throw new UnsupportedOperationException();
364     }
365
366     /**
367      * Getter for MenuBar
368      * @return MenuBar: the MenuBar associated to the Tab.
369      */
370     public MenuBar getMenuBar() {
371         /* Unimplemented for EditBoxes */
372         throw new UnsupportedOperationException();
373     }
374
375     /**
376      * Getter for ToolBar
377      * @return ToolBar: the ToolBar associated to the Tab.
378      */
379     public ToolBar getToolBar() {
380         /* Unimplemented for EditBoxes */
381         throw new UnsupportedOperationException();
382     }
383
384     /**
385      * Set the horizontal alignment for the EditBox text
386      * @param alignment the value for the alignment (See ScilabAlignment.java)
387      */
388     public void setHorizontalAlignment(String alignment) {
389         if (alignment.equals("") == false) {
390             int alignConstant = StyleConstants.ALIGN_LEFT;
391             if (alignment.equals("right")) {
392                 alignConstant = StyleConstants.ALIGN_RIGHT;
393             } else if (alignment.equals("center")) {
394                 alignConstant = StyleConstants.ALIGN_CENTER;
395             }
396
397             StyleConstants.setAlignment(docAttributes, alignConstant);
398             doc.setParagraphAttributes(0, doc.getLength(), docAttributes, true);
399         }
400     }
401
402     /**
403      * Set the vertical alignment for the EditBox text
404      * @param alignment the value for the alignment (See ScilabAlignment.java)
405      */
406     public void setVerticalAlignment(String alignment) {
407         if (alignment.equals("") == false) {
408             if (alignment.equals("bottom")) {
409                 textPane.setAlignmentY(BOTTOM_ALIGNMENT);
410             } else if (alignment.equals("top")) {
411                 textPane.setAlignmentY(TOP_ALIGNMENT);
412             } else if (alignment.equals("middle")) {
413                 textPane.setAlignmentY(CENTER_ALIGNMENT);
414             }
415             // Force text update to render
416             setText(getText());
417         }
418     }
419
420     /**
421      * Set the Relief of the EditBox
422      * @param reliefType the type of the relief to set (See ScilabRelief.java)
423      */
424     public void setRelief(String reliefType) {
425         if (defaultBorder == null) {
426             defaultBorder = textPane.getBorder();
427         }
428         textPane.setBorder(ScilabRelief.getBorderFromRelief(reliefType, defaultBorder));
429     }
430
431     /**
432      * Destroy the EditBox
433      */
434     public void destroy() {
435         ScilabSwingUtilities.removeFromParent(this);
436     }
437
438     /**
439      * Setter for InfoBar
440      * @param infoBarToAdd the InfoBar associated to the EditBox.
441      */
442     public void addInfoBar(TextBox infoBarToAdd) {
443         /* Unimplemented for EditBoxes */
444         throw new UnsupportedOperationException();
445     }
446
447     /**
448      * Getter for InfoBar
449      * @return the InfoBar associated to the EditBox.
450      */
451     public TextBox getInfoBar() {
452         /* Unimplemented for EditBoxes */
453         throw new UnsupportedOperationException();
454     }
455
456     /**
457      * Set the UID
458      * @param id the UID
459      */
460     public void setId(Integer id) {
461         uid = id;
462     }
463
464     /**
465      * Get the UID
466      * @return the UID
467      */
468     public Integer getId() {
469         return uid;
470     }
471
472     public void setBackground(Color bg) {
473         super.setBackground(bg);
474         if (docAttributes != null && textPane != null) {
475             textPane.setBackground(bg);
476             StyleConstants.setBackground(docAttributes, bg);
477         }
478     }
479
480     public void setEditFont(Font font) {
481         super.setFont(font);
482         if (textPane != null) {
483             textPane.setFont(font);
484             StyleConstants.setFontFamily(docAttributes, font.getFamily());
485             StyleConstants.setFontSize(docAttributes, font.getSize());
486             StyleConstants.setBold(docAttributes, font.isBold());
487             StyleConstants.setItalic(docAttributes, font.isItalic());
488             doc.setParagraphAttributes(0, doc.getLength() - 1, docAttributes, true);
489         }
490     }
491
492     public void setFont(Font font) {
493         setEditFont(font);
494     }
495
496     /**
497      * Generic update method
498      * @param property property name
499      * @param value property value
500      */
501     public void update(int property, Object value) {
502         GraphicController controller = GraphicController.getController();
503
504         switch (property) {
505             case __GO_UI_MAX__: {
506                 double min = ((Double) controller.getProperty(uid, __GO_UI_MIN__));
507                 double max = ((Double) controller.getProperty(uid, __GO_UI_MAX__));
508                 if (max - min > 1.0) {
509                     setMultiLineText(true);
510                 } else {
511                     setMultiLineText(false);
512                 }
513
514                 //refresh scrollable state
515                 setScrollable(scrollable);
516                 // Force String update
517                 update(__GO_UI_STRING__, GraphicController.getController().getProperty(uid, __GO_UI_STRING__));
518                 break;
519             }
520             case __GO_UI_MIN__: {
521                 Double min = ((Double) value);
522                 Double max = ((Double) controller.getProperty(uid, __GO_UI_MAX__));
523                 if (max - min > 1.0) {
524                     setMultiLineText(true);
525                 } else {
526                     setMultiLineText(false);
527                 }
528
529                 //refresh scrollable state
530                 setScrollable(scrollable);
531                 // Force String update
532                 update(__GO_UI_STRING__, GraphicController.getController().getProperty(uid, __GO_UI_STRING__));
533                 break;
534             }
535             case __GO_UI_STRING__: {
536                 String[] str = (String[])value;
537
538                 double min = ((Double) controller.getProperty(uid, __GO_UI_MIN__));
539                 double max = ((Double) controller.getProperty(uid, __GO_UI_MAX__));
540
541                 //if str.length > 1 automactly switch to multiline
542                 if (str.length > 1 && max - min <= 1.0 ) {
543                     //update max in model that recall setText
544                     controller.setProperty(uid, __GO_UI_MAX__, min + 2);
545                     return;
546                 }
547
548                 ArrayList<String> lst = new ArrayList<String>();
549                 for (int i = 0 ; i < str.length ; i++) {
550                     String s = str[i];
551                     int index = 0;
552                     int lastIndex = 0;
553                     while ((index = s.indexOf('\n', lastIndex)) != -1) {
554                         lst.add(s.substring(lastIndex, index));
555                         lastIndex = index + 1;
556                     }
557                     if (lastIndex <= s.length()) {
558                         lst.add(s.substring(lastIndex));
559                     }
560                 }
561
562                 if (lst.size() != str.length) {
563                     String[] newStr = new String[lst.size()];
564                     lst.toArray(newStr);
565                     controller.setProperty(uid,  __GO_UI_STRING__, newStr);
566                     return;
567                 }
568
569                 if (max - min > 1.0) {
570                     setText(str);
571                     setMultiLineText(true);
572                 } else {
573                     if (str.length == 0) {
574                         setEmptyText();
575                     } else {
576                         setText(str[0]);
577                     }
578                     setMultiLineText(false);
579                 }
580                 break;
581             }
582             case __GO_UI_SCROLLABLE__ : {
583                 setScrollable((Boolean)value);
584                 break;
585             }
586             default: {
587                 SwingViewWidget.update(this, property, value);
588                 break;
589             }
590         }
591     }
592
593     public void setScrollable(Boolean scrollable) {
594         this.scrollable  = scrollable;
595         if (scrollable) {
596             //scrollbar -> true
597             if (isMultiLine) {
598                 //wrap -> false
599                 setWordWrap(false);
600             } else {
601                 //wrap -> false
602                 setWordWrap(false);
603             }
604
605             //scrollbar -> true
606             setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
607         } else {
608             if (isMultiLine) {
609                 //wrap -> true
610                 setWordWrap(true);
611             } else {
612                 //wrap -> false
613                 setWordWrap(false);
614             }
615
616             //scrollbar -> false
617             setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
618         }
619     }
620
621     private void setWordWrap(boolean wordWrap) {
622         if (wordWrap) {
623             setViewportView(textPane);
624         } else {
625             setViewportView(noWrapPanel);
626             noWrapPanel.add(textPane);
627         }
628     }
629
630     public String getText() {
631         return textPane.getText();
632     }
633
634     public void setMultiLineText(boolean enable) {
635         isMultiLine = enable;
636         KeyStroke enterKey = KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0);
637         KeyStroke tabKey = KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0);
638         KeyStroke shiftTabKey = KeyStroke.getKeyStroke(KeyEvent.VK_TAB, KeyEvent.SHIFT_DOWN_MASK);
639         if (enable) {
640             setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);
641             textPane.getInputMap().remove(enterKey);
642             textPane.getInputMap().remove(tabKey);
643             textPane.getInputMap().remove(shiftTabKey);
644             textPane.getInputMap().put(enterKey, enterKeyAction);
645             textPane.getInputMap().put(tabKey, tabKeyAction);
646             textPane.getInputMap().put(tabKey, shiftTabKeyAction);
647         } else {
648             setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_NEVER);
649             AbstractAction focusNextComponent = new AbstractAction() {
650                 private static final long serialVersionUID = -5286137769378297783L;
651
652                 public void actionPerformed(ActionEvent e) {
653                     KeyboardFocusManager manager = KeyboardFocusManager.getCurrentKeyboardFocusManager();
654                     manager.focusNextComponent();
655                 }
656             };
657
658             AbstractAction validateUserInput = new AbstractAction() {
659                 private static final long serialVersionUID = -5286137769378297783L;
660
661                 public void actionPerformed(ActionEvent e) {
662                     validateUserInput();
663                 }
664             };
665
666             AbstractAction focusPreviousComponent = new AbstractAction() {
667                 private static final long serialVersionUID = -5286137769378297783L;
668
669                 public void actionPerformed(ActionEvent e) {
670                     KeyboardFocusManager manager = KeyboardFocusManager.getCurrentKeyboardFocusManager();
671                     manager.focusPreviousComponent();
672                 }
673             };
674             textPane.getInputMap().remove(enterKey);
675             textPane.getInputMap().remove(tabKey);
676             textPane.getInputMap().remove(shiftTabKey);
677             textPane.getInputMap().put(enterKey, validateUserInput);
678             textPane.getInputMap().put(tabKey, focusNextComponent); // input validation will be performed by focusLost
679             textPane.getInputMap().put(shiftTabKey, focusPreviousComponent); // input validation will be performed by focusLost
680         }
681     }
682
683     public void resetBackground() {
684         Color color = (Color) UIManager.getLookAndFeelDefaults().get("TextField.background");
685         if (color != null) {
686             setBackground(color);
687         }
688     }
689
690     public void resetForeground() {
691         Color color = (Color)UIManager.getLookAndFeelDefaults().get("TextField.foreground");
692         if (color != null) {
693             setForeground(color);
694         }
695     }
696 }