org.wings.text.DefaultDocument Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of wings Show documentation
The newest version!
/*
 * Copyright 2000,2005 wingS development team.
 *
 * This file is part of wingS (http://wingsframework.org).
 *
 * wingS is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1
 * of the License, or (at your option) any later version.
 *
 * Please see COPYING for the complete licence.
 */
package org.wings.text;

import org.wings.event.SDocumentEvent;
import org.wings.event.SDocumentListener;
import org.wings.util.EditTranscriptGenerator;

import javax.swing.event.DocumentEvent;
import javax.swing.event.EventListenerList;
import javax.swing.text.BadLocationException;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;

/**
 * @author hengels
 */
public class DefaultDocument implements SDocument {
    private final StringBuilder buffer = new StringBuilder();
    private EventListenerList listeners = null;

    /**
     * Indicates if we should fire event immediately when they arise,
     * or if we should collect them for a later delivery
     */
    private boolean delayEvents = false;

    /**
     * All delayed events are stored here
     */
    protected final ArrayList delayedEvents = new ArrayList(5);

    public DefaultDocument() {
    }

    public DefaultDocument(String text) {
        buffer.append(text);
    }

    @Override
    public void setText(String text) {
        String origText = buffer.toString();
        if (origText.equals(text)) {
            return;
        }
        buffer.setLength(0);
        if (text != null){
            buffer.append(text);
        }
        if((listeners == null) || (listeners.getListenerCount() > 0)){
            // If there are any document listeners: Generate document change events!
            List actions = EditTranscriptGenerator.generateEvents(origText, text);

            // and fire them!
            fireChangeUpdate(0, buffer.length());
            for (Object action : actions) {
                DocumentEvent de = (DocumentEvent) action;
                if (de.getType().equals(DocumentEvent.EventType.INSERT)) {
                    fireInsertUpdate(de.getOffset(), de.getLength());
                } else if (de.getType().equals(DocumentEvent.EventType.REMOVE)) {
                    fireRemoveUpdate(de.getOffset(), de.getLength());
                }
            }
        }
    }

    @Override
    public String getText() {
        return buffer.length() == 0 ? "" : buffer.toString();
    }

    @Override
    public String getText(int offset, int length) throws BadLocationException {
        try {
            return buffer.substring(offset, length);
        } catch (IndexOutOfBoundsException e) {
            throw new BadLocationException(e.getMessage(), offset);
        }
    }

    @Override
    public int getLength() {
        return buffer.length();
    }

    @Override
    public void remove(int offset, int length) throws BadLocationException {
        if (length == 0) {
            return;
        }
        try {
            buffer.delete(offset, offset + length);
            fireRemoveUpdate(offset, length);
        } catch (IndexOutOfBoundsException e) {
            throw new BadLocationException(e.getMessage(), offset);
        }
    }

    @Override
    public void insert(int offset, String string) throws BadLocationException {
        if (string == null || string.length() == 0) {
            return;
        }
        try {
            buffer.insert(offset, string);
            fireInsertUpdate(offset, string.length());
        } catch (IndexOutOfBoundsException e) {
            throw new BadLocationException(e.getMessage(), offset);
        }
    }

    @Override
    public SDocumentListener[] getDocumentListeners() {
    	if (listeners != null) {
            return (SDocumentListener[]) listeners.getListeners(SDocumentListener.class);
        } else {
            return (SDocumentListener[]) Array.newInstance(SDocumentListener.class, 0);
        }
	}

	@Override
    public void addDocumentListener(SDocumentListener listener) {
        if (listeners == null)
            listeners = new EventListenerList();
        listeners.add(SDocumentListener.class, listener);
    }

    @Override
    public void removeDocumentListener(SDocumentListener listener) {
        if (listeners == null)
            return;
        listeners.remove(SDocumentListener.class, listener);
    }

    protected void fireInsertUpdate(int offset, int length) {
    	SDocumentEvent e = new SDocumentEvent(this, offset, length, SDocumentEvent.INSERT);

		if (delayEvents) {
			delayedEvents.add(e);
		} else {
			if (listeners == null || listeners.getListenerCount() == 0)
				return;

			Object[] listeners = this.listeners.getListenerList();
			for (int i = listeners.length - 2; i >= 0; i -= 2) {
				((SDocumentListener) listeners[i + 1]).insertUpdate(e);
			}
		}
    }

    protected void fireRemoveUpdate(int offset, int length) {
    	SDocumentEvent e = new SDocumentEvent(this, offset, length, SDocumentEvent.REMOVE);

		if (delayEvents) {
			delayedEvents.add(e);
		} else {
			if (listeners == null || listeners.getListenerCount() == 0)
				return;

			Object[] listeners = this.listeners.getListenerList();
			for (int i = listeners.length - 2; i >= 0; i -= 2) {
				((SDocumentListener) listeners[i + 1]).removeUpdate(e);
			}
		}
    }

    protected void fireChangeUpdate(int offset, int length) {
    	SDocumentEvent e = new SDocumentEvent(this, offset, length, SDocumentEvent.CHANGE);

    	if (delayEvents) {
    		delayedEvents.add(e);
		} else {
			if (listeners == null || listeners.getListenerCount() == 0)
				return;

			Object[] listeners = this.listeners.getListenerList();
			for (int i = listeners.length - 2; i >= 0; i -= 2) {
				((SDocumentListener) listeners[i + 1]).changedUpdate(e);
			}
		}
    }

	@Override
    public boolean getDelayEvents() {
		return delayEvents;
	}

	@Override
    public void setDelayEvents(boolean b) {
		delayEvents = b;
	}

	@Override
    public void fireDelayedIntermediateEvents() {
        for (Object delayedEvent : delayedEvents) {
            SDocumentEvent e = (SDocumentEvent) delayedEvent;

            switch (e.getType()) {
                case SDocumentEvent.INSERT:
                    fireInsertUpdate(e.getOffset(), e.getLength());
                case SDocumentEvent.REMOVE:
                    fireRemoveUpdate(e.getOffset(), e.getLength());
                case SDocumentEvent.CHANGE:
                    fireChangeUpdate(e.getOffset(), e.getLength());
            }
        }
		delayedEvents.clear();
	}

	@Override
    public void fireDelayedFinalEvents() {

	}
}