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

Initial Mercurial check in.

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/samer/core_/util/shell/ViewableManager.java	Tue Jan 17 17:50:20 2012 +0000
@@ -0,0 +1,203 @@
+/*
+ *	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; }
+}
+