}

    /** <tt>UndoGroupManager</tt> extends {@link UndoManager}

     * and allows explicit control of what

     * <tt>UndoableEdit</tt>s are coalesced into compound edits,

     * rather than using the rules defined by the edits themselves.

     * Other than the default usage, special handling is initiated by invoking

     * <tt>beginUndoGroup()</tt>.

     * <p>

     * Three use cases are supported.

     * </p>

     * <ol>

     * <li> Default behavior is defined by {@link UndoManager}.</li>

     * <li> <tt>UnddoableEdit</tt>s issued between {@link #beginUndoGroup}

     * and {@link endUndoGroup} are placed into a single {@link CompoundEdit}.

     * Thus <tt>undo()</tt> and <tt>redo()</tt> treat them atomically.</li>

     * <li> Use {@link commitUndoGroup} to place any accumulated

     * <tt>UndoableEdit</tt>s into a <tt>CompoundEdit</tt>;

     * an application could do this at strategic points, such as EndOfLine

     * input or cursor movement. In this way, the application can accumulate

     * large chunks, but this behavior would not be enabled unless

     * <tt>beginUndoGroup</tt> is first invoked.</li>

     * </ol>

     * Note that the semantics of {@link UndoManager} are preserved at all

     * times, so certain methods, such as <tt>undo()</tt>, automatically issue

     * <tt>commitUndoGroup()</tt>.

     * @see UndoManager

     */

    public static class UndoGroupManager extends UndoManager {

        /** signals that edits should be accumulated */

        private boolean buildUndoGroup;

        /** accumulate edits here in undoGroup */

        private CompoundEdit undoGroup;

        /**

         * Direct this <tt>UndoGroupManager</tt> to begin coalescing any

         * <tt>UndoableEdit</tt>s that are added into a <tt>CompoundEdit</tt>.

         * <p>If edits are already being coalesced and some have been 

         * accumulated, they are commited as an atomic group and a new

         * group is started.

         * @see #addEdit

         * @see #endUndoGroup

         * @see #commitUndoGroup

         */

        public synchronized void beginUndoGroup() {

            commitUndoGroup();

            buildUndoGroup = true;

        }

        /**

         * Direct this <tt>UndoGroupManager</tt> to stop coalescing edits.

         * {@link #commitUndoGroup} is invoked to save accumulated edits as

         * an atomic group.

         * Until <tt>beginUndoGroupManager</tt> is invoked,

         * received <tt>UndoableEdit</tt>s are added singly.

         * <p>

         * This has no effect if edits are not being coalesced, for example

         * if <tt>beginUndoGroup</tt> has not been called.

         * @see #commitUndoGroup

         */

        public synchronized void endUndoGroup() {

            buildUndoGroup = false;

            commitUndoGroup();

        }

        /**

         * Commit any accumulated <tt>UndoableEdit</tt>s as an atomic

         * <tt>undo</tt>/<tt>redo</tt> group. {@link CompoundEdit#end}

         * is invoked on the <tt>CompoundEdit</tt> and it is added as a single

         * <tt>UndoableEdit</tt> to this <tt>UndoManager</tt>.

         * <p>

         * If edits are currently being coalesced, a new undo group is started.

         * This has no effect if edits are not being coalesced, for example

         * <tt>beginUndoGroup</tt> has not been called.

         */

        public synchronized void commitUndoGroup() {

            if(undoGroup == null) {

                return;

            }

            // super.addEdit may end up in this.addEdit,

            // so buildUndoGroup must be false

            boolean saveBuildUndoGroup = buildUndoGroup;

            buildUndoGroup = false;

            undoGroup.end();

            super.addEdit(undoGroup);

            undoGroup = null;

            buildUndoGroup = saveBuildUndoGroup;

        }

        // HACK ALERT! There are a variety of "marker" edits added to track

        // the modified state of the file. These can not be coalesced into

        // an undo group. So for proof of concept, detect them questionably.

        private static final String magicClassPrefix

                = "org.openide.text.CloneableEditorSupport$";

        /* return true if the edit is a magic marker, else false. */

        private boolean isMagic(UndoableEdit anEdit) {

            return anEdit.getClass().getName().startsWith(magicClassPrefix);

        }

        /** Add this edit atomically, not part of a group.

         * @return super.addEdit

         */

        private boolean commitAddEdit(UndoableEdit anEdit) {

            commitUndoGroup();

            boolean saveBuildUndoGroup = buildUndoGroup;

            buildUndoGroup = false;

            boolean f = super.addEdit(anEdit);

            //boolean f = addEdit(undoGroup);

            buildUndoGroup = saveBuildUndoGroup;

            return f;

        }

        /** AtomicEdit tags an UndoableEdit so the

         * UndoGroupManager does not coalesce it.

         */

        public interface AtomicEdit {

        }

        /**

         * If this <tt>UndoManager</tt> is coalescing edits then add

         * <tt>anEdit</tt> to the accumulating <tt>CompoundEdit</tt>.

         * Otherwise, add it to this UndoManager. In either case the

         * edit is saved for later <tt>undo</tt> or <tt>redo</tt>.

         * @return {@inheritDoc}

         * @see #beginUndoGroup

         * @see #endUndoGroup

         * @see #commitUndoGroup

         */

        public synchronized boolean addEdit(UndoableEdit anEdit) {

            if(!isInProgress())

                return false;

            if(buildUndoGroup) {

                if(anEdit instanceof AtomicEdit || isMagic(anEdit))

                    return commitAddEdit(anEdit);

                if(undoGroup == null)

                    undoGroup = new CompoundEdit();

                return undoGroup.addEdit(anEdit);

            } else {

                return super.addEdit(anEdit);

            }

        }

        /** {@inheritDoc} */

        public synchronized void discardAllEdits() {

            commitUndoGroup();

            super.discardAllEdits();

        }

        //

        // TODO: limits

        //

        /** {@inheritDoc} */

        public synchronized void undoOrRedo() {

            commitUndoGroup();

            super.undoOrRedo();

        }

        /** {@inheritDoc} */

        public synchronized boolean canUndoOrRedo() {

            if(undoGroup != null)

                return true;

            return super.canUndoOrRedo();

        }

        /** {@inheritDoc} */

        public synchronized void undo() {

            commitUndoGroup();

            super.undo();

        }

        /** {@inheritDoc} */

        public synchronized boolean canUndo() {

            if(undoGroup != null)

                return true;

            return super.canUndo();

        }

        /** {@inheritDoc} */

        public synchronized void redo() {

            if(undoGroup != null)

                throw new CannotRedoException();

            super.redo();

        }

        /** {@inheritDoc} */

        public synchronized boolean canRedo() {

            if(undoGroup != null)

                return false;

            return super.canRedo();

        }

        /** {@inheritDoc} */

        public synchronized void end() {

            commitUndoGroup();

            super.end();

        }

        /** {@inheritDoc} */

        public synchronized String getUndoOrRedoPresentationName() {

            if(undoGroup != null)

                return undoGroup.getUndoPresentationName();

            return super.getUndoOrRedoPresentationName();

        }

        /** {@inheritDoc} */

        public synchronized String getUndoPresentationName() {

            if(undoGroup != null)

                return undoGroup.getUndoPresentationName();

            return super.getUndoPresentationName();

        }

        /** {@inheritDoc} */

        public synchronized String getRedoPresentationName() {

            if(undoGroup != null)

                return undoGroup.getRedoPresentationName();

            return super.getRedoPresentationName();

        }

        /** {@inheritDoc} */

        public boolean isSignificant() {

            if(undoGroup != null && undoGroup.isSignificant()) {

                return true;

            }

            return super.isSignificant();

        }

        /** {@inheritDoc} */

        public synchronized void die() {

            commitUndoGroup();

            super.die();

        }

        /** {@inheritDoc} */

        public String getPresentationName() {

            if(undoGroup != null)

                return undoGroup.getPresentationName();

            return super.getPresentationName();

        }

        // The protected methods are only accessed from

        // synchronized methods that commitUndoGroup,

        // they do not need to be in this class

        /*protected UndoableEdit editToBeUndone() {

            if(undoGroup != null)

                return null;

            return super.editToBeUndone();

        }

        protected UndoableEdit editToBeRedone() {

            if(undoGroup != null)

                return null;

            return super.editToBeRedone();

        }

        protected void undoTo(UndoableEdit edit) {

            if(undoGroup != null)

                throw new CannotUndoException();

            super.undoTo(edit);

        }

        protected void redoTo(UndoableEdit edit) {

            if(undoGroup != null)

                throw new CannotRedoException();

            super.redoTo(edit);

        }*/