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

/**
 *#########################################################################
 *
 * 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;

    private GLIButton cancel_button = null;
    private GLIButton save_button = null;
    private NumberedJTextArea editor = null;
    private JTextArea editor_msgarea;

    
    // 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);

    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(Dictionary.get("ConfigFileEditor.Tooltip"));
    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);

    // LAYOUT
    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(button_panel, BorderLayout.CENTER);
    
    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);

        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.
    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
        public void windowClose(WindowEvent we) {
            Gatherer.g_man.doRegainFocus();
        }
        });
    

    
    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");
        }
        
    }
    }
    
   
    // 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);
        }
    }


    // 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);
        }
    }
    }
}