plugins/ui-designer/src/com/intellij/uiDesigner/designSurface/GridDropLocation.java - platform/tools/idea - Git at Google

 /*
  * Copyright 2000-2009 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.intellij.uiDesigner.designSurface;

 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.uiDesigner.core.GridConstraints;
 import com.intellij.uiDesigner.radComponents.RadComponent;
 import com.intellij.uiDesigner.radComponents.RadContainer;
 import com.intellij.uiDesigner.shared.XYLayoutManager;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.NotNull;

 import javax.swing.*;
 import java.awt.Rectangle;
 import java.awt.LayoutManager;

 /**
  * @author yole
  */
 public class GridDropLocation implements ComponentDropLocation {
   private static final Logger LOG = Logger.getInstance("#com.intellij.uiDesigner.designSurface.GridDropLocation");

   protected final RadContainer myContainer;
   protected int myRow;
   protected int myColumn;

   public GridDropLocation(@NotNull final RadContainer container, final int row, final int column) {
     myContainer = container;
     myRow = row;
     myColumn = column;
   }

   public int getRow() {
     return myRow;
   }

   public int getColumn() {
     return myColumn;
   }

   public RadContainer getContainer() {
     return myContainer;
   }

   public boolean canDrop(final ComponentDragObject dragObject) {
     // If target point doesn't belong to any cell and column then do not allow drop.
     if (myRow == -1 || myColumn == -1) {
       LOG.debug("RadContainer.canDrop=false because no cell at mouse position");
       return false;
     }

     int colSpan = 1; // allow drop any (NxM) component to cell (1x1)
     int rowSpan = 1;

     for(int i=0; i<dragObject.getComponentCount(); i++) {
       int relativeCol = dragObject.getRelativeCol(i);
       int relativeRow = dragObject.getRelativeRow(i);

       LOG.debug("checking component: relativeRow" + relativeRow + ", relativeCol" + relativeCol + ", colSpan=" + colSpan + ", rowSpan=" + rowSpan);

       if (myRow + relativeRow < 0 ||
           myColumn + relativeCol < 0 ||
           myRow + relativeRow + rowSpan > myContainer.getGridRowCount() ||
           myColumn + relativeCol + colSpan > myContainer.getGridColumnCount()) {
         LOG.debug("RadContainer.canDrop=false because range is outside grid: row=" + (myRow +relativeRow) +
                   ", col=" + (myColumn +relativeCol) + ", colSpan=" + colSpan + ", rowSpan=" + rowSpan);
         return false;
       }

       final RadComponent componentInRect = findOverlappingComponent(myRow + relativeRow, myColumn + relativeCol, rowSpan, colSpan);
       if (componentInRect != null) {
         LOG.debug("GridDropLocation.canDrop=false because found component " + componentInRect.getId() +
                   " in rect (row=" + (myRow +relativeRow) + ", col=" + (myColumn +relativeCol) +
                   ", rowSpan=" + rowSpan + ", colSpan=" + colSpan + ")");
         return false;
       }
     }
     LOG.debug("canDrop=true");
     return true;
   }

   protected RadComponent findOverlappingComponent(final int startRow, final int startCol, final int rowSpan, final int colSpan) {
     return myContainer.findComponentInRect(startRow, startCol, rowSpan, colSpan);
   }

   public void placeFeedback(FeedbackLayer feedbackLayer, ComponentDragObject dragObject) {
     Rectangle feedbackRect = null;
     if (getContainer().getLayoutManager().isGrid()) {
       feedbackRect = getGridFeedbackRect(dragObject, false, false, true);
     }
     if (feedbackRect != null) {
       final JComponent component = getContainer().getDelegee();
       StringBuilder feedbackBuilder = new StringBuilder(getContainer().getDisplayName());
       feedbackBuilder.append(" (").append(myRow + getContainer().getGridLayoutManager().getCellIndexBase());
       feedbackBuilder.append(", ").append(myColumn + getContainer().getGridLayoutManager().getCellIndexBase());
       feedbackBuilder.append(")");
       feedbackLayer.putFeedback(component, feedbackRect, feedbackBuilder.toString());
     }
     else {
       feedbackLayer.removeFeedback();
     }
   }

   @Nullable
   protected Rectangle getGridFeedbackCellRect(ComponentDragObject dragObject,
                                               boolean ignoreWidth,
                                               boolean ignoreHeight,
                                               boolean overlapping) {
     if (dragObject.getComponentCount() == 0) {
       return null;
     }

     Rectangle rc = calculateGridFeedbackCellRect(dragObject, ignoreWidth, ignoreHeight, true);

     if (rc == null) {
       return calculateGridFeedbackCellRect(dragObject, ignoreWidth, ignoreHeight, false);
     }

     if (overlapping && findOverlappingComponent(rc.y, rc.x, rc.height + 1, rc.width + 1) != null) {
      return calculateGridFeedbackCellRect(dragObject, ignoreWidth, ignoreHeight, false);
     }

     return rc;
   }

   @Nullable
   private Rectangle calculateGridFeedbackCellRect(ComponentDragObject dragObject,
                                              boolean ignoreWidth,
                                              boolean ignoreHeight,
                                              boolean spans) {
     Rectangle rc = getDragObjectDimensions(dragObject, spans);
     int w = ignoreWidth ? 1 : rc.width;
     int h = ignoreHeight ? 1 : rc.height;

     if (rc.x < 0 || rc.y < 0 || rc.y + h > getContainer().getGridRowCount() || rc.x + w > getContainer().getGridColumnCount()) {
       return null;
     }

     return new Rectangle(rc.x, rc.y, w - 1, h - 1);
   }

   protected Rectangle getDragObjectDimensions(ComponentDragObject dragObject, boolean spans) {
     int firstRow = getRow();
     int lastRow = getRow();
     int firstCol = getColumn();
     int lastCol = getColumn();
     for (int i = 0; i < dragObject.getComponentCount(); i++) {
       int relRow = dragObject.getRelativeRow(i);
       int relCol = dragObject.getRelativeCol(i);
       firstRow = Math.min(firstRow, getRow() + relRow);
       firstCol = Math.min(firstCol, getColumn() + relCol);
       lastRow = Math.max(lastRow, getRow() + relRow + (spans ? dragObject.getRowSpan(i) : 1) - 1);
       lastCol = Math.max(lastCol, getColumn() + relCol + (spans ? dragObject.getColSpan(i) : 1) - 1);
     }
     return new Rectangle(firstCol, firstRow, lastCol - firstCol + 1, lastRow - firstRow + 1);
   }

   @Nullable
   protected Rectangle getGridFeedbackRect(ComponentDragObject dragObject, boolean ignoreWidth, boolean ignoreHeight, boolean overlapping) {
     Rectangle cellRect = getGridFeedbackCellRect(dragObject, ignoreWidth, ignoreHeight, overlapping);
     if (cellRect == null) return null;
     int h = ignoreHeight ? 0 : cellRect.height;
     int w = ignoreWidth ? 0 : cellRect.width;
     return getContainer().getGridLayoutManager().getGridCellRangeRect(getContainer(), cellRect.y, cellRect.x,
                                                                       cellRect.y+h, cellRect.x+w);
   }

   public void processDrop(final GuiEditor editor,
                           final RadComponent[] components,
                           final GridConstraints[] constraintsToAdjust,
                           final ComponentDragObject dragObject) {
     dropIntoGrid(myContainer, components, myRow, myColumn, dragObject);
   }

   @Nullable
   public ComponentDropLocation getAdjacentLocation(Direction direction) {
     switch(direction) {
       case LEFT:  return new GridInsertLocation(myContainer, myRow, myColumn, GridInsertMode.ColumnBefore);
       case UP:    return new GridInsertLocation(myContainer, myRow, myColumn, GridInsertMode.RowBefore);
       case RIGHT: return new GridInsertLocation(myContainer, myRow, myColumn, GridInsertMode.ColumnAfter);
       case DOWN:  return new GridInsertLocation(myContainer, myRow, myColumn, GridInsertMode.RowAfter);
     }
     return null;
   }

   @NonNls @Override public String toString() {
     return "GridDropLocation(row=" + myRow + ",col=" + myColumn + ")";
   }

   protected static void dropIntoGrid(final RadContainer container, final RadComponent[] components, int row, int column, final ComponentDragObject dragObject) {
     assert components.length > 0;

     for(int i=0; i<components.length; i++) {
       RadComponent c = components [i];
       if (c instanceof RadContainer) {
         final LayoutManager layout = ((RadContainer)c).getLayout();
         if (layout instanceof XYLayoutManager) {
           ((XYLayoutManager)layout).setPreferredSize(c.getSize());
         }
       }

       int relativeCol = dragObject.getRelativeCol(i);
       int relativeRow = dragObject.getRelativeRow(i);
       LOG.debug("dropIntoGrid: relativeRow=" + relativeRow + ", relativeCol=" + relativeCol);
       int colSpan = dragObject.getColSpan(i);
       int rowSpan = dragObject.getRowSpan(i);

       assert row + relativeRow >= 0;
       assert column + relativeCol >= 0;

       if (rowSpan > 1 || colSpan > 1) {
         if ((row + relativeRow + rowSpan > container.getGridRowCount() && rowSpan > 1) ||
             (column + relativeCol + colSpan > container.getGridColumnCount() && colSpan > 1) ||
             container.findComponentInRect(row + relativeRow, column + relativeCol, rowSpan, colSpan) != null) {
           rowSpan = 1;
           colSpan = 1;
         }
       }

       if (!container.getGridLayoutManager().isGridDefinedByComponents()) {
         assert relativeRow + rowSpan <= container.getGridRowCount();
         assert relativeCol + colSpan <= container.getGridColumnCount();
       }

       RadComponent old = container.findComponentInRect(row + relativeRow, column + relativeCol, rowSpan, colSpan);
       if (old != null) {
         LOG.error("Drop rectangle not empty: (" + (row + relativeRow) + ", " + (column + relativeCol) + ", " + rowSpan + ", " + colSpan +
                   "), component ID=" + old.getId());
       }

       final GridConstraints constraints = c.getConstraints();
       constraints.setRow(row + relativeRow);
       constraints.setColumn(column + relativeCol);
       constraints.setRowSpan(rowSpan);
       constraints.setColSpan(colSpan);
       LOG.info("GridDropLocation.dropIntoGrid() constraints=" + constraints);
       container.addComponent(c);

       // Fill DropInfo
       c.revalidate();
     }

     container.revalidate();
     LOG.info("GridDropLocation.dropIntoGrid() done");
   }
 }
	/*
	* Copyright 2000-2009 JetBrains s.r.o.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.intellij.uiDesigner.designSurface;

	import com.intellij.openapi.diagnostic.Logger;
	import com.intellij.uiDesigner.core.GridConstraints;
	import com.intellij.uiDesigner.radComponents.RadComponent;
	import com.intellij.uiDesigner.radComponents.RadContainer;
	import com.intellij.uiDesigner.shared.XYLayoutManager;
	import org.jetbrains.annotations.NonNls;
	import org.jetbrains.annotations.Nullable;
	import org.jetbrains.annotations.NotNull;

	import javax.swing.*;
	import java.awt.Rectangle;
	import java.awt.LayoutManager;

	/**
	* @author yole
	*/
	public class GridDropLocation implements ComponentDropLocation {
	private static final Logger LOG = Logger.getInstance("#com.intellij.uiDesigner.designSurface.GridDropLocation");

	protected final RadContainer myContainer;
	protected int myRow;
	protected int myColumn;

	public GridDropLocation(@NotNull final RadContainer container, final int row, final int column) {
	myContainer = container;
	myRow = row;
	myColumn = column;
	}

	public int getRow() {
	return myRow;
	}

	public int getColumn() {
	return myColumn;
	}

	public RadContainer getContainer() {
	return myContainer;
	}

	public boolean canDrop(final ComponentDragObject dragObject) {
	// If target point doesn't belong to any cell and column then do not allow drop.
	if (myRow == -1 \|\| myColumn == -1) {
	LOG.debug("RadContainer.canDrop=false because no cell at mouse position");
	return false;
	}

	int colSpan = 1; // allow drop any (NxM) component to cell (1x1)
	int rowSpan = 1;

	for(int i=0; i<dragObject.getComponentCount(); i++) {
	int relativeCol = dragObject.getRelativeCol(i);
	int relativeRow = dragObject.getRelativeRow(i);

	LOG.debug("checking component: relativeRow" + relativeRow + ", relativeCol" + relativeCol + ", colSpan=" + colSpan + ", rowSpan=" + rowSpan);

	if (myRow + relativeRow < 0 \|\|
	myColumn + relativeCol < 0 \|\|
	myRow + relativeRow + rowSpan > myContainer.getGridRowCount() \|\|
	myColumn + relativeCol + colSpan > myContainer.getGridColumnCount()) {
	LOG.debug("RadContainer.canDrop=false because range is outside grid: row=" + (myRow +relativeRow) +
	", col=" + (myColumn +relativeCol) + ", colSpan=" + colSpan + ", rowSpan=" + rowSpan);
	return false;
	}

	final RadComponent componentInRect = findOverlappingComponent(myRow + relativeRow, myColumn + relativeCol, rowSpan, colSpan);
	if (componentInRect != null) {
	LOG.debug("GridDropLocation.canDrop=false because found component " + componentInRect.getId() +
	" in rect (row=" + (myRow +relativeRow) + ", col=" + (myColumn +relativeCol) +
	", rowSpan=" + rowSpan + ", colSpan=" + colSpan + ")");
	return false;
	}
	}
	LOG.debug("canDrop=true");
	return true;
	}

	protected RadComponent findOverlappingComponent(final int startRow, final int startCol, final int rowSpan, final int colSpan) {
	return myContainer.findComponentInRect(startRow, startCol, rowSpan, colSpan);
	}

	public void placeFeedback(FeedbackLayer feedbackLayer, ComponentDragObject dragObject) {
	Rectangle feedbackRect = null;
	if (getContainer().getLayoutManager().isGrid()) {
	feedbackRect = getGridFeedbackRect(dragObject, false, false, true);
	}
	if (feedbackRect != null) {
	final JComponent component = getContainer().getDelegee();
	StringBuilder feedbackBuilder = new StringBuilder(getContainer().getDisplayName());
	feedbackBuilder.append(" (").append(myRow + getContainer().getGridLayoutManager().getCellIndexBase());
	feedbackBuilder.append(", ").append(myColumn + getContainer().getGridLayoutManager().getCellIndexBase());
	feedbackBuilder.append(")");
	feedbackLayer.putFeedback(component, feedbackRect, feedbackBuilder.toString());
	}
	else {
	feedbackLayer.removeFeedback();
	}
	}

	@Nullable
	protected Rectangle getGridFeedbackCellRect(ComponentDragObject dragObject,
	boolean ignoreWidth,
	boolean ignoreHeight,
	boolean overlapping) {
	if (dragObject.getComponentCount() == 0) {
	return null;
	}

	Rectangle rc = calculateGridFeedbackCellRect(dragObject, ignoreWidth, ignoreHeight, true);

	if (rc == null) {
	return calculateGridFeedbackCellRect(dragObject, ignoreWidth, ignoreHeight, false);
	}

	if (overlapping && findOverlappingComponent(rc.y, rc.x, rc.height + 1, rc.width + 1) != null) {
	return calculateGridFeedbackCellRect(dragObject, ignoreWidth, ignoreHeight, false);
	}

	return rc;
	}

	@Nullable
	private Rectangle calculateGridFeedbackCellRect(ComponentDragObject dragObject,
	boolean ignoreWidth,
	boolean ignoreHeight,
	boolean spans) {
	Rectangle rc = getDragObjectDimensions(dragObject, spans);
	int w = ignoreWidth ? 1 : rc.width;
	int h = ignoreHeight ? 1 : rc.height;

	if (rc.x < 0 \|\| rc.y < 0 \|\| rc.y + h > getContainer().getGridRowCount() \|\| rc.x + w > getContainer().getGridColumnCount()) {
	return null;
	}

	return new Rectangle(rc.x, rc.y, w - 1, h - 1);
	}

	protected Rectangle getDragObjectDimensions(ComponentDragObject dragObject, boolean spans) {
	int firstRow = getRow();
	int lastRow = getRow();
	int firstCol = getColumn();
	int lastCol = getColumn();
	for (int i = 0; i < dragObject.getComponentCount(); i++) {
	int relRow = dragObject.getRelativeRow(i);
	int relCol = dragObject.getRelativeCol(i);
	firstRow = Math.min(firstRow, getRow() + relRow);
	firstCol = Math.min(firstCol, getColumn() + relCol);
	lastRow = Math.max(lastRow, getRow() + relRow + (spans ? dragObject.getRowSpan(i) : 1) - 1);
	lastCol = Math.max(lastCol, getColumn() + relCol + (spans ? dragObject.getColSpan(i) : 1) - 1);
	}
	return new Rectangle(firstCol, firstRow, lastCol - firstCol + 1, lastRow - firstRow + 1);
	}

	@Nullable
	protected Rectangle getGridFeedbackRect(ComponentDragObject dragObject, boolean ignoreWidth, boolean ignoreHeight, boolean overlapping) {
	Rectangle cellRect = getGridFeedbackCellRect(dragObject, ignoreWidth, ignoreHeight, overlapping);
	if (cellRect == null) return null;
	int h = ignoreHeight ? 0 : cellRect.height;
	int w = ignoreWidth ? 0 : cellRect.width;
	return getContainer().getGridLayoutManager().getGridCellRangeRect(getContainer(), cellRect.y, cellRect.x,
	cellRect.y+h, cellRect.x+w);
	}

	public void processDrop(final GuiEditor editor,
	final RadComponent[] components,
	final GridConstraints[] constraintsToAdjust,
	final ComponentDragObject dragObject) {
	dropIntoGrid(myContainer, components, myRow, myColumn, dragObject);
	}

	@Nullable
	public ComponentDropLocation getAdjacentLocation(Direction direction) {
	switch(direction) {
	case LEFT: return new GridInsertLocation(myContainer, myRow, myColumn, GridInsertMode.ColumnBefore);
	case UP: return new GridInsertLocation(myContainer, myRow, myColumn, GridInsertMode.RowBefore);
	case RIGHT: return new GridInsertLocation(myContainer, myRow, myColumn, GridInsertMode.ColumnAfter);
	case DOWN: return new GridInsertLocation(myContainer, myRow, myColumn, GridInsertMode.RowAfter);
	}
	return null;
	}

	@NonNls @Override public String toString() {
	return "GridDropLocation(row=" + myRow + ",col=" + myColumn + ")";
	}

	protected static void dropIntoGrid(final RadContainer container, final RadComponent[] components, int row, int column, final ComponentDragObject dragObject) {
	assert components.length > 0;

	for(int i=0; i<components.length; i++) {
	RadComponent c = components [i];
	if (c instanceof RadContainer) {
	final LayoutManager layout = ((RadContainer)c).getLayout();
	if (layout instanceof XYLayoutManager) {
	((XYLayoutManager)layout).setPreferredSize(c.getSize());
	}
	}

	int relativeCol = dragObject.getRelativeCol(i);
	int relativeRow = dragObject.getRelativeRow(i);
	LOG.debug("dropIntoGrid: relativeRow=" + relativeRow + ", relativeCol=" + relativeCol);
	int colSpan = dragObject.getColSpan(i);
	int rowSpan = dragObject.getRowSpan(i);

	assert row + relativeRow >= 0;
	assert column + relativeCol >= 0;

	if (rowSpan > 1 \|\| colSpan > 1) {
	if ((row + relativeRow + rowSpan > container.getGridRowCount() && rowSpan > 1) \|\|
	(column + relativeCol + colSpan > container.getGridColumnCount() && colSpan > 1) \|\|
	container.findComponentInRect(row + relativeRow, column + relativeCol, rowSpan, colSpan) != null) {
	rowSpan = 1;
	colSpan = 1;
	}
	}

	if (!container.getGridLayoutManager().isGridDefinedByComponents()) {
	assert relativeRow + rowSpan <= container.getGridRowCount();
	assert relativeCol + colSpan <= container.getGridColumnCount();
	}

	RadComponent old = container.findComponentInRect(row + relativeRow, column + relativeCol, rowSpan, colSpan);
	if (old != null) {
	LOG.error("Drop rectangle not empty: (" + (row + relativeRow) + ", " + (column + relativeCol) + ", " + rowSpan + ", " + colSpan +
	"), component ID=" + old.getId());
	}

	final GridConstraints constraints = c.getConstraints();
	constraints.setRow(row + relativeRow);
	constraints.setColumn(column + relativeCol);
	constraints.setRowSpan(rowSpan);
	constraints.setColSpan(colSpan);
	LOG.info("GridDropLocation.dropIntoGrid() constraints=" + constraints);
	container.addComponent(c);

	// Fill DropInfo
	c.revalidate();
	}

	container.revalidate();
	LOG.info("GridDropLocation.dropIntoGrid() done");
	}
	}