dockbarmanager.java

定要上载质量高而定要上载质量高而定要上载质量高而定要上载质量高而定要上载质量高而

	public int getEdge(String dockableId) {
		Dockable dockable = DockingManager.getDockable(dockableId);
		return getEdge(dockable);
	}
	
	public int getEdge(Dockable dockable) {
		Dockbar dockbar = getDockbar(dockable);

		if(dockbar==leftBar)
			return MinimizationManager.LEFT;
		if(dockbar==rightBar)
			return MinimizationManager.RIGHT;
		if(dockbar==bottomBar)
			return MinimizationManager.BOTTOM;
		return MinimizationManager.UNSPECIFIED_LAYOUT_CONSTRAINT;
	}
	
	public Dockbar getDockbar(Dockable dockable) {
		if(dockable==null)
			return null;
		
		if(leftBar.contains(dockable))
			return leftBar;
		if(rightBar.contains(dockable))
			return rightBar;
		if(bottomBar.contains(dockable))
			return bottomBar;
		return null;
	}

	public Dockbar getDockbar(int edge) {
		edge = Dockbar.getValidOrientation(edge);
		switch(edge) {
			case MinimizationManager.RIGHT:
				return rightBar;
			case MinimizationManager.BOTTOM:
				return bottomBar;
			default:
				return leftBar;
		}
	}
	
	
	
	
	
	
	public void minimize(Dockable dockable) {
		if(dockable==null)
			return;
		
		int edge = DEFAULT_EDGE;
		RootWindow window = getWindow();
		if(window!=null && DockingManager.isDocked(dockable)) {
			edge = findDockbarEdge(dockable);
		}
		
		minimize(dockable, edge);
	}
	
	public void minimize(Dockable dockable, int edge) {
		if(dockable==null)
			return;
		
		if(isDockingCancelled(dockable, edge))
			return;
			
		// install the dockable
		edge = Dockbar.getValidOrientation(edge);
		install(dockable, edge);
		
		// store the dockable id
		dockables.put(dockable.getPersistentId(), new Integer(edge));
		
		// send event notification
		DockbarEvent evt = new DockbarEvent(dockable, DockbarEvent.MINIMIZE_COMPLETED, edge);
		EventManager.dispatch(evt);
	}
	
	public void reAdd(Dockable dockable) {
		// can't re-add if the dockable is null, or we already contain it
		if(dockable==null || contains(dockable))
			return;
		
		Integer edge = (Integer)dockables.get(dockable.getPersistentId());
		if(edge!=null)
			install(dockable, edge.intValue());
	}
	
	private void install(Dockable dockable, int edge) {
		Dockbar dockbar = getDockbar(edge);
		
		// undock the dockable 
		DockingManager.undock(dockable);
		// place in the dockbar
		dockbar.dock(dockable);
		// make sure they can't drag the dockable while it's in the dockbar
		dockable.getDockingProperties().setDockingEnabled(false);
		// indicate that the dockable is minimized
		DockingState info = DockingManager.getLayoutManager().getDockingState(dockable);
		info.setMinimizedConstraint(edge);
		revalidate();
	}
	
	private boolean isDockingCancelled(Dockable dockable, int edge) {
		DockbarEvent evt = new DockbarEvent(dockable, DockbarEvent.MINIMIZE_STARTED, edge);
		EventManager.dispatch(evt);
		return evt.isConsumed();
	}
	
	
	public void restore(final Dockable dockable) {
		if(dockable == null) {
			return;
		}
		
		// now restore to the current layout
		final DockingState dockingState = DockingManager.getDockingState(dockable);
		final DockingPath dockingPath = dockingState.getPath();
		boolean restoreResult = false;
		
		if (dockingPath != null) {
			restoreResult = dockingPath.restore(dockable);
		} else {
			restoreResult = RestorationManager.getInstance().restore(dockable);
		}
		
		if (restoreResult) {
			// remove the dockable from the dockbar
			remove(dockable);
			// remove the dockable reference
			dockables.remove(dockable.getPersistentId());
		}
	}
	
	public boolean remove(Dockable dockable) {
		if(dockable==null)
			return false;
		
		if(getActiveDockable()==dockable)
			setActiveDockable((Dockable)null);
		
		Dockbar dockbar = getDockbar(dockable);
		if(dockbar==null)
			return false;

		dockbar.undock(dockable);
		// restore drag capability to the dockable after removing
		// from the dockbar
		dockable.getDockingProperties().setDockingEnabled(true);
		revalidate();
		return true;
	}
	
	
	public int getActiveEdge() {
		synchronized(this) {
			return activeEdge;
		}
	}
	
	private void setActiveEdge(int edge) {
		synchronized(this) {
			activeEdge = edge;
		}
	}
	
	private Dockbar getActiveDockbar() {
		int edge = getActiveEdge();
		switch(edge) {
			case MinimizationManager.TOP:
				return bottomBar;
			case MinimizationManager.RIGHT:
				return rightBar;
			default:
				return leftBar;
		}
	}

	public String getActiveDockableId() {
		synchronized(this) {
			return activeDockableId;
		}
	}
	
	private void setActiveDockableId(String id) {
		synchronized(this) {
			activeDockableId = id;
		}
	}
	
	public Dockable getActiveDockable() {
		String dockingId = getActiveDockableId();
		Dockable dockable = DockingManager.getDockable(dockingId);
		return dockable;
	}

	
	public Cursor getResizeCursor() {
		return viewPane.getResizeCursor();
	}
	 
	public boolean isActive() {
		return getActiveDockable()!=null;
	}
	
	public void setActiveDockable(String dockableId) {
		Dockable dockable = DockingManager.getDockable(dockableId);
		setActiveDockable(dockable);
	}
		
	public void setActiveDockable(Dockable dockable) {
		// if we're not currently docked to any particular edge, then
		// we cannot activate the specified dockable.  instead, set the
		// active dockable to null
		final int newEdge = getEdge(dockable);
		if(newEdge==MinimizationManager.UNSPECIFIED_LAYOUT_CONSTRAINT)
			dockable = null;

		// check for dockable changes
		Dockable oldDockable = getActiveDockable();
		final String newDockableId = dockable==null? null: dockable.getPersistentId();
		String currentlyActiveId = getActiveDockableId();
		boolean changed = Utilities.isChanged(currentlyActiveId, newDockableId);
		// check for edge changes
		changed = changed || newEdge!=getActiveEdge();

		
		// if nothing has changed, then we're done
		if(changed) {
			viewPane.setLocked(false);
			setActiveEdge(newEdge);
			setActiveDockableId(newDockableId);
			startAnimation(oldDockable, dockable, newDockableId, newEdge);
		}
	}
	
	private void dispatchEvent(Dockable oldDockable, Dockable newDockable) {
		// dispatch to event listeners
		int evtType = DockbarEvent.EXPANDED;
		if(newDockable==null && oldDockable!=null) {
			newDockable = oldDockable;
			evtType = DockbarEvent.COLLAPSED;
		}
		
		if(newDockable!=null) {
			DockbarEvent evt = new DockbarEvent(newDockable, evtType, getActiveEdge());
			EventManager.dispatch(evt);
		}		
	}
	
	private void startAnimation(final Dockable oldDockable, final Dockable newDockable, final String newDockableId, final int newEdge) {
		Animation deactivation = oldDockable==null? null: new Animation(this, true);
		Runnable updater1 = new Runnable() {
			public void run() {
				setActiveEdge(newEdge);
				setActiveDockableId(newDockableId);
				viewPane.updateOrientation();
				viewPane.updateContents();
			}
		};
		Animation activation = newDockableId==null? null: new Animation(this, false);		
		Runnable updater2 = new Runnable() {
			public void run() {
				viewPane.setPrefSize(ViewPane.UNSPECIFIED_PREFERRED_SIZE);
				viewPane.updateOrientation();
				viewPane.updateContents();
				revalidate();
				
				// dispatch event notification
				dispatchEvent(oldDockable, newDockable);
			}
		};

		ActivationQueue queue = new ActivationQueue(this, deactivation, updater1, activation, updater2);
		queue.start();
	}
	
	public int getPreferredViewpaneSize() {
		return dockbarLayout.getDesiredViewpaneSize();
	}


	public boolean isAnimating() {
		return animating;
	}
	
	public void setAnimating(boolean animating) {
		this.animating = animating;
	}

	public boolean isDragging() {
		return dragging;
	}
	
	public void setDragging(boolean dragging) {
		this.dragging = dragging;
	}

	public ActivationListener getActivationListener() {
		return activationListener;
	}
	
	public boolean contains(Dockable dockable) {
		return getDockbar(dockable)!=null;
	}
	
	private boolean isOwner(Dockable dockable) {
		return dockable==null? false: dockables.containsKey(dockable.getPersistentId());
	}
	
	public DockbarLayout getLayout() {
	    return dockbarLayout;
	}
	
}