mapview.java

思维导图(Mind Mapping)以放射性思考(Radiant Thinking)为基础的收放自如方式

/*FreeMind - A Program for creating and viewing Mindmaps
 *Copyright (C) 2000-2001  Joerg Mueller <[e-mail]>
 *See COPYING for Details
 *
 *This program is free software; you can redistribute it and/or
 *modify it under the terms of the GNU General Public License
 *as published by the Free Software Foundation; either version 2
 *of the License, or (at your option) any later version.
 *
 *This program is distributed in the hope that it will be useful,
 *but WITHOUT ANY WARRANTY; without even the implied warranty of
 *MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *GNU General Public License for more details.
 *
 *You should have received a copy of the GNU General Public License
 *along with this program; if not, write to the Free Software
 *Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
/*$Id: MapView.java,v 1.30.16.14 2005/08/21 14:47:49 christianfoltin Exp $*/
 
package freemind.view.mindmapview;

import java.awt.Color;
import java.awt.Component;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.KeyboardFocusManager;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.dnd.DragGestureListener;
import java.awt.dnd.DropTargetListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.event.KeyEvent;
import java.awt.print.PageFormat;
import java.awt.print.Printable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Map;
import java.util.TreeMap;
import java.util.Vector;

import javax.swing.JPanel;
import javax.swing.JViewport;
import javax.swing.event.TreeModelEvent;
import javax.swing.event.TreeModelListener;

import freemind.controller.Controller;
import freemind.controller.NodeKeyListener;
import freemind.controller.NodeMotionListener;
import freemind.controller.NodeMouseMotionListener;
import freemind.extensions.PermanentNodeHook;
import freemind.main.Tools;
import freemind.modes.MindMap;
import freemind.modes.MindMapArrowLink;
import freemind.modes.MindMapLink;
import freemind.modes.MindMapNode;


/**
 * This class represents the view of a whole MindMap
 * (in analogy to class JTree).
 */
public class MapView extends JPanel implements Printable {

	private class Selected {
		private Vector mySelected = new Vector();
		public Selected() {};
		public void clear() {
			if(size() >0 ) {
				removeSelectionForHooks(get(0)); 
			}
			mySelected.clear();
			logger.finest("Cleared selected.");
		}
		public int size() { return mySelected.size();
		}
		public void remove(NodeView node) { 
			if(mySelected.indexOf(node)==0) {
				removeSelectionForHooks(node);
			}
			mySelected.remove(node); 
			logger.finest("Removed selected "+node);
		}
		public void add(NodeView node) {
			if(size() >0 ) {
				removeSelectionForHooks(get(0)); 
			}
			mySelected.add(0, node);
			addSelectionForHooks(node); 
			logger.finest("Added selected "+node + "\nAll="+mySelected);
		}
		private void removeSelectionForHooks(NodeView node) {
		    if(node.getModel() == null) 
		        return;
			// deselect the old node:
			for(Iterator i= node.getModel().getActivatedHooks().iterator(); i.hasNext();){
				PermanentNodeHook hook = (PermanentNodeHook) i.next();
				hook.onLooseFocusHook();
			}
		}
		private void addSelectionForHooks(NodeView node) {
			// select the new node:
			for(Iterator i= node.getModel().getActivatedHooks().iterator(); i.hasNext();){
				PermanentNodeHook hook = (PermanentNodeHook) i.next();
				hook.onReceiveFocusHook();
			}
		}
		public NodeView get(int i) { return (NodeView) mySelected.get(i); 
		}
		public boolean contains(NodeView node) { return mySelected.contains(node);
		}
		/**
		 * @param newSelected
		 */
		public void moveToFirst(NodeView newSelected) {
			if(contains(newSelected)) {
				int pos = mySelected.indexOf(newSelected);
				if( pos > 0 ){ // move
					if(size() >0 ) {
						removeSelectionForHooks(get(0)); 
					}
					mySelected.remove(newSelected);
					mySelected.add(0, newSelected);
				}
			} else {
				add(newSelected);
			}
			addSelectionForHooks(newSelected);
			logger.finest("MovedToFront selected "+newSelected + "\nAll="+mySelected);
		}
	}

	//	Logging: 
	private static java.util.logging.Logger logger;

	private class DelayedScroller extends ComponentAdapter{
		/**
		 * the only one interface method.
		 * @param map
		 * @param node
		 * @param extraWidth
		 */
		public void componentMoved(ComponentEvent e){
			if (m_map != null) { // fc, 22.2.2005: bug fix.
                m_map.scrollNodeToVisible(m_node, m_extraWidth);
            }
			m_map = null;
			m_node = null;		
		}		
	
		public void scrollNodeToVisible(MapView map, NodeView node, int extraWidth){
			deactivate();
			m_map = map;
			m_node = node;
			m_extraWidth = extraWidth;
			node.addComponentListener(this);
		}
		
