<target name="basic-init" depends="projectized-common.basic-init">

        <!--

        when this is fixed: http://www.netbeans.org/issues/show_bug.cgi?id=69794

        use this property value instead

        -->

        <property name="module-patch-dir"

                  value="${cluster}/modules/patches/org-openide-awt"/>

        <!--

        <property name="module-patch-dir"

                  value="${netbeans.dest.dir}/platform6/modules/patches/org-openide-awt"/>

        -->

        <property name="module-patch"

                  value="${module-patch-dir}/Nb55UndoRedo-patch.jar"/>

        <property name="patch-source-dir"

                  value="patchsrc"/>

        <property name="patch-build-dir"

                  value="build/patch"/>

    </target>

    <target name="compile" depends="projectized-common.compile">

        <mkdir dir="${patch-build-dir}"/>

        <javac srcdir="${patch-source-dir}"

               destdir="${patch-build-dir}"

               debug="${build.compiler.debug}"

               debuglevel="${build.compiler.debuglevel}"

               deprecation="${build.compiler.deprecation}"

               optimize="${build.compiler.optimize}"

               source="${javac.source}"

               target="${javac.target}"

               includeantruntime="false">

            <classpath>

                <path refid="cp"/>

                <pathelement location="build/classes"/> 

            </classpath>

        </javac>

    </target>

    <target name="jar" depends="projectized-common.jar">

        <mkdir dir="${module-patch-dir}"/>

        <jar destfile="${module-patch}"

             basedir="${patch-build-dir}"

             compress="${build.package.compress}"/>

    </target>

    <target name="clean" depends="projectized-common.clean">

        <delete dir="${module-patch-dir}"/>

        <delete dir="${patch-build-dir}"/>

    </target>

    }

    /** <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 restoreBuildUndoGroup = buildUndoGroup;

            buildUndoGroup = false;

            undoGroup.end();

            super.addEdit(undoGroup);

            undoGroup = null;

            buildUndoGroup = restoreBuildUndoGroup;

        }

        /**

         * 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(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);

        }*/