/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.netbeans.modules.properties;

import java.awt.EventQueue;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.event.ActionListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.beans.PropertyVetoException;
import java.beans.VetoableChangeListener;
import java.beans.VetoableChangeSupport;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.Action;
import javax.swing.event.ChangeListener;
import javax.swing.JPanel;
import javax.swing.JTable;
import javax.swing.SwingUtilities;
import javax.swing.undo.CannotRedoException;
import javax.swing.undo.CannotUndoException;

import org.openide.actions.FindAction;
import org.openide.awt.UndoRedo;
import org.openide.cookies.CloseCookie;
import org.openide.cookies.OpenCookie;
import org.openide.cookies.SaveCookie;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileStateInvalidException;
import org.openide.filesystems.FileStatusEvent;
import org.openide.filesystems.FileStatusListener;
import org.openide.filesystems.FileSystem;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;
import org.openide.nodes.Node;
import org.openide.NotifyDescriptor;
import org.openide.DialogDisplayer;
import org.openide.ErrorManager;
import org.openide.nodes.Node.Cookie;
import org.openide.util.Exceptions;
import org.openide.util.HelpCtx;
import org.openide.util.ImageUtilities;
import org.openide.util.Mutex;
import org.openide.util.NbBundle;
import org.openide.util.WeakListeners;
import org.openide.util.WeakSet;
import org.openide.util.actions.SystemAction;
import org.openide.windows.CloneableOpenSupport;
import org.openide.windows.CloneableTopComponent;
import org.openide.DialogDescriptor;
import org.openide.text.DataEditorSupport;


/** 
 * Support for opening bundle of .properties files (OpenCookie) in table view editor. 
 * 
 * @author Petr Jiricka, Peter Zavadsky
 */