		public void deactivate(){
			if (m_node != null) 
				m_node.removeComponentListener(this);
		}
		MapView m_map = null;
		NodeView m_node = null;
		int m_extraWidth = 0;
	}

	private DelayedScroller m_delayedScroller = new DelayedScroller();

    private MindMap model;
    private NodeView rootView;
    private Selected selected = new Selected();
    private Controller controller;
    private float zoom=1F;
    private boolean disableMoveCursor = true;
    private int siblingMaxLevel;
    private boolean isPrinting = false; // use for remove selection from print
    private NodeView shiftSelectionOrigin = null;
    private int maxNodeWidth = 0;
    private Color background = null;
	private Rectangle boundingRectangle = null;
	private boolean fitToPage = true;
	private boolean isPreparedForPrinting = false;
        
    /** Used to identify a right click onto a link curve.*/
    private Vector/* of ArrowLinkViews*/ ArrowLinkViews;
    //
    // Constructors
    //

    public MapView( MindMap model, Controller controller ) {
        super();
		
        this.model = model;
        this.controller = controller;
		if(logger == null)
			logger = controller.getFrame().getLogger(this.getClass().getName());

        this.setAutoscrolls(true); //For some reason this doesn't work.

        getModel().addTreeModelListener( new MapModelHandler() );

        this.setLayout( new MindMapLayout( this ) );

        initRoot();

        setBackground(getModel().getBackgroundColor());

        addMouseListener( controller.getMapMouseMotionListener() );
        addMouseMotionListener( controller.getMapMouseMotionListener() );
        addMouseWheelListener( controller.getMapMouseWheelListener() );

		// fc, 20.6.2004: to enable tab for insert.
		setFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, Collections.EMPTY_SET);
		setFocusTraversalKeys(KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, Collections.EMPTY_SET);
		setFocusTraversalKeys(KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, Collections.EMPTY_SET);
		// end change.

        // like in excel - write a letter means edit (PN)
        // on the other hand it doesn't allow key navigation (sdfe)
        disableMoveCursor = Tools.safeEquals(
                                             controller.getProperty("disable_cursor_move_paper"),"true");
    }

    public void initRoot() {
        rootView = NodeView.newNodeView( (MindMapNode)getModel().getRoot(), this );
        rootView.insert();
        getMindMapLayout().updateTreeHeightsAndRelativeYOfWholeMap();
        revalidate();
    }
    
        public int getMaxNodeWidth() {
        if (maxNodeWidth == 0) {
            try {
                maxNodeWidth = Integer.parseInt(controller.getProperty("max_node_width")); }
            catch (NumberFormatException e) {
                maxNodeWidth = Integer.parseInt(controller.getProperty("el__max_default_window_width")); }}
        return maxNodeWidth; }

    //
    // Navigation
    //

    /**
     * Problem: Before  scrollRectToVisible is called, the node has the location (0,0), ie. the location first gets
     * calculated after the scrollpane is actually scrolled. Thus, as a workaround, I simply call scrollRectToVisible
     * twice, the first time the location of the node is calculated, the second time the scrollPane is actually
     * scrolled.
     */
    public void centerNode( NodeView node ) {
        JViewport viewPort = (JViewport)getParent();
        Dimension d = viewPort.getExtentSize();
		if (! isValid()){
			final Rectangle r0 = new Rectangle(0,0,d.width, d.height);
			scrollRectToVisible(r0);
		}
		Rectangle rect = new Rectangle(node.getLocation().x + (node.getPreferredSize().width/2) - (d.width/2),
                                          node.getLocation().y + (node.getPreferredSize().height/2) - (d.height/2),
			d.width, d.height);
			
		// One call of scrollRectToVisible suffices 
		// after patching the FreeMind.java
		// and the FreeMindApplet
		scrollRectToVisible(rect);		
    }

    // scroll with extension (PN 6.2)
    public void scrollNodeToVisible( NodeView node ) {
			scrollNodeToVisible( node, 0);
    }

    // scroll with extension (PN)
    // e.g. the input field is bigger than the node view => scroll in order to
    //      fit the input field into the screen
    public void scrollNodeToVisible( NodeView node, int extraWidth) {
        //see centerNode()
		if (! node.isValid()){
			m_delayedScroller.scrollNodeToVisible(this, node, extraWidth);
			return;
		}
		m_delayedScroller.deactivate();
        final int HORIZ_SPACE  = 10;
        final int HORIZ_SPACE2 = 20;
        final int VERT_SPACE   = 5; 
        final int VERT_SPACE2  = 10;

        // get left/right dimension
        int x  =  node.getX() ;
        int width = node.getWidth();
        if (extraWidth < 0) { // extra left width
            x += extraWidth;
			width -= extraWidth; 
        }
        else {                // extra right width
            width += extraWidth; 
        }
		// get top/bottom dimension
		int y  =  node.getY();
		int height = node.getHeight();
        // adjusting container size is needed no more
        //this is buggy!