TFModel.java

package timeflow.model;

import timeflow.data.db.*;
import timeflow.data.db.filter.*;
import timeflow.data.time.*;


import java.util.*;

// encapsulates all properties of a timeline model:
// data, display properties, etc.
// also does listening, etc.

public class TFModel {
	
	private ActDB db;
	private ActList acts;
	private ActFilter filter=new ConstFilter(true);
	private ArrayList<TFListener> listeners=new ArrayList<TFListener>();
	private Display display=new Display();

	private String[] labelGuesses={"label", "LABEL", "Label", "title", "TITLE", "Title",
			"name", "Name", "NAME"};
	private String[] startGuesses={"start", "Start", "START"};
	
	private String dbFile="[unknown source]";
	private boolean changedSinceSave;
	private boolean readOnly;
	private double minSize, maxSize;
	private Interval viewInterval;
	
	public ValueFilter getGrayFilter() {
		return display.grayFilter;
	}

	public void setGrayFilter(ValueFilter grayFilter, Object origin) {
		display.grayFilter = grayFilter;
		fireEvent(new TFEvent(TFEvent.Type.FILTER_CHANGE, origin));
	}

	public ActFilter getFilter()
	{
		return filter;
	}
	
	public Interval getViewInterval()
	{
		return viewInterval;
	}
	
	public void setViewInterval(Interval viewInterval)
	{
		this.viewInterval=viewInterval;
	}
	
	public double getMinSize() {
		return minSize;
	}

	public void setMinSize(double minSize) {
		this.minSize = minSize;
	}

	public double getMaxSize() {
		return maxSize;
	}

	public void setMaxSize(double maxSize) {
		this.maxSize = maxSize;
	}

	public String getDbFile() {
		return dbFile;
	}
	
	public boolean getReadOnly()
	{
		return readOnly;
	}

	public void setDbFile(String dbFile, boolean readOnly, Object origin) {
		this.dbFile = dbFile;
		fireEvent(new TFEvent(TFEvent.Type.SOURCE_CHANGE, origin));
	}

	public boolean isChangedSinceSave() {
		return changedSinceSave;
	}

	public void setChangedSinceSave(boolean changedSinceSave) {
		this.changedSinceSave = changedSinceSave;
	}
	
	public Display getDisplay()
	{
		return display;
	}
	
	public ActDB getDB()
	{
		return db;
	}
	
	public ActList getActs()
	{
		return acts;
	}
	
	public void addListener(TFListener t)
	{
		listeners.add(t);
	}


	public void removeListener(TFListener t)
	{
		listeners.remove(t);
	}
	
	public void noteNewDescription(Object origin)
	{
		setChangedSinceSave(true);
		fireEvent(new TFEvent(TFEvent.Type.DESCRIPTION_CHANGE, origin));
	}
	
	public void noteNewSource(Object origin)
	{
		setChangedSinceSave(true);
		fireEvent(new TFEvent(TFEvent.Type.SOURCE_CHANGE, origin));
	}
	
	public void noteRecordChange(Object origin)
	{
		setChangedSinceSave(true);
		fireEvent(new TFEvent(TFEvent.Type.ACT_CHANGE, origin));
	}
	
	public void noteAddField(Object origin)
	{
		setChangedSinceSave(true);
		fireEvent(new TFEvent(TFEvent.Type.FIELD_ADD, origin));
	}
	
	public void noteError(Object origin)
	{
		fireEvent(new TFEvent(TFEvent.Type.ERROR, origin));
	}
	
	public void noteDelete(Object origin)
	{
		setChangedSinceSave(true);
		updateActs();
		fireEvent(new TFEvent(TFEvent.Type.ACT_DELETE, origin));
	}
	
	public void noteSchemaChange(Object origin)
	{
		setChangedSinceSave(true);
		updateActs();
		fireEvent(new TFEvent(TFEvent.Type.DATABASE_CHANGE, origin)); // @TODO: make schema change? 
	}
	
	public void noteAdd(Object origin)
	{
		setChangedSinceSave(true);
		updateActs();
		fireEvent(new TFEvent(TFEvent.Type.ACT_ADD, origin));
	}
	
	public void setFilter(ActFilter filter, Object origin)
	{
		this.filter=filter;
		updateActs();
		fireEvent(new TFEvent(TFEvent.Type.FILTER_CHANGE, origin));
	}
	
	private void updateActs()
	{
		acts=db.select(filter);
	}
	
	public void setDB(ActDB db, String dbFile, boolean readOnly, Object origin)
	{
		this.db=db;
		this.dbFile=dbFile;
		this.readOnly=readOnly;
		setChangedSinceSave(false);
		this.filter=new ConstFilter(true);
		this.acts=db.all();
		initVisualEncodings();
		refreshColors();
		fireEvent(new TFEvent(TFEvent.Type.DATABASE_CHANGE, origin));
	}
	
	private void initVisualEncodings()
	{
		guessField(VirtualField.LABEL, labelGuesses, String.class);
		guessField(VirtualField.START, startGuesses, RoughTime.class);
		viewInterval=null;
	}
	
	public void refreshColors()
	{
		display.grayFilter=null;
		Field colorField=getColorField();
		if (colorField==null)
			return;
		List<String> top25=DBUtils.countValues(db, colorField).listTop(25);
		display.refreshColors(top25);
	}
	
	private void guessField(String name, String[] guesses, Class type)
	{
		Field field=db.getField(name);
		if (field==null)
		{
			for (int i=0; i<guesses.length; i++)
			{
				Field f=db.getField(guesses[i]);
				if (f!=null && f.getType()==type)
				{
					field=f;
					break;
				}
			}
			if (field==null)
			{
				List<Field> f=db.getFields(type);
				if (f.size()>0)
					field=f.get(0);
			}
			if (field!=null)
				db.setAlias(field, name);
		}
	}
	
	private void fireEvent(TFEvent e)
	{
		// clone list before going through it, because some events can cause
		// listeners to be added or removed.
		
		for (TFListener t: (List<TFListener>)listeners.clone())
			if (t!=e.origin)
				t.note(e);				
	}

	public void setFieldAlias(Field field, String alias, Object origin)
	{
		db.setAlias(field, alias);
		if (db.size()>0 && field==getColorField())
			refreshColors();
		fireEvent(new TFEvent(TFEvent.Type.VIEW_CHANGE, origin));
	}
	
	public Field getColorField()
	{
		if (db==null)
			return null;
		Field f=db.getField(VirtualField.COLOR);
		if (f!=null)
			return f;
		return db.getField(VirtualField.TRACK);
	}
	
	public void setReadOnly(boolean readOnly) {
		this.readOnly = readOnly;
	}

	public boolean isReadOnly() {
		return readOnly;
	}
}