view src/samer/core_/util/shell/ViewableManager.java @ 0:bf79fb79ee13

Initial Mercurial check in.

/*
 *	AppShell.java	
 *
 *	Copyright (c) 2000, Samer Abdallah, King's College London.
 *	All rights reserved.
 *
 *	This software is provided AS iS and WITHOUT ANY WARRANTY; 
 *	without even the implied warranty of MERCHANTABILITY or 
 *	FITNESS FOR A PARTICULAR PURPOSE.
 */

package samer.core.util.shell;
import  samer.core.util.*;
import  samer.core.types.*;
import  samer.core.*;

import java.awt.*;
import java.awt.event.*;
import java.util.*;

public class ViewableManager
{
	private		Vector	viewables = new Vector();
	protected	Vector	exposedViewers = new Vector();

	public ViewableManager() {
		Shell.put("ViewableManager", this);
	}
	protected static class VblEntry
	{
		public Viewable viewable;
		public boolean	exposed=false;

		public VblEntry(Viewable v) { viewable=v; }
	}

	protected static class VwrEntry
	{
		public Viewer	viewer;
		public VblEntry	entry;
		public VwrEntry(VblEntry ve, Viewer vwr) { entry=ve; viewer=vwr; }
	}

	public void listViewables() {
		Shell.print("registered viewables:");
		Iterator i=viewables.iterator();
		while(i.hasNext()) {
			Shell.print(((VblEntry)(i.next())).viewable.getNode().fullName()	);
		}
	}

	public void registerViewable(Viewable v)
	{
		if (findEntry(v)==null)	{
			// not already in list, so add
			VblEntry vbl=new VblEntry(v);
			viewables.addElement(vbl);

			// if viewables currently exposed, then expose this one
			if (vc!=null) {
				final Viewer vwr=v.getViewer();
				if (vwr!=null) {
					// add via singleton enumeration
					vc.add( new Iterator() {
						boolean more=true;
						public boolean hasNext() { return more; }
						public Object next() { more=false; return vwr.getComponent(); }
						public void remove() {}
					} );
				}
			}
		}
	}

	public void deregisterViewable(Viewable v)
	{
		VblEntry ve=findEntry(v);
		if (ve!=null) viewables.removeElement(ve);
		// ought to remove from vc but can't be bothered
	}

	public Viewable getViewable(String name)
	{
		Iterator i=viewables.iterator();
		Viewable		best=null;
		int			score=0;

		while (i.hasNext()) {
			VblEntry ve=(VblEntry)i.next();
			String fullname=ve.viewable.getNode().fullName();
			if (name.endsWith(fullname)) {
				int ss=fullname.length();
				if (ss>score) {
					best=ve.viewable;
					score=ss;
				}
			}
		}
		return best;
	}

	private VblEntry findEntry(Viewable v)
	{
		Iterator i=viewables.iterator();
		while (i.hasNext()) {
			VblEntry ve=(VblEntry)i.next();
			if (ve.viewable==v) return ve;
		}
		return null;
	}


	public interface ViewerContainer {
		// add(Viewer viewer);
		void add(Iterator components);
		void removeAll(); // redundant?
	}

	private ViewerContainer vc=null;

	public Iterator getViewables() {
		return new Iterator() {
			Iterator vbls=viewables.iterator();
			VblEntry	vbl;

			public boolean hasNext() { return vbls.hasNext(); }
			public Object next() 	{ return ((VblEntry)vbls.next()).viewable; }
			public void remove() {}
		};
	}

	/**
		Register the supplied ViewerContainer and fill with
		all currently registered exposable Viewables.
		Any subsequently registered Viewables will be exposed
		in this ViewerContainer.
	  */

	public void exposeViewables(ViewerContainer c)
	{
		Iterator viewers = new Iterator() {
			Iterator vbls=viewables.iterator();
			VblEntry	vbl;
			Viewer		nextvwr;

			{ prepareNext(); }

			public void remove() {}
			public boolean hasNext() { return nextvwr!=null; }
			public Object next()
			{
				Component ret=nextvwr.getComponent();
				exposedViewers.addElement(new VwrEntry(vbl,nextvwr));
				vbl.exposed=true;
				prepareNext();

				return ret;
			}

			private void prepareNext()
			{
				while (vbls.hasNext()) {
					vbl=(VblEntry)vbls.next();
					if (!vbl.exposed) {
						nextvwr=vbl.viewable.getViewer();
						if (nextvwr!=null) return;
					}
				}
				nextvwr=null;
			}
		};
		c.add(viewers);
		vc=c;
	}

	/**
		Empties and deregisters the currently registered ViewerContainer.
		All Viewers are detached, and removed, so they should be up
		for garbage collection after this. The ViewableManager also
		forgets about the ViewerContainer so that it can be disposed
		of and subsequently registered Viewable will not be shown.
	  */

	public void releaseViewerContainer()
	{
		if (vc==null) return;

		Shell.trace("releasing viewer container");
		Iterator i=exposedViewers.iterator();
		while (i.hasNext()) {
			VwrEntry entry = (VwrEntry)i.next();
			entry.viewer.detach();
			entry.entry.exposed=false;
		}
		vc.removeAll();
		vc=null;

		return;
	}

	public boolean hasViewerContainer() { return vc!=null; }
}