/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package util;
 
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import javax.swing.undo.UndoManager;
import javax.swing.undo.UndoableEdit;
 
/**
 *
 * @author i30817
 */
public class DefaultUndoManager<ARGUMENT> extends UndoManager {
 
    PropertyChangeSupport prop = new PropertyChangeSupport(this);
    Factory<UndoableEdit, ARGUMENT> factory;
 
    public DefaultUndoManager(Factory<UndoableEdit, ARGUMENT> factory) {
        this.factory = factory;
    }
 
    public UndoableEdit getUndoableEdit(ARGUMENT arg) {
        if (!factory.accepts(arg)) {
            throw new IllegalArgumentException("Illegal factory argument.");
        }
        return factory.create(arg);
    }
 
    public void addPropertyChangeListener(PropertyChangeListener l) {
        prop.addPropertyChangeListener(l);
    }
 
    public void removePropertyChangeListener(PropertyChangeListener l) {
        prop.removePropertyChangeListener(l);
    }
 
    @Override
    public boolean addEdit(UndoableEdit edit) {
        boolean r = super.addEdit(edit);
        prop.firePropertyChange("", "1", "2");
        return r;
    }
 
    @Override
    public boolean replaceEdit(UndoableEdit edit) {
        boolean r = super.replaceEdit(edit);
        prop.firePropertyChange("", "1", "2");
        return r;
    }
 
    @Override
    public void discardAllEdits() {
        super.discardAllEdits();
        prop.firePropertyChange("", "1", "2");
    }
 
    @Override
    public void undoTo(UndoableEdit edit) {
        super.undoTo(edit);
        prop.firePropertyChange("", "1", "2");
    }
 
    @Override
    public void undo() {
        super.undo();
        prop.firePropertyChange("", "1", "2");
    }
 
    @Override
    public void redo() {
        super.redo();
        prop.firePropertyChange("", "1", "2");
    }
 
    @Override
    public void trimForLimit() {
        super.trimForLimit();
        prop.firePropertyChange("", "1", "2");
    }
 
    @Override
    public void trimEdits(int from, int to) {
        super.trimEdits(from, to);
        prop.firePropertyChange("", "1", "2");
    }
 
    @Override
    public void redoTo(UndoableEdit edit) {
        super.redoTo(edit);
        prop.firePropertyChange("", "1", "2");
    }
}
 
Used like this, T2 is a tuple of two:
    private DefaultUndoManager<T2<Integer, Integer>> undoRedo = new DefaultUndoManager(
            new Factory<UndoableEdit, T2<Integer, Integer>>() {
                @Override
                public UndoableEdit create(final T2<Integer, Integer> arg) {
                    return new MovementUndoableEdit(arg.getFirst(), arg.getSecond());
                }
            });

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package util.swing;
 
import java.lang.reflect.Method;
import java.util.LinkedList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.DefaultStyledDocument;
import javax.swing.text.DefaultStyledDocument.ElementSpec;
import javax.swing.text.Element;
 
/**
 * A fast buffered builder for creating DefaultStyledDocuments
 * @author i30817
 */
public class BufferedStyledDocumentBuilder {
 
    private final long MEMORY_CAPACITY_CHARS;
    private int bufferedChars;
    private final LinkedList<ElementSpec> textList = new LinkedList<ElementSpec>();
    private final char[] par = {'\n'};
    private final char[] space = {' '};
    private final DefaultStyledDocument doc;
    private final Insert insertFunctor;
 
 
 
    private interface Insert {
        void insert();
    }
 
    private final class InsertStyledDocument implements Insert {
 
        private final Method bulkInsert;
        private final Object[] bulkInsertArgs;
 
        public InsertStyledDocument() {
            try {
                Class[] args = new Class[]{Integer.TYPE, new ElementSpec[]{}.getClass()};
                bulkInsertArgs = new Object[2];
                bulkInsert = DefaultStyledDocument.class.getDeclaredMethod("insert", args);
                //naughty
                bulkInsert.setAccessible(true);
            } catch (Throwable ex) {
                throw new RuntimeException(ex);
            }
        }
 
        public void insert() {
            ElementSpec[] arr = new ElementSpec[textList.size()];
            bulkInsertArgs[0] = doc.getLength();
            bulkInsertArgs[1] = textList.toArray(arr);
            try {
                bulkInsert.invoke(doc, bulkInsertArgs);
            } catch (Exception ex) {
                //Should never happen but whatever
                throw new RuntimeException(ex);
            }
        }
    }
 
    private final class InsertMyStyledDocument implements Insert {
 
        private final Method bulkInsert;
        private final Object[] bulkInsertArgs;
 
        public InsertMyStyledDocument() {
            try {
                Class[] args = new Class[]{Integer.TYPE, new ElementSpec[]{}.getClass(), Integer.TYPE};
                bulkInsertArgs = new Object[3];
                bulkInsert = Class.forName("ui.documents.MyStyledDocument").getMethod("insert", args);
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }
        }
 
        public void insert() {
            ElementSpec[] arr = new ElementSpec[textList.size()];
            bulkInsertArgs[0] = doc.getLength();
            bulkInsertArgs[1] = textList.toArray(arr);
            bulkInsertArgs[2] = bufferedChars;
            try {
                bulkInsert.invoke(doc, bulkInsertArgs);
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }
        }
    }
 