public class PropertiesOpen extends CloneableOpenSupport
                            implements OpenCookie, CloseCookie {

    private static final Logger LOG = Logger.getLogger(PropertiesOpen.class.getName());
    /** Main properties dataobject */
    @Deprecated
    PropertiesDataObject propDataObject;


    private List<PropertiesDataObject> dataObjectList;

    private BundleStructure bundleStructure;
    /** Listener for modificationc on dataobject, adding and removing save cookie */
    PropertyChangeListener modifL;

    HashMap<PropertiesDataObject,PropertyChangeListener> weakModifiedListeners;

    /** UndoRedo manager for this properties open support */
    protected transient UndoRedo undoRedoManager;

    /** This object is used for marking all undoable edits performed as one atomic undoable action. */
    transient Object atomicUndoRedoFlag;

    private transient Object UPDATE_LOCK = new Object();
    

    /** Constructor */
    @Deprecated
    public PropertiesOpen(PropertiesDataObject propDataObject) {
        super(new Environment(propDataObject));
        
        this.propDataObject = propDataObject;

        //PENDING Add Listeners for all DataObject from this OpenSupport
        this.propDataObject.addPropertyChangeListener(WeakListeners.propertyChange(modifL =
            new ModifiedListener(), this.propDataObject));
    }

    public PropertiesOpen(BundleStructure structure) {
        super(new Environment(structure));

        this.bundleStructure = structure;
        //Listeners added later in addDataObject method
//        addModifiedListeners();
        dataObjectList = new ArrayList<PropertiesDataObject>();
        weakModifiedListeners = new HashMap<PropertiesDataObject, PropertyChangeListener>();
        modifL = new ModifiedListener();
    }

    protected void removeModifiedListener(PropertiesDataObject dataObject) {
        PropertyChangeListener l = weakModifiedListeners.remove(dataObject);
        if (l!=null) {
            dataObject.removePropertyChangeListener(l);
        }
        PropertiesCloneableTopComponent topComp = (PropertiesCloneableTopComponent) allEditors.getArbitraryComponent();
        if (topComp != null) {
            topComp.dataObjectRemoved(dataObject);
        }
        dataObjectList.remove(dataObject);
    }

    protected void addDataObject(PropertiesDataObject dataObject) {
            PropertyChangeListener l = weakModifiedListeners.get(dataObject);
            if (l != null) {
                dataObject.removePropertyChangeListener(l);
            } else {
                l = WeakListeners.propertyChange(modifL, dataObject);
                weakModifiedListeners.put(dataObject,l);
            }
            dataObject.addPropertyChangeListener(l);
            ((Environment)env).addListener(dataObject);
            if (((Environment)env).isModified())
                try {
                   ((Environment) env).markModified(dataObject);
                   if (dataObject.getCookie(SaveCookie.class) == null) {
                       dataObject.getCookieSet0().add((Cookie) modifL);
                   }
                } catch (IOException ex) {
                    Exceptions.printStackTrace(ex);
                }
            PropertiesCloneableTopComponent topComp = (PropertiesCloneableTopComponent) allEditors.getArbitraryComponent();
            if (topComp != null) {
                topComp.dataObjectAdded(dataObject);
            }
        if (!dataObjectList.contains(dataObject)) {
            dataObjectList.add(dataObject);
        }
    }
    /** 
     * Tests whether all data is saved, and if not, prompts the user to save.
     *
     * @return {@code true} if everything can be closed
     */
    @Override
    protected boolean canClose() {
        PropertiesDataObject dataObject;
        SaveCookie saveCookie = null;
        HashMap<SaveCookie,PropertiesDataObject> map = new HashMap<SaveCookie,PropertiesDataObject>();
        for (PropertiesFileEntry e : bundleStructure.getEntries()) {
            dataObject = (PropertiesDataObject) e.getDataObject();
            saveCookie = dataObject.getCookie(SaveCookie.class);
            //Need to find all saveCookie
            if (saveCookie != null) map.put(saveCookie, dataObject);
        }
        if (map.isEmpty()) {
            return true;
        }
        stopEditing();
        if (!shouldAskSave()) {
            return true;
        }
        
        /* Create and display a confirmation dialog - Save/Discard/Cancel: */
        String title = NbBundle.getMessage(PropertiesOpen.class,
                                           "CTL_Question");         //NOI18N
        String question = NbBundle.getMessage(PropertiesOpen.class,
                                              "MSG_SaveFile",       //NOI18N
                                              bundleStructure.getNthEntry(0).getName());
        String optionSave = NbBundle.getMessage(PropertiesOpen.class,
                                                "CTL_Save");        //NOI18N
        String optionDiscard = NbBundle.getMessage(PropertiesOpen.class,
                                                   "CTL_Discard");  //NOI18N
        NotifyDescriptor descr = new DialogDescriptor(
                question,
                title,                              //title
                true,                               //modal
                new Object[] {optionSave,
                              optionDiscard,
                              NotifyDescriptor.CANCEL_OPTION},
                optionSave,                         //default option
                DialogDescriptor.DEFAULT_ALIGN,     //alignment of the options
                null,                               //help context
                (ActionListener) null);
        descr.setMessageType(NotifyDescriptor.QUESTION_MESSAGE);
        Object answer = DialogDisplayer.getDefault().notify(descr);
        
        /* Save the file if the answer was "Save": */
        if (answer == optionSave) {
            try {
                for (SaveCookie save : map.keySet()) {
                    save.save();
                    map.get(save).updateModificationStatus();
                }
            }
            catch (IOException e) {
                ErrorManager.getDefault().notify(e);
                return false;
            }
        }
        dataObject = null;
        for (int i=0;i<bundleStructure.getEntryCount();i++) {
            dataObject = (PropertiesDataObject) bundleStructure.getNthEntry(i).getDataObject();
            dataObject.updateModificationStatus();
        }

        return (answer == optionSave || answer == optionDiscard);
    }

    private void stopEditing() {
        saveEditorValues(true);
    }
    
    /**
     * Saves values of cells being edited and optionally stops the cell editing.
     *
     * @param  saveValueOnly  if {@code true}, just the cell values will be
     *                        saved to the model but the editor remains active
     */
    private void saveEditorValues(boolean stopEditing) {
        Enumeration en = allEditors.getComponents();
        if (en.hasMoreElements() == false) {
            PropertiesCloneableTopComponent topComp = (PropertiesCloneableTopComponent) allEditors.getArbitraryComponent();
            if (topComp != null) {
                BundleEditPanel bep = (BundleEditPanel) topComp.getComponent(0);
                if (stopEditing) {
                    bep.stopEditing();
                } else {
                    bep.saveEditorValue(false);
                }
            }
        }
        while (en.hasMoreElements()) {
            Object o = en.nextElement();
            if (o instanceof PropertiesCloneableTopComponent) {
                BundleEditPanel bep = (BundleEditPanel)((PropertiesCloneableTopComponent)o).getComponent(0);
                if (stopEditing) {
                    bep.stopEditing();
                } else {
                    bep.saveEditorValue(false);
                }
            }
        }
    }
    
    /** 
     * Overrides superclass abstract method. 
     * A method to create a new component.
     * @return the cloneable top component for this support
     */
    @Override
    protected CloneableTopComponent createCloneableTopComponent() {
//        return new PropertiesCloneableTopComponent(propDataObject);
        return new PropertiesCloneableTopComponent(bundleStructure);
    }

    /**
     * Overrides superclass abstract method. 
     * Message to display when an object is being opened.
     * @return the message or null if nothing should be displayed
     */
    @Override
    protected String messageOpening() {
        bundleStructure.updateEntries();
        PropertiesFileEntry primaryEntry = bundleStructure.getNthEntry(0);
        String primaryEntryName = primaryEntry != null ? primaryEntry.getName() : "";
        FileObject fo = primaryEntry != null ? primaryEntry.getFile() : null;
        String primaryEntryFile = fo != null ? fo.toString() : "" ; // #190125
        return NbBundle.getMessage(PropertiesOpen.class,
                                   "LBL_ObjectOpen", // NOI18N
                                   primaryEntryName,
                                   primaryEntryFile);
    }

    /** 
     * Overrides superclass abstract method.
     * Message to display when an object has been opened.
     * @return the message or null if nothing should be displayed
     */
    @Override
    protected String messageOpened() {
        return NbBundle.getMessage(PropertiesOpen.class, "LBL_ObjectOpened"); // NOI18N
    }

    /** @return whether has open table view component. */
    public synchronized boolean hasOpenedTableComponent() {
        return !allEditors.isEmpty();
    }

    /** Gets UndoRedo manager for this OpenSupport. */
    public UndoRedo getUndoRedo () {
        if (undoRedoManager == null)
            undoRedoManager = new CompoundUndoRedoManager(bundleStructure);
        return undoRedoManager;
    }

    /** Helper method. Closes documents. */
    private synchronized void closeDocuments() {
        for (int i = 0; i< bundleStructure.getEntryCount(); i++) {
            PropertiesFileEntry nthEntry = bundleStructure.getNthEntry(i);
            if (nthEntry != null) {
                closeEntry(nthEntry);
            }
        }
    }

    /** Helper method. Closes entry. */
    private void closeEntry(PropertiesFileEntry entry) {
        PropertiesEditorSupport editorSupport = entry.getPropertiesEditor();
        if (editorSupport.hasOpenedEditorComponent()) {
            // Has opened editor view for this entry -> don't close document.
            return;
        } else {
            // Hasn't opened editor view for this entry -> close document.
            editorSupport.forceNotifyClosed();
            
            // #17221. Don't reparse invalid or virtual file.
            if(entry.getFile().isValid() && !entry.getFile().isVirtual()) {
                entry.getHandler().autoParse();
            }
        }
    }

    /**
     * Helper method. Should be called only if the object has SaveCookie
     * @return true if closing this editor whithout saving would result in loss of data
     *  because al least one of the modified files is not open in the code editor
     */
    private boolean shouldAskSave() {
        // for each entry : if there is a SaveCookie and no open editor component, return true.
        // if passed for all entries, return false
        BundleStructure structure = bundleStructure;
        PropertiesFileEntry entry;
        SaveCookie savec;
        for (int i = 0; i < structure.getEntryCount(); i++) {
            entry = structure.getNthEntry(i);
            savec = entry.getCookie(SaveCookie.class);
            if ((savec != null) && !entry.getPropertiesEditor().hasOpenedEditorComponent()) {
                return true;
            }
        }
        return false;
    }


    /** Environment that connects the open support together with {@code DataObject}. */
    private static class Environment implements CloneableOpenSupport.Env, Serializable,
        PropertyChangeListener, VetoableChangeListener {
            
        /** Generated Serialized Version UID */
        static final long serialVersionUID = -1934890789745432531L;
        
        /** Object to serialize and be connected to. */
        @Deprecated
        private DataObject dataObject;

        private BundleStructure bundleStructure;
        
        /** Support for firing of property changes. */
        private transient PropertyChangeSupport propSupp;
        
        /** Support for firing of vetoable changes. */
        private transient VetoableChangeSupport vetoSupp;

        private transient HashMap<PropertiesDataObject, PropertyChangeListener> weakEnvPropListeners;
        private transient HashMap<PropertiesDataObject, VetoableChangeListener> weakEnvVetoListeners;
        
        /** 
         * Constructor. Attaches itself as listener to 
         * the data object so, all property changes of the data object
         * are also rethrown to own listeners.
         * @param dataObject data object to be attached to
         */
        @Deprecated
        public Environment(PropertiesDataObject dataObject) {
            this.dataObject = dataObject;
            dataObject.addPropertyChangeListener(WeakListeners.propertyChange(this, dataObject));
            dataObject.addVetoableChangeListener(WeakListeners.vetoableChange(this, dataObject));
        }

        public Environment(BundleStructure structure) {
            this.bundleStructure = structure;
            PropertiesFileEntry entry = bundleStructure.getNthEntry(0);
            if (entry != null)
                dataObject = entry.getDataObject();
            //Listeners added later by addListener method
//            addListeners();
            weakEnvPropListeners = new HashMap<PropertiesDataObject, PropertyChangeListener>();
            weakEnvVetoListeners = new HashMap<PropertiesDataObject, VetoableChangeListener>();
        }


        private void addListener(PropertiesDataObject dataObj) {
            PropertyChangeListener l =weakEnvPropListeners.get(dataObj);
            VetoableChangeListener v = weakEnvVetoListeners.get(dataObj);
            if (l != null) {
                dataObj.removePropertyChangeListener(l);
            } else {
                l = WeakListeners.propertyChange(this, dataObj);
                weakEnvPropListeners.put(dataObj, l);
            }
            if (v != null) {
                dataObj.removeVetoableChangeListener(v);
            } else {
                v = WeakListeners.vetoableChange(this, dataObj);
                weakEnvVetoListeners.put(dataObj, v);
            }
            dataObj.addPropertyChangeListener(l);
            dataObj.addVetoableChangeListener(v);
        }

        private  void addListeners() {
            BundleStructure structure = bundleStructure;
            PropertiesDataObject dataObj;
            weakEnvPropListeners = new HashMap<PropertiesDataObject, PropertyChangeListener>();
            weakEnvVetoListeners = new HashMap<PropertiesDataObject, VetoableChangeListener>();
            PropertyChangeListener l;
            VetoableChangeListener v;
            for(int i=0;i<structure.getEntryCount();i++) {
                dataObj = (PropertiesDataObject) structure.getNthEntry(i).getDataObject();
                l = WeakListeners.propertyChange(this, dataObj);
                weakEnvPropListeners.put(dataObj, l);
                dataObj.addPropertyChangeListener(l);
                v = WeakListeners.vetoableChange(this, dataObj);
                weakEnvVetoListeners.put(dataObj, v);
                dataObj.addVetoableChangeListener(v);
            }

        }

        private void removeListeners() {
            BundleStructure structure = bundleStructure;
            PropertiesDataObject dataObj;
            PropertyChangeListener l;
            VetoableChangeListener v;
            for(int i=0;i<structure.getEntryCount();i++) {
                dataObj = (PropertiesDataObject) structure.getNthEntry(i).getDataObject();
                l = weakEnvPropListeners.remove(dataObj);
                v = weakEnvVetoListeners.remove(dataObj);
                if (l!=null) {
                    dataObj.removePropertyChangeListener(l);
                }
                if (v!=null) {
                    dataObj.removeVetoableChangeListener(v);
                }
            }
        }

        /** Implements {@code CloneableOpenSupport.Env} interface. Adds property listener. */
        @Override
        public void addPropertyChangeListener(PropertyChangeListener l) {
            prop().addPropertyChangeListener(l);
        }

        /** Implements {@code CloneableOpenSupport.Env} interface. Removes property listener. */
        @Override
        public void removePropertyChangeListener(PropertyChangeListener l) {
            prop().removePropertyChangeListener(l);
        }

        /** Implements {@code CloneableOpenSupport.Env} interface. Adds veto listener. */
        @Override
        public void addVetoableChangeListener(VetoableChangeListener l) {
            veto().addVetoableChangeListener(l);
        }

        /** Implements {@code CloneableOpenSupport.Env} interface. Removes veto listener. */
        @Override
        public void removeVetoableChangeListener(VetoableChangeListener l) {
            veto().removeVetoableChangeListener(l);
        }

        /**
         * Implements {@code CloneableOpenSupport} interface.
         * Method that allows environment to find its cloneable open support.
         * @return the support or null if the environemnt is not in valid 
         * state and the CloneableOpenSupport cannot be found for associated
         * data object
         */
        @Deprecated
        //TODO PENDING Called from super class need to preserve
        @Override
        public CloneableOpenSupport findCloneableOpenSupport() {
            if (dataObject != null)
                return (CloneableOpenSupport) dataObject.getCookie(OpenCookie.class);
            return null;
        }

        public CloneableOpenSupport findCloneableOpenSupport(PropertiesDataObject dataObject) {
            if (dataObject != null)
                return (CloneableOpenSupport)dataObject.getCookie(OpenCookie.class);
            return null;
        }

        /** 
         * Implements {@code CloneableOpenSupport.Env} interface.
         * Test whether the support is in valid state or not.
         * It could be invalid after deserialization when the object it
         * referenced to does not exist anymore.
         * @return true or false depending on its state
         */
        @Deprecated
        @Override
        public boolean isValid() {
            return dataObject.isValid();
        }

        public boolean isValid(PropertiesDataObject dataObject) {
            return dataObject.isValid();
        }

        /**
         * Implements {@code CloneableOpenSupport.Env} interface. 
         * Test whether the object is modified or not.
         * @return true if the object is modified
         */
        @Override
        public boolean isModified() {
            //if one dataObject is modified assume that everything modified
            PropertiesFileEntry entry;
            for (int i=0; i < bundleStructure.getEntryCount();i++) {
                entry = bundleStructure.getNthEntry(i);
                if ((entry !=null) && (entry.getDataObject().isModified()) ) {
                    return true;
                }
            }
            return false;
        }

        public boolean isModified(PropertiesDataObject dataObject) {
            return dataObject.isModified();
        }

        /**
         * Implements {@code CloneableOpenSupport.Env} interface. 
         * Support for marking the environement modified.
         * @exception IOException if the environment cannot be marked modified
         *   (for example when the file is readonly), when such exception
         *   is the support should discard all previous changes
         */
        @Deprecated
        @Override
        public void markModified() throws java.io.IOException {
            dataObject.setModified(true);
        }

        public void markModified(PropertiesDataObject dataObject) throws java.io.IOException {
            dataObject.setModified(true);
        }
        /** 
         * Implements {@code CloneableOpenSupport.Env} interface.
         * Reverse method that can be called to make the environment unmodified.
         */
        @Deprecated
        @Override
        public void unmarkModified() {
            dataObject.setModified(false);
        }

        public void unmarkModified(PropertiesDataObject dataObject) {
            dataObject.setModified(false);
        }
        
        /** 
         * Implements {@code PropertyChangeListener} interface.
         * Accepts property changes from {@code DataObject} and fires them to own listeners.
         */
        @Override
        public void propertyChange(PropertyChangeEvent evt) {
            if(DataObject.PROP_MODIFIED.equals(evt.getPropertyName())) {
                PropertiesDataObject dataObj = null;
                if (evt.getSource() instanceof PropertiesDataObject) {
                    dataObj = (PropertiesDataObject) evt.getSource();
                }
                if (dataObj!=null) {
                    if(dataObj.isModified()) {
                        dataObj.addVetoableChangeListener(this);
                    } else {
                        dataObj.removeVetoableChangeListener(this);
                    }
                }
            } else if(DataObject.PROP_VALID.equals(evt.getPropertyName ())) { 
                // We will handle the object invalidation here.
                // Do not check it if old value is not true.
                if (Boolean.FALSE.equals(evt.getOldValue())) {
                    return;
                }

                PropertiesDataObject dataObj = null;
                if (evt.getSource() instanceof PropertiesDataObject) {
                    dataObj = (PropertiesDataObject) evt.getSource();
                }
                if (dataObj != null) {
                    PropertyChangeListener l = weakEnvPropListeners.remove(dataObj);
                    VetoableChangeListener  v = weakEnvVetoListeners.remove(dataObj);
                    if (l!=null) {
                        dataObj.removePropertyChangeListener(l);
                    }
                    if (v!=null) {
                        dataObj.removeVetoableChangeListener(v);
                    }
                    // Mark the object as not being modified, so nobody
                    // will ask for save.
                    unmarkModified(dataObj);
                    bundleStructure.updateEntries();
                    if (bundleStructure.getEntryCount() == 0) {
                        // Loosing validity.
                        PropertiesOpen support = (PropertiesOpen)findCloneableOpenSupport();
                        if(support != null ) {
                            //bundleStructure.updateEntries();
                            support.close(false);
                        }
                    } else {
                        bundleStructure.notifyOneFileChanged(dataObj.getPrimaryFile());
                    }
                }
            } else if (DataObject.PROP_NAME.equals(evt.getPropertyName())) {
                PropertiesDataObject dataObj = null;
                if (evt.getSource() instanceof PropertiesDataObject) {
                    dataObj = (PropertiesDataObject) evt.getSource();
                }
                if (dataObj != null) {
                    OpenCookie cookie = dataObj.getCookieSet0().getCookie(OpenCookie.class);
                    if (cookie != dataObj.getOpenSupport()) {
                        PropertyChangeListener l = weakEnvPropListeners.remove(dataObj);
                        VetoableChangeListener v = weakEnvVetoListeners.remove(dataObj);
                        if (l!=null) {
                            dataObj.removePropertyChangeListener(l);
                        }
                        if (v!=null) {
                            dataObj.removeVetoableChangeListener(v);
                        }
                        // remove old open cookie
                        if (cookie != null) {
                            // remove also open cookie factory, new open cookie will be added.
                            dataObj.getCookieSet0().remove(PropertiesOpen.class, dataObj);
                            dataObj.getCookieSet0().remove(cookie);
                        }
                        //Adds new OpenCookie to this dataObj
                        dataObj.getCookieSet0().add(dataObj.getOpenSupport());
                        if (dataObj.getBundleStructure().getEntryCount()>1) {
                            dataObj.getBundleStructure().updateEntries();
                            dataObj.getBundleStructure().notifyOneFileChanged(dataObj.getPrimaryFile());
                            dataObj.getOpenSupport().open();
                        }
                    }
                }
            } else if (DataObject.PROP_PRIMARY_FILE.equals(evt.getPropertyName())) {
                //Here DataObject is valid and with new path
                PropertiesDataObject dataObj = null;
                if (evt.getSource() instanceof PropertiesDataObject) {
                    dataObj = (PropertiesDataObject) evt.getSource();
                }
                if (dataObj != null) {
                    OpenCookie cookie = dataObj.getCookieSet0().getCookie(OpenCookie.class);
                    if (cookie != dataObj.getOpenSupport()) {
                        PropertyChangeListener l = weakEnvPropListeners.remove(dataObj);
                        VetoableChangeListener v = weakEnvVetoListeners.remove(dataObj);
                        if (l!=null) {
                            dataObj.removePropertyChangeListener(l);
                        }
                        if (v!=null) {
                            dataObj.removeVetoableChangeListener(v);
                        }
                        // remove old open cookie
                        if (cookie != null) {
                            // remove also open cookie factory, new open cookie will be added.
                            dataObj.getCookieSet0().remove(PropertiesOpen.class, dataObj);
                            dataObj.getCookieSet0().remove(cookie);
                        }
                        //Adds new OpenCookie to this dataObj
                        dataObj.getCookieSet0().add(dataObj.getOpenSupport());
                        if (dataObj.getBundleStructure().getEntryCount()>1) {
                            dataObj.getBundleStructure().updateEntries();
                            dataObj.getBundleStructure().notifyOneFileChanged(dataObj.getPrimaryFile());
                        }
                    } else {
                        //shouldn't get here
                    }
                }
            } else {
                firePropertyChange (
                    evt.getPropertyName(),
                    evt.getOldValue(),
                    evt.getNewValue()
                );
            }
        }
        
        /**
         * Implements <code>VetoAbleChangeListener</code> interface. 
         * Accepts vetoable changes and fires them to own listeners.
         */
        @Override
        public void vetoableChange(PropertyChangeEvent evt) throws PropertyVetoException {
            fireVetoableChange (
                evt.getPropertyName(),
                evt.getOldValue(),
                evt.getNewValue()
            );
        }
        
        /** Fires property change.
        * @param name the name of property that changed
        * @param oldValue old value
        * @param newValue new value
        */
        private void firePropertyChange (String name, Object oldValue, Object newValue) {
            prop().firePropertyChange(name, oldValue, newValue);
        }
        
        /** Fires vetoable change.
        * @param name the name of property that changed
        * @param oldValue old value
        * @param newValue new value
        */
        private void fireVetoableChange (String name, Object oldValue, Object newValue) throws PropertyVetoException {
            veto().fireVetoableChange(name, oldValue, newValue);
        }
        
        /** Lazy gets property change support. */
        private PropertyChangeSupport prop() {
            synchronized (this) {
                if (propSupp == null) {
                    propSupp = new PropertyChangeSupport(this);
                }
            }
            return propSupp;
        }
        
        /** Lazy gets vetoable change support. */
        private VetoableChangeSupport veto() {
            synchronized (this) {
                if (vetoSupp == null) {
                    vetoSupp = new VetoableChangeSupport(this);
                }
            }
            return vetoSupp;
        }
    } // End of inner class Environment.
    
    
    /** Inner class. Listens to modifications and updates save cookie. */
    private final class ModifiedListener implements SaveCookie, PropertyChangeListener {


        /** Gives notification that the DataObject was changed.
        * @param ev PropertyChangeEvent
        */
        @Override
        public void propertyChange(PropertyChangeEvent evt) {
            // Data object changed, reset the UndoRedo manager.
            if (DataObject.PROP_MODIFIED.equals(evt.getPropertyName())) {
                if (evt.getSource() instanceof  PropertiesDataObject) {
                    PropertiesDataObject dataObject = (PropertiesDataObject) evt.getSource();
                    if (!dataObject.isValid()) {
                            if (!((Boolean)evt.getNewValue()).booleanValue()) {
                                removeSaveCookie(dataObject);
                            }
                    } else
                    if(bundleStructure.getEntryByFileName(dataObject.getName())!=null) {
                        ((CompoundUndoRedoManager) PropertiesOpen.this.getUndoRedo()).reset(bundleStructure);
                            if (((Boolean)evt.getNewValue()).booleanValue()) {
                                addSaveCookie(dataObject);
                            } else {
                                removeSaveCookie(dataObject);
                            }
                     }
                }
            }
        }

        /** Implements {@code SaveCookie} interface. */
        @Override
        public void save() throws IOException {
            /*
             * At first, save the value of the cell being edited,
             * without making any UI changes.
             */
            saveEditorValues(false);

            // do saving job
            saveDocument();

            /* Update the UI: */
            Mutex.EVENT.writeAccess(new Runnable() {
                @Override
                public void run() {
                    stopEditing();
                }
            });
        }

        /** Save the document in this thread.
        * Create "orig" document for the case that the save would fail.
        * @exception IOException on I/O error
        */
        public void saveDocument() throws IOException {
            BundleStructure structure = bundleStructure;
            SaveCookie save;
            for (int i=0; i<structure.getEntryCount();i++) {
                PropertiesFileEntry pfe = structure.getNthEntry(i);
                if(pfe != null) { // #184927
                    save = pfe.getCookie(SaveCookie.class);
                    if (save != null) {
                        save.save();
                    }
                }
            }
        }

        /** Adds save cookie to the dataobject. */
        @Deprecated
        private void addSaveCookie() {
            if(propDataObject.getCookie(SaveCookie.class) == null) {
                propDataObject.getCookieSet0().add(this);
            }
        }

        private void addSaveCookie(PropertiesDataObject propDataObject) {
            if(propDataObject.getCookie(SaveCookie.class) == null) {
                propDataObject.getCookieSet0().add(this);
            }
        }
        
        /** Removes save cookie from the dataobject. */
        @Deprecated
        private void removeSaveCookie() {
            if(propDataObject.getCookie(SaveCookie.class) == this) {
                propDataObject.getCookieSet0().remove(this);
            }
        }

        private void removeSaveCookie(PropertiesDataObject propDataObject) {
            if(propDataObject.getCookie(SaveCookie.class) == this) {
                propDataObject.getCookieSet0().remove(this);
            }
        }
    } // End of inner class ModifiedListener.

    
    /** Inner class for opening at a given key. */
    public class PropertiesOpenAt implements OpenCookie {

        /** Entry the key belongs to. */
        private PropertiesFileEntry entry;
        
        /** Key where to open at. */
        private String key;

        
        /** Construcor. */
        PropertiesOpenAt(PropertiesFileEntry entry, String key) {
            this.entry = entry;
            this.key   = key;
        }

        
        /** Setter for key property. */
        public void setKey(String key) {
            this.key = key;
        }

        /** Implements {@code OpenCookie}. Opens document. */
        @Override
        public void open() {
            // Instead of PropertiesOpen.super.open() so we get reference to TopComponent.
            // Note: It is strange for me that calling PropetiesOpen.this.openCloneableTopComponent throw s exception at run-time.
            final PropertiesCloneableTopComponent editor = (PropertiesCloneableTopComponent)PropertiesOpen.super.openCloneableTopComponent();
            editor.requestActive();
            
            BundleStructure bs = bundleStructure;
            bs.updateEntries();
            // Find indexes.
            int entryIndex = bs.getEntryIndexByFileName(entry.getFile().getName());
            int rowIndex   = bs.getKeyIndexByName(key);
            
            if ((entryIndex != -1) && (rowIndex != -1)) {
                final int row = rowIndex;
                final int column = entryIndex + 1;

                SwingUtilities.invokeLater(new Runnable() {
                    @Override
                    public void run() {
                        JTable table = ((BundleEditPanel)editor.getComponent(0)).getTable();
                        // Autoscroll to cell if possible and necessary.
                        if (table.getAutoscrolls()) { 
                            Rectangle cellRect = table.getCellRect(row, column, false);
                            if (cellRect != null) {
                                table.scrollRectToVisible(cellRect);
                            }
                        }

                        // Update selection & edit.
//XXX This caused to open properties for editing with wrong values
//                        table.getColumnModel().getSelectionModel().setSelectionInterval(row, column);
//                        table.getSelectionModel().setSelectionInterval(row, column);

                        table.editCellAt(row, column);
                    }
                });
            }
        }
    } // End of inner class PropertiesOpenAt.


    /** Cloneable top component which represents table view of resource bundles. */
    public static class PropertiesCloneableTopComponent extends CloneableTopComponent {

        /** Reference to underlying {@code PropertiesDataObject}. */
        @Deprecated
        private PropertiesDataObject propDataObject;

        private List<PropertiesDataObject> dataObjectsList;
        /** Listener for changes on {@code propDataObject} name and cookie properties.
         * Changes display name of components accordingly. */
        private transient PropertyChangeListener nameUpdaterListener;

        private transient static HashMap<PropertiesDataObject,PropertyChangeListener> weakNameUpdateListeners;

        /** Generated serial version UID. */
        static final long serialVersionUID =2836248291419024296L;
        
        private final static transient Object UPDATE_LOCK = new Object();
        /** Default constructor for deserialization. */
        public PropertiesCloneableTopComponent() {
        }

        @Override
        protected void componentHidden() {
            ((BundleEditPanel)getComponent(0)).getTable().firePropertyChange("componentHidden", 0, 1);  //NOI18N
            super.componentHidden();
        }

        /** Constructor.
        * @param propDataObject data object we belong to */
        @Deprecated
        public PropertiesCloneableTopComponent (PropertiesDataObject propDataObject) {
            this.propDataObject  = propDataObject;

            initialize();
        }

        private MultiBundleStructure bundleStructure;

        public PropertiesCloneableTopComponent(BundleStructure structure) {
            this.bundleStructure = (MultiBundleStructure) structure;
            propDataObject = (PropertiesDataObject) bundleStructure.getNthEntry(0).getDataObject();
            dataObjectsList = new ArrayList<PropertiesDataObject>();
            for (int i=0; i<bundleStructure.getEntryCount();i++) {
                dataObjectsList.add((PropertiesDataObject)bundleStructure.getNthEntry(i).getDataObject());
            }
            weakNameUpdateListeners = new HashMap<PropertiesDataObject, PropertyChangeListener>();
            initialize();
        }
        /**
         */
        @Override
        public void open() {
            if (discard()) {
                return;
            }
            super.open();
        }

        @Override
        public void requestActive() {
            super.requestActive();
            getComponent(0).requestFocusInWindow();
        }
        
        @Override
        public boolean canClose () {
            ((BundleEditPanel)getComponent(0)).stopEditing();
            return super.canClose();
        }
        
        /** Initializes this instance. Used by construction and deserialization. */
        private void initialize() {
            initComponents();
            setupActions();
            BundleStructure structure = bundleStructure;
            PropertiesDataObject dataObject;

            Node[] node = new Node[structure.getEntryCount()];
            nameUpdaterListener = new NameUpdater();

            for( int i=0; i<structure.getEntryCount();i++) {
                    dataObject = dataObjectsList.get(i);
                    node[i] = dataObject.getNodeDelegate();
                    weakNameUpdateListeners.put(dataObject,WeakListeners.propertyChange(nameUpdaterListener, dataObject));
                    dataObject.addPropertyChangeListener(weakNameUpdateListeners.get(dataObject));
            }
            
            setActivatedNodes(node);

            updateName();
        }

        protected void dataObjectRemoved(PropertiesDataObject dataObject) {
            PropertyChangeListener l = weakNameUpdateListeners.remove(dataObject);
            if (l != null) {
                dataObject.removePropertyChangeListener(l);
            }
            if (!dataObjectsList.remove(dataObject)) {
                LOG.log(Level.WARNING,
                        "{0} not in the list", //NOI18N
                        dataObject.getName());
            }
        }

        /**
         * Called from PropertiesOpen when new DataObject added
         * @param dataObject to add listener to
         */
        protected void dataObjectAdded(PropertiesDataObject dataObject) {
            if (weakNameUpdateListeners.get(dataObject)!=null) {
                dataObject.removePropertyChangeListener(weakNameUpdateListeners.get(dataObject));
            } else {
                weakNameUpdateListeners.put(dataObject, WeakListeners.propertyChange(nameUpdaterListener, dataObject));
            }
            dataObject.addPropertyChangeListener(weakNameUpdateListeners.get(dataObject));
            if (dataObjectsList.indexOf(dataObject) == -1) {
                dataObjectsList.add(dataObject);
            }
            if (EventQueue.isDispatchThread()) {
                updateName();
                updateDisplayName();
            }
        }

        /* Based on class DataNode.PropL. */
        final class NameUpdater implements PropertyChangeListener,
                                           FileStatusListener,
                                           Runnable {
            
            /** */
            private static final int NO_ACTION = 0;
            /** */
            private static final int ACTION_UPDATE_NAME = 1;
            /** */
            private static final int ACTION_UPDATE_DISPLAY_NAME = 2;
            
            /** weak version of this listener */
            private FileStatusListener weakL;
            /** previous filesystem we were attached to */
            private FileSystem previous;
            
            /** */
            private final int action;

            /**
             */
            NameUpdater() {
                this(NO_ACTION);
                updateStatusListener();
            }
            
            /**
             */
            NameUpdater(int action) {
                this.action = action;
            }
            
            /** Updates listening on a status of filesystem. */
            private void updateStatusListener() {
                if (previous != null) {
                    previous.removeFileStatusListener(weakL);
                }
                try {
                    PropertiesFileEntry entry = bundleStructure.getNthEntry(0);
                    if (entry == null) {
                        bundleStructure.updateEntries();
                        entry = bundleStructure.getNthEntry(0);
                        if (entry == null) {
                            previous = null;
                            return;
                        }
                    }
                    previous = entry.getFile().getFileSystem();
                    if (weakL == null) {
                        weakL = org.openide.filesystems.FileUtil
                                .weakFileStatusListener(this, previous);
                    }
                    previous.addFileStatusListener(weakL);
                } catch (FileStateInvalidException ex) {
                    previous = null;
                }
            }
            
            /**
             * Notifies listener about change in annotataion of a few files.
             */
            @Override
            public void annotationChanged(FileStatusEvent ev) {
                if (!ev.isNameChange()) {
                    return;
                }
                
                boolean thisChanged = false;
                for (int i=0;i<bundleStructure.getEntryCount();i++) {
                    PropertiesFileEntry pfe = bundleStructure.getNthEntry(i);
                    if(pfe != null && ev.hasChanged(pfe.getFile())) { // #172691
                        thisChanged = true;
                        break;
                    }
                }
                if (thisChanged) {
                    Mutex.EVENT.writeAccess(
                            new NameUpdater(ACTION_UPDATE_DISPLAY_NAME));
                }
            }
            
            @Override
            public void propertyChange(PropertyChangeEvent e) {
                //PENDING Add correct propDataObject
                if (bundleStructure.getEntryCount() == 0) {return;}
                if (e.getSource() instanceof PropertiesDataObject) {
                    PropertiesDataObject DO = (PropertiesDataObject) e.getSource();
                    try {
                        if ((DO == Util.findPrimaryDataObject(DO)) && (!DO.isValid())) {
                            return;
                        }
                    } catch (DataObjectNotFoundException ex) {
                        Exceptions.printStackTrace(ex);
                    }
                }
                
                final String property = e.getPropertyName();
                if (property == null) {
                    return;
                }
                if (property.equals(DataObject.PROP_NAME)) {
                    Mutex.EVENT.writeAccess(
                            new NameUpdater(ACTION_UPDATE_NAME));
                } else if (property.equals(DataObject.PROP_PRIMARY_FILE)) {
                    updateStatusListener();
                    Mutex.EVENT.writeAccess(
                            new NameUpdater(ACTION_UPDATE_NAME));
                } else if (property.equals(DataObject.PROP_COOKIE)
                           || property.equals(DataObject.PROP_FILES)) {
                    Mutex.EVENT.writeAccess(
                            new NameUpdater(ACTION_UPDATE_DISPLAY_NAME));
                }
            }
            
            @Override
            public void run() {
                assert EventQueue.isDispatchThread();
                
                if (action == ACTION_UPDATE_NAME) {
                    updateName();
                } else if (action == ACTION_UPDATE_DISPLAY_NAME) {
                    updateDisplayName();
                } else {
                    assert false;
                }
            }
            
        }
        
        /**
         * Sets up action Find that it is activated/deactivated appropriately
         * and so that it does what it should do.
         */
        private void setupActions() {
            JTable bundleTable = ((BundleEditPanel) getComponent(0)).getTable();
            FindAction findAction = SystemAction.get(FindAction.class);
            Action action = FindPerformer.getFindPerformer(bundleTable);
            getActionMap().put(findAction.getActionMapKey(), action);
        }
        
        /**
         */
        private void updateName() {
            assert EventQueue.isDispatchThread();
            if (bundleStructure.getNthEntry(0)==null)
                bundleStructure.updateEntries();
            final String name = bundleStructure.getNthEntry(0).getName();
            final String displayName = displayName();
            final String htmlDisplayName = htmlDisplayName();
            final String toolTip = messageToolTip();
            
            Enumeration<CloneableTopComponent> en = getReference().getComponents();
            while (en.hasMoreElements()) {
                CloneableTopComponent tc = en.nextElement();
                tc.setName(name);
                tc.setDisplayName(displayName);
                tc.setHtmlDisplayName(htmlDisplayName);
                tc.setToolTipText(toolTip);
            }
        }
        
        /**
         */
        private void updateDisplayName() {
            assert EventQueue.isDispatchThread();
            
            final String displayName = displayName();
            final String htmlDisplayName = htmlDisplayName();
            final String toolTip = messageToolTip();
            
            Enumeration<CloneableTopComponent> en = getReference().getComponents();
            while (en.hasMoreElements()) {
                CloneableTopComponent tc = en.nextElement();
                tc.setDisplayName(displayName);
                tc.setHtmlDisplayName(htmlDisplayName);
                tc.setToolTipText(toolTip);
            }
        }
        
        private boolean isModified() {
            PropertiesFileEntry entry;
            for (int i=0;i<bundleStructure.getEntryCount();i++) {
                entry = bundleStructure.getNthEntry(i);
                if(entry != null && entry.getDataObject().getLookup().lookup(SaveCookie.class) != null) {
                    return true;
                }
            }
            return false;
        }

        /**
         * Builds a display name for this component.
         *
         * @return  the created display name
         * @see  #htmlDisplayName
         */
        private String displayName() {
            //PENDING change to avoid call getNthEntry, in some cases it will throw an exception
            if (bundleStructure.getNthEntry(0)==null) {
                bundleStructure.updateEntries();
            }
            String nameBase = bundleStructure.getNthEntry(0).getDataObject().getNodeDelegate().getDisplayName();
            return DataEditorSupport.annotateName(nameBase, false, isModified(), false);
        }
        
        /**
         * Builds a HTML display name for this component.
         *
         * @return  the created display name
         * @see  #displayName()
         */
        private String htmlDisplayName() {
            if (bundleStructure.getNthEntry(0)==null) {
                bundleStructure.updateEntries();
            }
            final Node node = bundleStructure.getNthEntry(0).getDataObject().getNodeDelegate();
            String displayName = node.getHtmlDisplayName();
            if (displayName != null) {
                if (!displayName.startsWith("<html>")) {                //NOI18N
                    displayName = "<html>" + displayName;               //NOI18N
                }
            } else {
                displayName = node.getDisplayName();
            }
            return DataEditorSupport.annotateName(displayName, true, isModified(), false);
        }
        
        /** Gets string for tooltip. */
        private String messageToolTip() {
            FileObject fo = bundleStructure.getNthEntry(0).getFile();
            return DataEditorSupport.toolTip(fo, isModified(), false);
        }
        
        /**
         * 
         * Overrides superclass method. When closing last view, also close the document.
         * @return {@code true} if close succeeded
         */
        @Override
        protected boolean closeLast () {
            if (!bundleStructure.getOpenSupport().canClose ()) {
                // if we cannot close the last window
                return false;
            }
            bundleStructure.getOpenSupport().closeDocuments();
            PropertyChangeListener l;
            for (PropertiesDataObject dataObject:dataObjectsList) {
                l = weakNameUpdateListeners.get(dataObject);
                if (l!=null) {
                    dataObject.removePropertyChangeListener(l);
                    weakNameUpdateListeners.remove(dataObject);
                }
            }
            return true;
        }

        /**
         * Is called from the superclass {@code clone} method to create new component from this one.
         * This implementation only clones the object by calling super.clone method.
         * @return the copy of this object
         */
        @Override
        protected CloneableTopComponent createClonedObject () {
            return new PropertiesCloneableTopComponent(bundleStructure);
        }

        /** Gets {@code Icon}. */
        @Override
        public Image getIcon () {
            return ImageUtilities.loadImage("org/netbeans/modules/properties/propertiesEditorMode.gif"); // NOI18N
        }

        /** Gets help context. */
        @Override
        public HelpCtx getHelpCtx () {
            return new HelpCtx(Util.HELP_ID_MODIFYING);
        }
        
        @Override
        protected String preferredID() {
            return getName();
        }
        
        @Override
        public int getPersistenceType() {
            return PERSISTENCE_ONLY_OPENED;
        }
        
        /** 
         * Gets compound UndoRedo manager from all UndozRedo managers from all editor supports. 
         */
        @Override
        public UndoRedo getUndoRedo () {
            return  bundleStructure.getOpenSupport().getUndoRedo();
        }

        /** Inits the subcomponents. Sets layout for this top component and adds {@code BundleEditPanel} to it. 
         * @see BundleEditPanel */
        private void initComponents() {
            GridBagLayout gridbag = new GridBagLayout();
            setLayout(gridbag);

            GridBagConstraints c = new GridBagConstraints();
            c.fill = GridBagConstraints.BOTH;
            c.weightx = 1.0;
            c.weighty = 1.0;
            c.gridwidth = GridBagConstraints.REMAINDER;
            JPanel panel = new BundleEditPanel(bundleStructure, new PropertiesTableModel(bundleStructure));
            gridbag.setConstraints(panel, c);
            add(panel);
        }
        
        /** This component should be discarded if the associated environment
         *  is not valid.
         */
        private boolean discard () {
            return bundleStructure == null;
        }
        

        /**
         * Serialize this top component.
         * Subclasses wishing to store state must call the super method, then write to the stream.
         * @param out the stream to serialize to
         */
        @Override
        public void writeExternal (ObjectOutput out) throws IOException {
            super.writeExternal(out);
            out.writeObject(bundleStructure.getNthEntry(0).getDataObject());
        }

        /** 
         * Deserialize this top component.
         * Subclasses wishing to store state must call the super method, then read from the stream.
         * @param in the stream to deserialize from
         */
        @Override
        public void readExternal (ObjectInput in) throws IOException, ClassNotFoundException {
            super.readExternal(in);

            propDataObject = (PropertiesDataObject)in.readObject();
            bundleStructure = (MultiBundleStructure) propDataObject.getBundleStructure();
            dataObjectsList = new ArrayList<PropertiesDataObject>();
            for (int i=0;i<bundleStructure.getEntryCount();i++) {
                dataObjectsList.add((PropertiesDataObject) bundleStructure.getNthEntry(i).getDataObject());
            }
            weakNameUpdateListeners = new HashMap<PropertiesDataObject, PropertyChangeListener>();
            initialize();
        }
    } // End of nested class PropertiesCloneableTopComponent.

    /**
     * {@code UndoRedo} manager for {@code PropertiesOpen} support. It contains weak references
     * to all UndoRedo managers from all PropertiesEditor supports (for each entry of dataobject one manager).
     * It uses it's "timeStamp" methods to find out which one of these managers comes to play.
     */
    private static class CompoundUndoRedoManager implements UndoRedo {
        
        /** Set of weak references to all "underlying" editor support undoredo managers. */
        private WeakSet<Manager> managers = new WeakSet<Manager>(5);
        
        // Constructor
        
        /** Collects all UndoRedo managers from all editor support of all entries. */
        @Deprecated
        public CompoundUndoRedoManager(PropertiesDataObject obj) {
            init(obj);
        }
        public CompoundUndoRedoManager(BundleStructure structure) {
            init(structure);
        }

        /** Initialize set of managers. */
        @Deprecated
        private void init(PropertiesDataObject obj) {
            BundleStructure structure = obj.getBundleStructure();
            PropertiesEditorSupport editorSupport = null;
            for(int i=0; i< structure.getEntryCount(); i++) {
                editorSupport = structure.getNthEntry(i).getPropertiesEditor();
                if (editorSupport != null) {
                    managers.add(editorSupport.getUndoRedoManager());
                }
            }
        }

        private void init(BundleStructure structure) {
            PropertiesFileEntry entry;
            for(int i=0; i< structure.getEntryCount(); i++) {
                entry = structure.getNthEntry(i);
                if (entry != null)
                    managers.add(entry.getPropertiesEditor().getUndoRedoManager());
            }
        }

        /** Resets the managers. Used when data object has changed. */
        @Deprecated
        public synchronized void reset(PropertiesDataObject obj) {
            managers.clear();
            init(obj);
        }

        public synchronized void reset(BundleStructure structure) {
            managers.clear();
            init(structure);
        }

        /** Gets manager which undo edit comes to play.*/
        private UndoRedo getNextUndo() {
            UndoRedo chosenManager = null;
            long time = 0L; // time to compare with
            long timeManager; // time of next undo of actual manager
            
            for (Iterator<Manager> it = managers.iterator(); it.hasNext(); ) {
                PropertiesEditorSupport.UndoRedoStampFlagManager manager = (PropertiesEditorSupport.UndoRedoStampFlagManager)it.next();
                timeManager = manager.getTimeStampOfEditToBeUndone();
                if(timeManager > time) {
                    time = timeManager;
                    chosenManager = manager;
                }
            }
            return chosenManager;
        }
        
        /** Gets manager which redo edit comes to play.*/
        private UndoRedo getNextRedo() {
            UndoRedo chosenManager = null;
            long time = 0L; // time to compare with
            long timeManager; // time of next redo of actual manager
            
            for (Iterator<Manager> it = managers.iterator(); it.hasNext(); ) {
                PropertiesEditorSupport.UndoRedoStampFlagManager manager = (PropertiesEditorSupport.UndoRedoStampFlagManager)it.next();
                timeManager = manager.getTimeStampOfEditToBeRedone();
                if(timeManager > time) {
                    time = timeManager;
                    chosenManager = manager;
                }
            }
            return chosenManager;
        }
        
        /** Implements {@code UndoRedo}. Test whether at least one of managers can Undo.
         * @return {@code true} if undo is allowed
         */
        @Override
        public synchronized boolean canUndo () {
            for (Manager manager : managers) {
                if (manager.canUndo()) {
                    return true;
                }
            }
            return false;
        }

        /** Implements {@code UndoRedo}. Test whether at least one of managers can Redo.
         * @return {@code true} if redo is allowed
         */
        @Override
        public synchronized boolean canRedo () {
            for (Manager manager : managers) {
                if (manager.canRedo()) {
                    return true;
                }
            }
            return false;
        }

        /** Implements {@code UndoRedo}. Undo an edit. It finds a manager which next undo edit has the highest 
         * time stamp and makes undo on it.
         * @exception CannotUndoException if it fails
         */
        @Override
        public synchronized void undo () throws CannotUndoException {
            PropertiesEditorSupport.UndoRedoStampFlagManager chosenManager = (PropertiesEditorSupport.UndoRedoStampFlagManager)getNextUndo();

            if (chosenManager == null) {
                throw new CannotUndoException();
            } else {
                Object atomicFlag = chosenManager.getAtomicFlagOfEditToBeUndone();
                if (atomicFlag == null) {// not linked with other edits as one atomic action
                    chosenManager.undo();
                } else { // atomic undo compound from more edits in underlying managers
                    boolean undone;
                    do { // the atomic action can consists from more undo edits from same manager
                        undone = false;
                        for (Iterator<Manager> it = managers.iterator(); it.hasNext(); ) {
                            PropertiesEditorSupport.UndoRedoStampFlagManager manager = (PropertiesEditorSupport.UndoRedoStampFlagManager)it.next();
                            if(atomicFlag.equals(manager.getAtomicFlagOfEditToBeUndone())) {
                                manager.undo();
                                undone = true;
                            }
                        }
                    } while(undone);
                }
            }
        }

        /** Implements {@code UndoRedo}. Redo a previously undone edit. It finds a manager which next undo edit has the highest 
         * time stamp and makes undo on it.
         * @exception CannotRedoException if it fails
         */
        @Override
        public synchronized void redo () throws CannotRedoException {
            PropertiesEditorSupport.UndoRedoStampFlagManager chosenManager = (PropertiesEditorSupport.UndoRedoStampFlagManager)getNextRedo();

            if (chosenManager == null) {
                throw new CannotRedoException();
            } else {
                Object atomicFlag = chosenManager.getAtomicFlagOfEditToBeRedone();
                if (atomicFlag == null) {// not linked with other edits as one atomic action
                    chosenManager.redo();
                } else { // atomic redo compound from more edits in underlying managers
                    boolean redone;
                    do { // the atomic action can consists from more redo edits from same manager
                        redone = false;
                        for (Iterator<Manager> it = managers.iterator(); it.hasNext(); ) {
                            PropertiesEditorSupport.UndoRedoStampFlagManager manager = (PropertiesEditorSupport.UndoRedoStampFlagManager)it.next();
                            if(atomicFlag.equals(manager.getAtomicFlagOfEditToBeRedone())) {
                                manager.redo();
                                redone = true;
                            }
                        }
                    } while(redone);
                }
            }
        }

        /** Implements {@code UndoRedo}. Empty implementation. Does nothing.
         * @param l the listener to add
         */
        @Override
        public void addChangeListener (ChangeListener l) {
            // PENDING up to now listen on separate managers
        }

        /** Implements {@code UndoRedo}. Empty implementation. Does nothing.
         * @param l the listener to remove
         * @see #addChangeListener
         */
        @Override
        public void removeChangeListener (ChangeListener l) {
            // PENDING
        }

        /** Implements {@code UndoRedo}. Get a human-presentable name describing the
         * undo operation.
         * @return the name
         */
        @Override
        public synchronized String getUndoPresentationName () {
            UndoRedo chosenManager = getNextUndo();

            if (chosenManager == null) {
                return "Undo"; // NOI18N // AbstractUndoableEdit.UndoName is not accessible
            } else {
                return chosenManager.getUndoPresentationName();
            }
        }

        /** Implements {@code UndoRedo}. Get a human-presentable name describing the
         * redo operation.
         * @return the name
         */
        @Override
        public synchronized String getRedoPresentationName () {
            UndoRedo chosenManager = getNextRedo();
            if (chosenManager == null) {
                return "Redo"; // NOI18N // AbstractUndoableEdit.RedoName is not accessible
            } else {
                return chosenManager.getRedoPresentationName();
            }
        }
        
    } // End of nested class CompoundUndoRedoManager.
    
}