source: main/trunk/gli/src/org/greenstone/gatherer/gui/ConfigFileEditor.java@ 34266

/**
 *#########################################################################
 *
 * A component of the Gatherer application, part of the Greenstone digital
 * library suite from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * Copyright (C) 1999 New Zealand Digital Library Project
 *
 * 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 2 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, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *########################################################################
 */

package org.greenstone.gatherer.gui;

// for RSyntaxTextArea editor's search functionality:
import org.fife.ui.rtextarea.SearchEngine;
import org.fife.ui.rtextarea.SearchContext;

import org.greenstone.gatherer.Configuration;
import org.greenstone.gatherer.Dictionary;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.util.StaticStrings;
import org.greenstone.gatherer.util.Utility;
import org.greenstone.gatherer.util.XMLTools;

import org.w3c.dom.*;

import java.io.File;
import java.io.IOException;

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.event.*;


public class ConfigFileEditor extends ModalDialog 
    implements ActionListener, DocumentListener
{
    public final File config_file;

    /** User can add some complex elements by clcking a button */
    private Document elements_available_for_insertion;
    
    private GLIButton cancel_button = null;
    private GLIButton save_button = null;
    private NumberedJTextArea editor = null;
    private JTextArea editor_msgarea;

    private JComboBox chooseElementComboBox;
    private GLIButton addElementButton;
    
    // https://github.com/bobbylight/RSyntaxTextArea/wiki/Example:-Using-Find-and-Replace
    final private JTextField searchField;
    private JCheckBox regexCB;
    private JCheckBox matchCaseCB;
    private JButton nextButton;
    private JButton prevButton;
    
    //private final String DEFAULT_PROCESSING_INSTRUCTION = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";    

    private static final Dimension SIZE = new Dimension(850,550);

    
    // Enum to define elements the user can add
    // enum available from Java 1.5
    // https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
    // https://docs.oracle.com/javase/7/docs/api/java/lang/Enum.html
    private enum ElementOption {    
    HIDE_COLLECTION (Dictionary.get("ConfigFileEditor.Hide_Collection")),
    SECURE_COLLECTION (Dictionary.get("ConfigFileEditor.Secure_Collection")),
    SECURE_ALL_DOCUMENTS(Dictionary.get("ConfigFileEditor.Secure_All_Documents")),
    SECURE_CERTAIN_DOCUMENTS(Dictionary.get("ConfigFileEditor.Secure_Certain_Documents")),
    ADD_ANOTHER_DOCUMENTSET(Dictionary.get("ConfigFileEditor.Add_Another_DocumentSet")),
    ADD_ANOTHER_EXCEPTION(Dictionary.get("ConfigFileEditor.Add_Another_Exception"));    
    
    private final String displayString;
    // Constructor may not be declared as public
    ElementOption(String displayStr) {
        // interesting that Enum implementation classes don't
        // have to call protected superclass constructor
        displayString = displayStr;
    }

    // override default behaviour of returning the ENUM string itself
    // to display the displayString instead
    public String toString() {
        return displayString;
    }
    }

    
    public ConfigFileEditor() {
    
    super(Gatherer.g_man, true);
    setModal(true);
    setSize(SIZE);
    
    String collection_folder_path = Gatherer.getCollectDirectoryPath();
    String collectionName  = Gatherer.c_man.getCollection().getName(); // we won't be in this constructor if collection is null.

    // Gatherer.c_man.saveCollection(); // on Edit > collectionConfig.xml menu click,
    // collection save has already happened as GLI pane.lostFocus() got called on current GLI Pane
    // if/where this affects collectionConfig.xml. For an explanation, see GUIManager.java,
    // look for "if(esrc == menu_bar.edit_config)"

    this.config_file = new File(collection_folder_path + File.separator + collectionName, Utility.CONFIG_GS3_FILE); // col config editing is a GS3 feature

    
    // Most of the validation_msg_panel code is from Format4gs3Manager.java
    JPanel validation_msg_panel = new JPanel();
    JLabel validation_label = new JLabel(Dictionary.get("CDM.FormatManager.MessageBox"));
    validation_label.setBorder(new EmptyBorder(10,10,10,10)); // add some margin
    editor_msgarea = new JTextArea();
    
    editor_msgarea.setCaretPosition(0);
    editor_msgarea.setLineWrap(true);
    editor_msgarea.setRows(3);
    editor_msgarea.setWrapStyleWord(false);
    editor_msgarea.setEditable(false);
    editor_msgarea.setToolTipText(Dictionary.get("CDM.FormatManager.MessageBox_Tooltip"));
    validation_msg_panel.setBorder(BorderFactory.createEmptyBorder(2, 0, 0, 0));
    validation_msg_panel.setLayout(new BorderLayout(5, 0));
    validation_msg_panel.add(validation_label, BorderLayout.WEST);
    validation_msg_panel.add(new JScrollPane(editor_msgarea), BorderLayout.CENTER);

    // Find functionality - can extend for Find and Replace
    // taken from https://github.com/bobbylight/RSyntaxTextArea/wiki/Example:-Using-Find-and-Replace
    // Create a toolbar with searching options.
    JToolBar toolBar = new JToolBar();
    searchField = new JTextField(30);
    toolBar.add(searchField);
    nextButton = new JButton("Find Next");
    nextButton.setActionCommand("FindNext");
    nextButton.addActionListener(this);
    toolBar.add(nextButton);
    searchField.addActionListener(this);
    prevButton = new JButton("Find Previous");
    prevButton.setActionCommand("FindPrev");
    prevButton.addActionListener(this);
    toolBar.add(prevButton);
    regexCB = new JCheckBox("Regex");
    toolBar.add(regexCB);
    matchCaseCB = new JCheckBox("Match Case");
    toolBar.add(matchCaseCB);
    
    // the all important XML editor
    editor = new NumberedJTextArea(); // Don't pass in tooltip string for editor:
                                      // The editor's purpose should be obvious, and
                                      // the tooltip annoyingly constantly floats over the editor all the time
    editor.getDocument().addDocumentListener(this);
    // if Ctrl (or Mac equiv) + F is pressed in the config file editing area,
    // then move the focus to the searchField, so the user can start typing the searchTerm
    editor.addKeyListener(new ConfigFileEditorKeyListener());
    
    save_button = new GLIButton(Dictionary.get("General.Save"), Dictionary.get("ConfigFileEditor.Save_Tooltip"));
    cancel_button = new GLIButton(Dictionary.get("General.Cancel"), Dictionary.get("ConfigFileEditor.Cancel_Tooltip")); // tooltip is the same
    cancel_button.addActionListener(this);
    save_button.addActionListener(this);

    // widgets in section for adding security-related XML elements into the collectionConfigXML file
    JLabel addElementLabel = new JLabel(Dictionary.get("ConfigFileEditor.Add_Element_Label"));

    chooseElementComboBox = new JComboBox(ElementOption.values()); // calls the implicit static values() method on Enum class to get an array of all Enum values
    addElementButton = new GLIButton(Dictionary.get("ConfigFileEditor.Add_Label"),
                     Dictionary.get("ConfigFileEditor.Add_Element_Tooltip"));
    elements_available_for_insertion = XMLTools.parseXMLFile("xml/elementsForInsertion.xml", true);
    addElementButton.addActionListener(this);

    // Elements can't be added if gli/classes/xml/elementsForInsertion.xml file
    // does not exist or can't be parsed
    if(elements_available_for_insertion == null) {
        addElementButton.setEnabled(false);
    }
    
    // LAYOUT
    JPanel add_elements_panel = new JPanel(new FlowLayout());
    add_elements_panel.setComponentOrientation(Dictionary.getOrientation());
    add_elements_panel.add(addElementLabel);
    add_elements_panel.add(chooseElementComboBox);
    add_elements_panel.add(addElementButton);
    
    JPanel button_panel = new JPanel(new FlowLayout());
    button_panel.setComponentOrientation(Dictionary.getOrientation());
    button_panel.add(editor.undoButton);
    button_panel.add(editor.redoButton);
    button_panel.add(cancel_button);
    button_panel.add(save_button);
    
    // toolbars_panel to contain find-and-replace toolbar and undo/redo/cancel/save button panel
    JPanel toolbars_panel = new JPanel(new BorderLayout());
    toolbars_panel.add(toolBar, BorderLayout.NORTH);
    toolbars_panel.add(add_elements_panel, BorderLayout.CENTER);
    toolbars_panel.add(button_panel, BorderLayout.SOUTH);
    
    JPanel content_pane = (JPanel) getContentPane();
    content_pane.setComponentOrientation(Dictionary.getOrientation());
    content_pane.setLayout(new BorderLayout());
    content_pane.add(validation_msg_panel, BorderLayout.NORTH);
    content_pane.add(new JScrollPane(editor), BorderLayout.CENTER); // make editor scrollable
    content_pane.add(toolbars_panel, BorderLayout.SOUTH);
    
    // NOW WE CAN PREPARE THE ACTUAL CONTENT TO GO INTO THE XML EDITOR TEXTAREA
    Document xmlDoc = null;
    xmlDoc = XMLTools.parseXMLFile(config_file);

    if(xmlDoc != null) { 

        // Save the collectionConfig.xml before loading it.
        String[] nonEscapingTagNames = { StaticStrings.FORMAT_STR, StaticStrings.DISPLAYITEM_STR };
        XMLTools.writeXMLFile(this.config_file, xmlDoc, nonEscapingTagNames); //prepends proc instruction

        // now load the contents
        editor_msgarea.setBackground(Color.white);
        StringBuffer sb = new StringBuffer();
        XMLTools.xmlNodeToString(sb, xmlDoc.getDocumentElement(), true, "  ", 0);
        editor.setText(sb.toString());
        //editor.setText(elementToString(xmlDoc.getDocumentElement(), true)); // reading in file this way adds processing instruction, which the parser doesn't like.

    } else { // parsing failed
        // so read in file as text and display as text and show the validation box in red

        // Won't re-save file that is already invalid before it's even been edited through this Editor
        System.err.println("*** Warning: Parsing error in file " + config_file + ".");
        System.err.println("*** Not saving ahead of editing.");

        String xml_str = Utility.readFile(config_file);

        // re-parse to get error msg to display in validation field

        // but first get rid of the preprocessing instruction, as this will fail parsing
        String processingInstruction = getProcessingInstruction(xml_str);
        xml_str = xml_str.replace(processingInstruction, "").trim(); // also trim newline at start

        if(!xml_str.equals("")) {

        String msg = XMLTools.parse(xml_str); // re-parse
        editor_msgarea.setBackground(Color.red);
        editor_msgarea.setText(msg); // display the parsing error
        save_button.setEnabled(false);
        addElementButton.setEnabled(false);

        editor.setText(xml_str); // display the xml contents with error and all     
        
        } else {
        editor.setText("");
        editor_msgarea.setText("Empty collection config file");
        }       
    }


    // Final dialog setup & positioning.
    this.setDefaultCloseOperation(DISPOSE_ON_CLOSE); // get rid of this dialog when it's closed (on dispose())
    this.addWindowListener(new WindowAdapter() { // called on dispose. Return focus to any curr GLI Pane
        @Override
        public void windowClosed(WindowEvent we) {
            super.windowClosed(we);         
            Gatherer.g_man.doRegainFocus();
            //Gatherer.g_man.refresh(Gatherer.COLLECTION_OPENED, true);
            Gatherer.g_man.updateUI();
        }
        });
    

    
    getRootPane().setDefaultButton(save_button);
    Dimension screen_size = Configuration.screen_size;
    setLocation((screen_size.width - SIZE.width) / 2, (screen_size.height - SIZE.height) / 2);
    editor.setCaretPosition(0); // start at top of config XML

    // Following has no effect: not sure why on dialog show, with or without requesting focus,
    // it takes some time for the editor to get focus and only if user's mouse curser is
    // hovering over ConfigFileEditor and moves about a bit there.
    // Give editor focus on dialog show, so that Ctrl-F, to shift focus to searchField, will be
    // responsive too. Not working until mouse moves about over editor, despite the suggestion
    // at https://stackoverflow.com/questions/17828264/java-swing-jdialog-default-focus
    editor.requestFocusInWindow();
    }


    public void actionPerformed(ActionEvent e) {
    
    if(e.getSource() == cancel_button) {
        this.dispose(); // get rid of this dialog, we're done
    } 
    else if(e.getSource() == save_button) {
        // write out the XML to the collectionConfig.xml file and we're done.

        // already know the xml in the textarea is valid, else the save_button would have been inactive
        Document xml_file_doc = XMLTools.getDOM(editor.getText());
        // This code from FormatConversionDialog.dispose() 
        // saves the XML, prepending the processing instruction (<?xml ... ?>)
        String[] nonEscapingTagNames = { StaticStrings.FORMAT_STR, StaticStrings.DISPLAYITEM_STR };
        XMLTools.writeXMLFile(this.config_file, xml_file_doc, nonEscapingTagNames);

        this.dispose(); // get rid of this dialog, we're done

        // close and reopen the collection in GLI
        String current_collection_filepath = Gatherer.c_man.getCollection().getCollectionPath();
        ////Gatherer.c_man.closeCollection(); // explicit save was necessary after all
                                              // closeCollection() doesn't auto-save
        ////Gatherer.c_man.loadCollection(current_collection_filepath);

        
        // Fixing bug: Edit > colcfg wasn't being saved on Save when client-GLI.
        // And in fact, it wasn't properly saving in GLI for some GLI panes.
        // That's because save needs to be explicitly called. (Didn't understand how GLI's
        // "autosave" worked until now. GLI > File > Close a collection saves it, but underneath
        // it calles SAVEandCloseCollection.
        
        // Works - but arduous: have to load in the entire collection just because cfg changed?
        // Especial pain with client-GLI where reloading takes forever.
        //Gatherer.g_man.saveThenCloseCurrentCollection();
        //Gatherer.c_man.loadCollection(current_collection_filepath);

        // Better way: don't have to close and reopen the entire collection after editing colCfg.xml
        // This just updates GLI's interface with the current collCfg.xml.
        // Fingers crossed this works for client-GLI, because then the coll won't need to be closed
        // and reopened each time after Edit > collectionCfg.xml gets saved.
        Gatherer.c_man.saveCollection(); // should save colcfg whether GLI or client-GLI
        Gatherer.c_man.reloadAfterConfigFileEdited();
        //Gatherer.g_man.updateUI(); // didn't do what I hoped it would, so is this relevant here?
                     // It's done when a new collection is loaded, so may be useful?
                     // But all my tests concerning GLI > Edit > collConfig.xml worked out without it
        
    }
    
    // Find functionality, can extend for Find and Replace
    // taken from https://github.com/bobbylight/RSyntaxTextArea/wiki/Example:-Using-Find-and-Replace
    else if(e.getSource() == searchField) {
        nextButton.doClick(0);
    }
    else if(e.getSource() == nextButton || e.getSource() == prevButton) {
        // "FindNext" => search forward, "FindPrev" => search backward
        String command = e.getActionCommand();
        boolean forward = "FindNext".equals(command);
        
        // Create an object defining our search parameters.
        SearchContext context = new SearchContext();
        String text = searchField.getText();
        if (text.length() == 0) {
        return;
        }
        context.setSearchFor(text);
        context.setMatchCase(matchCaseCB.isSelected());
        context.setRegularExpression(regexCB.isSelected());
        context.setSearchForward(forward);
        context.setWholeWord(false);

        //boolean found = SearchEngine.find(this.editor, context).wasFound();
        boolean found = false;
        try {
        found = SearchEngine.find(this.editor, context);
        // if the current search string is a correction to a previous invalid regex,
        // then return background colour back to normal
        searchField.setBackground(Color.white);
        if (!found) {
            JOptionPane.showMessageDialog(this, "Text not found");
        }
        } catch(java.util.regex.PatternSyntaxException regex_exception) {
        searchField.setBackground(Color.red);
        JOptionPane.showMessageDialog(this, "Invalid regex");
        }
        
    }
    else if(e.getSource() == addElementButton) {
        
        ElementOption elementToAdd = (ElementOption)chooseElementComboBox.getSelectedItem();
        addElementToConfigFile(elementToAdd);
        
    }
    }

    /** Method to add the selected security-related element to the config file
     * so that the user can then edit it to behave as they wish.
     */
    private void addElementToConfigFile(ElementOption elementOption) {

    // if the user just undid a previous add operation, then the editor would be empty
    // and can't be parsed. In such a case, don't try to add any elements into the editor
    String config_xml_str = editor.getText();
    if(config_xml_str.equals("")) {
        editor_msgarea.setText(Dictionary.get("ConfigFileEditor.Press_Undo_Once_More_First"));
        editor_msgarea.setBackground(Color.orange);
        return;
    }
    Document config_xml_doc = XMLTools.getDOM(config_xml_str);
    // The addElementButton would not have been enabled/available for pressing
    // and we wouldn't be here unless the collConfig xml parses fine.   

    Element targetParent = config_xml_doc.getDocumentElement(); // tentative target element
    

    final String SECURITY = "security"; // just looking for security elements to insert
    final String EXCEPTION = "exception"; // just looking for security elements to insert
    final String DOCUMENTSET = "documentSet"; // just looking for security elements to insert
    
    NodeList children = elements_available_for_insertion.getElementsByTagName(SECURITY);        

    Element elementToAdd = null;
    
    // To find out if the collectionConfig.xml has any security nodes in it already
    NodeList configXMLSecurityNodes = config_xml_doc.getElementsByTagName(SECURITY);

    
    // Switch on an Enum type is interesting:
    // don't have to do "case ElementOption.HIDE_COLLECTION:"
    // and just "case HIDE_COLLECTION:" is fine
    // see https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html

    switch(elementOption) {
    case HIDE_COLLECTION:
        Element publicElement = XMLTools.getNamedElement(
                          config_xml_doc.getDocumentElement(), // parent
                          "metadata", // element name
                          "name", // attribute name
                          "public" // attribute value
                      );
        
        if(publicElement != null) {
        XMLTools.setNodeText(publicElement, "false");
        // done, with elementToAdd = null, no more processing
        } else { // collConfig.xml missing <metadata name="public">true</metadata>
        // need to add in the necessary element from elements_available_for_insertion XML,
        // which is set to hide
        elementToAdd = XMLTools.getNamedElement(
                    elements_available_for_insertion.getDocumentElement(), // parent
                    "metadata", // element name
                    "name", // attribute name
                    "public" // attribute value
                );
        }
        break;
        
    case SECURE_COLLECTION:
    case SECURE_ALL_DOCUMENTS:
    case SECURE_CERTAIN_DOCUMENTS:
        if(configXMLSecurityNodes.getLength() == 0) {
        elementToAdd = (Element)children.item(elementOption.ordinal()-1);
        } else {
        editor_msgarea.setText(Dictionary.get("ConfigFileEditor.Config_Already_Has_Security_Element"));
        editor_msgarea.setBackground(Color.orange);
        }
        break;
        
        
    case ADD_ANOTHER_DOCUMENTSET:
    case ADD_ANOTHER_EXCEPTION:
        
        if(configXMLSecurityNodes.getLength() > 0) {

        // get first security element child of collectionConfigXML file.
        // There should at most be one
        targetParent = (Element)configXMLSecurityNodes.item(0);
        Element lastSecurityElement = (Element)children.item(children.getLength()-1);
        
        if(elementOption == ElementOption.ADD_ANOTHER_DOCUMENTSET) {
            // Get the immediate child called documentSet, not any other descendants by that name
            // i.e. not the child <exception> element's child called <documentSet>, but the last
            // <security> element's <documentSet> element
            elementToAdd = (Element)XMLTools.getChildByTagName(lastSecurityElement, DOCUMENTSET);
        }
        else { // ElementOption.ADD_ANOTHER_EXCEPTION:

            // Get the last <security> element's sole <exception> child
            elementToAdd = (Element)XMLTools.getChildByTagName(lastSecurityElement, EXCEPTION);
        }
        }
        else {
        // Can't Add Another DocSet/Exception element if the collectionConfigXML has no
        // Security element in place to add them into.
        // Display an error/warning if no security element and don't do anything.       
        
        targetParent = null;
        editor_msgarea.setText(Dictionary.get("ConfigFileEditor.Need_Security_Element_To_Add"));
        editor_msgarea.setBackground(Color.orange);
        }
        break;
    }

    if(elementToAdd != null) {
        Node copiedNode = config_xml_doc.importNode(elementToAdd, true);
        targetParent.appendChild(copiedNode);
        StringBuffer xml_str_buf = new StringBuffer();
        // now set the text in the XML editor to reflect the changes to the doc     
        XMLTools.xmlNodeToString(xml_str_buf, config_xml_doc.getDocumentElement(), true, "  ", 0); 
        editor.setText(xml_str_buf.toString()); // display the xml contents with error and all      
    } // TODO: sadly, the act of doing a editor.setText() adds 2 actions to undo history instead of 1
    }
   
    // This method returns a proper processing instruction (starts with <?xml and ends with ?>)
    // else the empty string is returned
    public String getProcessingInstruction(String xmlStr) {
    String processingInstruction = "";

    xmlStr = xmlStr.trim();
    if(xmlStr.startsWith("<?xml")) {
        int endIndex = xmlStr.indexOf("?>"); // end of processing instruction
        
        if(endIndex != -1) {
        endIndex += 2;
        processingInstruction = xmlStr.substring(0, endIndex);
        }
    }   
    return processingInstruction;
    }


    // THE FOLLOWING FUNCTIONS ARE LARGELY FROM Format4gs3Manager.java.EditorListener
    public void changedUpdate(DocumentEvent e)
    {
    update();
    }
    
    public void insertUpdate(DocumentEvent e)
    {
    update();
    updateUndo("insert");
    
    }
    
    public void removeUpdate(DocumentEvent e)
    {
    update();
    updateUndo("remove");
    
    }
    
    private void updateUndo(String from)
    {
    
    editor.undoButton.setEnabled(true);
    }
    
    public void update()
    {
    
    String xml_str = editor.getText();

    // Processing instructions "<?xml...?>" are no longer displayed in the editor (but
    // they are written out to the file on save) so we don't need to deal with them here.
    
    // can't parse with processing instruction <?xml...?>, so remove that
    ///String processingInstruction = getProcessingInstruction(xml_str);
    ///xml_str = xml_str.replace(processingInstruction, "");    
    // now can parse the XML portion without the processing instruction,
    // while the original XML remains unchanged in the editor area  
    // If the processing instruction was incomplete, then xml_str would still
    // include the incomplete processing instruction, and parsing below will catch the error.
    
    String msg = XMLTools.parse(xml_str);
    editor_msgarea.setText(msg);
    
    if (msg.startsWith(XMLTools.WELLFORMED))
        {          
        editor_msgarea.setBackground(Color.white);
        save_button.setEnabled(true);
        }
    else
        {        
        editor_msgarea.setBackground(Color.red);
        save_button.setEnabled(false);
        addElementButton.setEnabled(false);
        }
    }


    // if Ctrl (or Mac equiv) + F is pressed in the config file editing area,
    // then move the focus to the searchField, so the user can start typing the searchTerm
    private class ConfigFileEditorKeyListener
    extends KeyAdapter
    {
    /** Gives notification of key events on the text field */
    public void keyPressed(KeyEvent key_event)
    {
        // Don't hardcode check for Ctrl key "(e.getModifiers() & KeyEvent.CTRL_MASK) != 0)"
        // because Mac uses another modifier key, Command-F instead of Ctrl-F.
        // https://stackoverflow.com/questions/5970765/java-detect-ctrlx-key-combination-on-a-jtree
        if((key_event.getModifiers() == Toolkit.getDefaultToolkit().getMenuShortcutKeyMask())
           && key_event.getKeyCode() == KeyEvent.VK_F) {

        // Instead of requestFocus() or the more forceful sounding grabFocus(),
        // use requestFocusInWindow(), see
        // https://stackoverflow.com/questions/1425392/how-do-you-set-a-focus-on-textfield-in-swing
        ConfigFileEditor.this.searchField.requestFocusInWindow();
        //JOptionPane.showMessageDialog(ConfigFileEditor.this, "Got a key", "Got key " + key_event.getKeyCode(), JOptionPane.INFORMATION_MESSAGE);
        }
    }
    }
}