    public BufferedStyledDocumentBuilder(DefaultStyledDocument d) {
        doc = d;
        //convert the free memory from bytes to dbytes (char size) and quarter it.
        MEMORY_CAPACITY_CHARS = (int) (Runtime.getRuntime().freeMemory() / 2) / 4;
        //non-dependent runtime testing if it is my subclass
        boolean isMyClass = false;
        try {
            isMyClass = Class.forName("ui.documents.MyStyledDocument").isInstance(d);
        } catch (Throwable e) {
            //do nothing...
        }
 
        if (isMyClass) {
            insertFunctor = new InsertMyStyledDocument();
        } else {
            insertFunctor = new InsertStyledDocument();
        }
    }
 
    public Integer getLength() {
        return Integer.valueOf(doc.getLength() + bufferedChars);
    }
 
    public DefaultStyledDocument getDocument() {
        return doc;
    }
 
    public void clear() {
        try {
            doc.remove(0, doc.getLength());
            bufferedChars = 0;
            textList.clear();
        } catch (BadLocationException ex) {
            throw new RuntimeException(ex);
        }
    }
 
//Far too inefficent 
//    public void remove(int index, int len) {
//        try {
//
//            if ((index + len) <= doc.getLength()) {
//                doc.remove(index, len);
//            } else if (index <= doc.getLength()) {
//                int docLen = doc.getLength() - index;
//                int bufferLen = len - docLen;
//                doc.remove(index, docLen);
//                removeRangeFromBuffer(0, bufferLen);
//            } else {
//                removeRangeFromBuffer(index, len);
//            }
//
//        } catch (BadLocationException ex) {
//            ex.printStackTrace();
//        }
//    }
//
//    private void removeRangeFromBuffer(int index, int len) {
//        if (len > 0) {
//            ListIterator<ElementSpec> i = textList.listIterator();
//
//            ElementSpec firstInRange = null, lastInRange = null;
//            int acc = 0, firstInRangeStartIndex = 0, lastInRangeEndIndex = 0, endIndex = index + len;
//
//            while (i.hasNext()) {
//                ElementSpec current = i.next();
//                acc += current.getLength();
//
//                if (index <= acc && endIndex >= acc) {
//                    if (firstInRange == null) {
//                        firstInRangeStartIndex = index - (acc - current.getLength());
//                        firstInRange = current;
//                    }
//                    bufferedChars -= current.getLength();
//                    i.remove();
//                } else if (endIndex < acc) {
//                    lastInRangeEndIndex = endIndex - (acc - current.getLength());
//                    lastInRange = current;
//                    bufferedChars -= current.getLength();
//                    i.remove();
//                    break;
//                }
//            }
//
//            if (firstInRange != null && firstInRangeStartIndex != 0) {
//                ElementSpec s = new ElementSpec(firstInRange.getAttributes(), ElementSpec.ContentType, firstInRange.getArray(), 0, firstInRangeStartIndex);
//                i.add(s);
//                bufferedChars += s.getLength();
//            }
//            if (lastInRange != null && lastInRangeEndIndex != lastInRange.getLength()) {
//                ElementSpec s = new ElementSpec(lastInRange.getAttributes(), ElementSpec.ContentType, lastInRange.getArray(), lastInRangeEndIndex, lastInRange.getLength() - lastInRangeEndIndex);
//                i.add(s);
//                bufferedChars += s.getLength();
//            }
//        }
//    }
 
    /**
     * Removes the last inserted \n.
     * No checking so you must know you inserted a \n by insertEnd before.
     */
    public void removeEnd() {
        if(textList.isEmpty()){
            try {
                doc.remove(doc.getLength() - 1, 1);
            } catch (BadLocationException ex) {
                throw new RuntimeException(ex);
            }
            
        }else{
            textList.removeLast();
            textList.removeLast();
            textList.removeLast();
            bufferedChars = bufferedChars - 1;
            
        }
    }
    
    public void insertSpace(AttributeSet currentAttributes) {
        insert(space, currentAttributes);
    }
    
    public void insertEnd(AttributeSet currentAttributes) {
        bufferedChars += 1;
        ElementSpec e = new ElementSpec(currentAttributes.copyAttributes(), ElementSpec.ContentType, par, 0, 1);
        textList.add(e);
        e = new ElementSpec(null, ElementSpec.EndTagType);
        textList.add(e);
        //Every non first Element needs a start type so the stack based document tree doesn't go bonkers
        //Paragraph element is aleatory, using the first element to reuse the object.
        Element paragraph = doc.getParagraphElement(0);
        AttributeSet pattr = paragraph.getAttributes();
        e = new ElementSpec(pattr, ElementSpec.StartTagType);
        textList.add(e);
    }
 
    public void insert(char[] s, AttributeSet currentAttributes) {
        textList.add(new ElementSpec(currentAttributes.copyAttributes(), ElementSpec.ContentType, s, 0, s.length));
        bufferedChars += s.length;
 
        if (bufferedChars > MEMORY_CAPACITY_CHARS) {
            commit();
        }
    }
 
    public void insert(char[] s, int len, AttributeSet currentAttributes) {
        textList.add(new ElementSpec(currentAttributes.copyAttributes(), ElementSpec.ContentType, s, 0, len));
        bufferedChars += len;
 
        if (bufferedChars > MEMORY_CAPACITY_CHARS) {
            commit();
        }
    }
 
    public void commit() {
        insertFunctor.insert();
        bufferedChars = 0;
        textList.clear();
    }
}