SVGTreePanelDropTarget.java

/**********************************************
 * Copyright (C) 2011 Lukas Laag
 * This file is part of svgreal.
 * 
 * svgreal 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 3 of the License, or
 * (at your option) any later version.
 * 
 * svgreal 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 svgreal.  If not, see http://www.gnu.org/licenses/
 **********************************************/
package org.vectomatic.svg.edit.client.gxt.widget;

import org.vectomatic.svg.edit.client.SVGWindow;
import org.vectomatic.svg.edit.client.command.CommandFactories;
import org.vectomatic.svg.edit.client.command.DndCommandFactory;
import org.vectomatic.svg.edit.client.command.DndCommandFactory.DropGesture;
import org.vectomatic.svg.edit.client.engine.SVGModel;
import org.vectomatic.svg.edit.client.engine.SVGProcessor;
import org.vectomatic.svg.edit.client.model.svg.SVGElementModel;

import com.extjs.gxt.ui.client.core.El;
import com.extjs.gxt.ui.client.dnd.DropTarget;
import com.extjs.gxt.ui.client.dnd.Insert;
import com.extjs.gxt.ui.client.dnd.ScrollSupport;
import com.extjs.gxt.ui.client.event.DNDEvent;
import com.extjs.gxt.ui.client.util.Rectangle;
import com.extjs.gxt.ui.client.widget.treepanel.TreePanel.TreeNode;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.Element;
import com.google.gwt.user.client.Timer;

/**
 * Drop target for SVGWindow
 * @author laaglu
 */
public class SVGTreePanelDropTarget extends DropTarget {
	protected DndCommandFactory dndCommandFactory;
	protected TreePanelExt<SVGElementModel> tree;
	protected TreeNode activeItem, appendItem;
	protected DropGesture dropGesture;

	private boolean restoreTrackMouse;
	private ScrollSupport scrollSupport;

	protected SVGModel svgModel;
	public SVGTreePanelDropTarget(SVGWindow window) {
		super(window.getTree());
		this.tree = window.getTree();
		svgModel = window.getSvgModel();
		dndCommandFactory = CommandFactories.getDndCommandFactory();
	}

	protected void clearStyles(DNDEvent event) {
		Insert.get().hide();
		event.getStatus().setStatus(false);
		if (activeItem != null) {
			tree.getView().onDropChange(activeItem, false);
		}
	}

	@Override
	protected void onDragDrop(DNDEvent event) {
		GWT.log("SVGTreePanelDropTarget.onDragDrop");
		super.onDragDrop(event);
		if (event.getData() == null)
			return;

		tree.getView().onDropChange(activeItem, false);
		dndCommandFactory.processDragAndDrop(dropGesture);
		tree.setTrackMouseOver(restoreTrackMouse);
		activeItem = null;
		appendItem = null;
		scrollSupport.stop();
	}

	@Override
	protected void onDragEnter(DNDEvent e) {
		super.onDragEnter(e);
		e.getStatus().setStatus(false);
		restoreTrackMouse = tree.isTrackMouseOver();
		tree.setTrackMouseOver(false);

		if (scrollSupport == null) {
			scrollSupport = new ScrollSupport(tree.el());
		}
		scrollSupport.start();
	}

	@Override
	protected void onDragFail(DNDEvent event) {
		super.onDragFail(event);
		scrollSupport.stop();
	}

	@Override
	protected void onDragLeave(DNDEvent e) {
		super.onDragLeave(e);
		if (activeItem != null) {
			tree.getView().onDropChange(activeItem, false);
			activeItem = null;
		}
		tree.setTrackMouseOver(restoreTrackMouse);
		scrollSupport.stop();
	}

	@Override
	protected void onDragMove(DNDEvent event) {
		event.setCancelled(false);
	}

	@Override
	protected void showFeedback(DNDEvent event) {
		// GWT.log("showFeedback");
		// Determine the tree node over which the cursor is hovering, if any
		final TreeNode overItem = tree.findNode(event.getTarget());
		if (!dndCommandFactory.isValidDropTarget(getModel(overItem))) {
			// Not over a tree item
			clearStyles(event);
			return;
		}
		handleInsert(event, overItem);
	}
	

	protected void handleInsert(DNDEvent event, final TreeNode item) {
		// Determine the position of the cursor with regards to the drop item
		// to find out if the drag source should be inserted before or after
		// the drop item
		int height = item.getElement().getOffsetHeight();
		int mid = height / 2;
		int top = item.getElement().getAbsoluteTop();
		mid += top;
		int y = event.getClientY();
		boolean before = y < mid;

		if ((!item.isLeaf() || SVGProcessor.isGroupElement(getModel(item).getElement()))
				&& ((before && y > top + 4) || (!before && y < top + height - 4))) {
			handleAppend(event, item);
			return;
		}
		dropGesture = before ? DropGesture.BeforeNode : DropGesture.AfterNode;

		// clear any active append item
		if (activeItem != null) {
			tree.getView().onDropChange(activeItem, false);
		}
		appendItem = null;
		activeItem = item;

		int idx = -1;
		if (activeItem.getParent() == null) {
			idx = tree.getStore().getRootItems().indexOf(activeItem);
		} else {
			idx = activeItem.getParent().indexOf(item);
		}
		
		event.getStatus().setStatus(true);

		showInsert(event, item.getElement(), before);
	}
	
	protected void handleAppend(DNDEvent event, final TreeNode item) {
		dropGesture = DropGesture.OnNode;
		Insert.get().hide();
		event.getStatus().setStatus(true);
		// clear any active append item
		if (activeItem != null) {
			tree.getView().onDropChange(activeItem, false);
		}

		if (item != null && item != appendItem && !item.isExpanded()) {
			Timer t = new Timer() {
				@Override
				public void run() {
					if (item == appendItem) {

						item.setExpanded(true);
					} else {
					}
				}
			};
			// auto-expand delay
			t.schedule(800);
		}
		appendItem = item;
		activeItem = item;
		if (activeItem != null) {
			tree.getView().onDropChange(activeItem, true);
		}
	}



	private void showInsert(DNDEvent event, Element elem, boolean before) {
		Insert insert = Insert.get();
		insert.show(elem);
		Rectangle rect = El.fly(elem).getBounds();
		int y = before ? rect.y - 2 : (rect.y + rect.height - 4);
		insert.setBounds(rect.x, y, rect.width, 6);
	}
	
	
	public SVGElementModel getActiveItem() {
		return getModel(activeItem);
	}
	public SVGElementModel getModel(TreeNode treeNode) {
		if (treeNode != null) {
			return (SVGElementModel)treeNode.getModel();
		}
		return null;
	}
	public SVGModel getSvgModel() {
		return svgModel;
	}
}