| /* |
| * 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.FormEditingUtil; |
| import com.intellij.uiDesigner.GridChangeUtil; |
| import com.intellij.uiDesigner.UIDesignerBundle; |
| import com.intellij.uiDesigner.core.GridConstraints; |
| import com.intellij.uiDesigner.radComponents.RadAbstractGridLayoutManager; |
| import com.intellij.uiDesigner.radComponents.RadComponent; |
| import com.intellij.uiDesigner.radComponents.RadContainer; |
| import org.jetbrains.annotations.NonNls; |
| import org.jetbrains.annotations.NotNull; |
| import org.jetbrains.annotations.Nullable; |
| |
| import java.awt.*; |
| |
| /** |
| * @author yole |
| */ |
| public class GridInsertLocation extends GridDropLocation { |
| private static final Logger LOG = Logger.getInstance("#com.intellij.uiDesigner.designSurface.GridInsertLocation"); |
| |
| public static final int INSERT_ARROW_SIZE = 3; |
| public static final int INSERT_RECT_MIN_SIZE = 15; // should be larger than the insets increase on Shift |
| |
| private GridInsertMode myMode; |
| |
| private boolean mySpanInsertMode; |
| |
| public GridInsertLocation(@NotNull final RadContainer container, |
| final int row, |
| final int column, |
| final GridInsertMode mode) { |
| super(container, row, column); |
| myMode = mode; |
| assert container.getLayoutManager().isGrid(); |
| } |
| |
| public GridInsertLocation normalize() { |
| final RadAbstractGridLayoutManager gridManager = myContainer.getGridLayoutManager(); |
| |
| if (myMode == GridInsertMode.RowBefore && myRow > 0) { |
| myMode = GridInsertMode.RowAfter; |
| myRow--; |
| } |
| else if (myMode == GridInsertMode.ColumnBefore && myColumn > 0) { |
| myMode = GridInsertMode.ColumnAfter; |
| myColumn--; |
| } |
| |
| if (myMode == GridInsertMode.RowAfter && gridManager.isGapCell(myContainer, true, myRow)) { |
| myRow--; |
| } |
| else if (myMode == GridInsertMode.RowBefore && gridManager.isGapCell(myContainer, true, myRow)) { |
| myRow++; |
| } |
| else if (myMode == GridInsertMode.ColumnAfter && gridManager.isGapCell(myContainer, false, myColumn)) { |
| myColumn--; |
| } |
| else if (myMode == GridInsertMode.ColumnBefore && gridManager.isGapCell(myContainer, false, myColumn)) { |
| myColumn++; |
| } |
| |
| return this; |
| } |
| |
| public GridInsertMode getMode() { |
| return myMode; |
| } |
| |
| public void setSpanInsertMode(boolean spanInsertMode) { |
| mySpanInsertMode = spanInsertMode; |
| } |
| |
| private boolean isColumnInsert() { |
| return myMode == GridInsertMode.ColumnAfter || myMode == GridInsertMode.ColumnBefore; |
| } |
| |
| private boolean isRowInsert() { |
| return myMode == GridInsertMode.RowAfter || myMode == GridInsertMode.RowBefore; |
| } |
| |
| public boolean isInsert() { |
| return isColumnInsert() || isRowInsert(); |
| } |
| |
| private int getInsertCell() { |
| return isRowInsert() ? myRow : myColumn; |
| } |
| |
| private int getOppositeCell() { |
| return isRowInsert() ? myColumn : myRow; |
| } |
| |
| private boolean isInsertAfter() { |
| return myMode == GridInsertMode.ColumnAfter || myMode == GridInsertMode.RowAfter; |
| } |
| |
| @Override public boolean canDrop(ComponentDragObject dragObject) { |
| Rectangle rc = getDragObjectDimensions(dragObject, true); |
| int size = isRowInsert() ? rc.width : rc.height; |
| if (isInsertInsideComponent(size)) { |
| LOG.debug("GridInsertLocation.canDrop()=false because insert inside component"); |
| return false; |
| } |
| |
| // TODO[yole]: any other conditions to check here? |
| LOG.debug("GridInsertLocation.canDrop()=true"); |
| return true; |
| } |
| |
| private static boolean isSameCell(final ComponentDragObject dragObject, boolean isRow) { |
| if (dragObject.getComponentCount() == 0) { |
| return true; |
| } |
| int cell = isRow ? dragObject.getRelativeRow(0) : dragObject.getRelativeCol(0); |
| for(int i=1; i<dragObject.getComponentCount(); i++) { |
| int cell2 = isRow ? dragObject.getRelativeRow(i) : dragObject.getRelativeCol(i); |
| if (cell2 != cell) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| private boolean isInsertInsideComponent(final int size) { |
| int endColumn = getInsertCell(); |
| if (isInsertAfter()) endColumn++; |
| int row = getOppositeCell(); |
| |
| for(int r=row; r<row+size; r++) { |
| for(int col = 0; col<endColumn; col++) { |
| RadComponent component; |
| if (isColumnInsert()) { |
| component = RadAbstractGridLayoutManager.getComponentAtGrid(getContainer(), r, col); |
| } |
| else { |
| component = RadAbstractGridLayoutManager.getComponentAtGrid(getContainer(), col, r); |
| } |
| |
| if (component != null) { |
| GridConstraints constraints = component.getConstraints(); |
| final boolean isRow = !isColumnInsert(); |
| if (constraints.getCell(isRow) + constraints.getSpan(isRow) > endColumn && |
| constraints.getSpan(isRow) > 1) { |
| return true; |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| @Override public void placeFeedback(FeedbackLayer feedbackLayer, ComponentDragObject dragObject) { |
| final int insertCol = getColumn(); |
| final int insertRow = getRow(); |
| |
| Rectangle feedbackRect = getGridFeedbackRect(dragObject, isColumnInsert(), isRowInsert(), false); |
| if (feedbackRect == null) { |
| feedbackLayer.removeFeedback(); |
| return; |
| } |
| Rectangle cellRect = getGridFeedbackCellRect(dragObject, isColumnInsert(), isRowInsert(), false); |
| assert cellRect != null; |
| |
| final RadAbstractGridLayoutManager layoutManager = getContainer().getGridLayoutManager(); |
| int[] vGridLines = layoutManager.getVerticalGridLines(getContainer()); |
| int[] hGridLines = layoutManager.getHorizontalGridLines(getContainer()); |
| |
| FeedbackPainter painter = (myMode == GridInsertMode.ColumnBefore || |
| myMode == GridInsertMode.ColumnAfter) |
| ? VertInsertFeedbackPainter.INSTANCE |
| : HorzInsertFeedbackPainter.INSTANCE; |
| Rectangle rc; |
| |
| Rectangle rcFeedback = null; |
| if (dragObject.getComponentCount() == 1) { |
| int lastColIndex = insertCol + dragObject.getColSpan(0); |
| if (lastColIndex > vGridLines.length - 1) { |
| lastColIndex = insertCol + 1; |
| } |
| |
| int lastRowIndex = insertRow + dragObject.getRowSpan(0); |
| if (lastRowIndex > hGridLines.length - 1) { |
| lastRowIndex = insertRow + 1; |
| } |
| |
| int cellWidth = vGridLines [lastColIndex] - vGridLines [insertCol]; |
| int cellHeight = hGridLines [lastRowIndex] - hGridLines [insertRow]; |
| RadComponent component = layoutManager.getComponentAtGrid(getContainer(), insertRow, insertCol); |
| if (component != null && mySpanInsertMode) { |
| Rectangle bounds = component.getBounds(); |
| bounds.translate(-vGridLines [insertCol], -hGridLines [insertRow]); |
| |
| int spaceToRight = vGridLines [lastColIndex] - vGridLines [insertCol] - (bounds.x + bounds.width); |
| int spaceBelow = hGridLines [lastRowIndex] - hGridLines [insertRow] - (bounds.y + bounds.height); |
| if (myMode == GridInsertMode.RowBefore && bounds.y > INSERT_RECT_MIN_SIZE) { |
| rcFeedback = new Rectangle(0, 0, cellWidth, bounds.y); |
| } |
| else if (myMode == GridInsertMode.RowAfter && spaceBelow > INSERT_RECT_MIN_SIZE) { |
| rcFeedback = new Rectangle(0, bounds.y + bounds.height, cellWidth, spaceBelow); |
| } |
| else if (myMode == GridInsertMode.ColumnBefore && bounds.x > INSERT_RECT_MIN_SIZE) { |
| rcFeedback = new Rectangle(0, 0, bounds.x, cellHeight); |
| } |
| else if (myMode == GridInsertMode.ColumnAfter && spaceToRight > INSERT_RECT_MIN_SIZE) { |
| rcFeedback = new Rectangle(bounds.x + bounds.width, 0, spaceToRight, cellHeight); |
| } |
| |
| if (rcFeedback != null) { |
| boolean spanInsertMode = false; |
| |
| if (isRowInsert()) { |
| int columns = layoutManager.getGridColumnCount(getContainer()); |
| for (int i = 0; i < columns; i++) { |
| if (i != insertCol && RadAbstractGridLayoutManager.getComponentAtGrid(getContainer(), insertRow, i) != null) { |
| spanInsertMode = true; |
| break; |
| } |
| } |
| } else { |
| int rows = layoutManager.getGridRowCount(getContainer()); |
| for (int i = 0; i < rows; i++) { |
| if (i != insertRow && RadAbstractGridLayoutManager.getComponentAtGrid(getContainer(), i, insertCol) != null) { |
| spanInsertMode = true; |
| break; |
| } |
| } |
| } |
| |
| if (!spanInsertMode) { |
| rcFeedback = null; |
| } |
| } |
| |
| if (rcFeedback != null) { |
| rcFeedback.translate(vGridLines [insertCol], hGridLines [insertRow]); |
| } |
| } |
| |
| if (rcFeedback == null) { |
| if (insertCol == layoutManager.getGridColumnCount(getContainer())-1 && myMode == GridInsertMode.ColumnAfter) { |
| final Dimension initialSize = dragObject.getInitialSize(getContainer()); |
| int feedbackX = vGridLines [vGridLines.length-1] + layoutManager.getGapCellSize(myContainer, false); |
| int remainingSize = getContainer().getDelegee().getWidth() - feedbackX; |
| if (!dragObject.isHGrow() && remainingSize > initialSize.width) { |
| if (dragObject.isVGrow() || initialSize.height > cellHeight) { |
| rcFeedback = new Rectangle(feedbackX, hGridLines [insertRow], initialSize.width, cellHeight); |
| } |
| else { |
| rcFeedback = new Rectangle(feedbackX, hGridLines [insertRow] + (cellHeight - initialSize.height)/2, |
| initialSize.width, initialSize.height); |
| } |
| } |
| else if (remainingSize >= 4) { |
| rcFeedback = new Rectangle(feedbackX, hGridLines [insertRow], remainingSize, cellHeight); |
| } |
| } |
| else if (insertRow == layoutManager.getGridRowCount(getContainer())-1 && myMode == GridInsertMode.RowAfter) { |
| final Dimension initialSize = dragObject.getInitialSize(getContainer()); |
| int feedbackY = hGridLines [hGridLines.length-1] + layoutManager.getGapCellSize(myContainer, true); |
| int remainingSize = getContainer().getDelegee().getHeight() - feedbackY; |
| if (!dragObject.isVGrow() && remainingSize > initialSize.height) { |
| rcFeedback = new Rectangle(vGridLines [insertCol], feedbackY, cellWidth, initialSize.height); |
| } |
| else if (remainingSize >= 4) { |
| rcFeedback = new Rectangle(vGridLines [insertCol], feedbackY, cellWidth, remainingSize); |
| } |
| } |
| } |
| } |
| |
| if (rcFeedback != null) { |
| feedbackLayer.putFeedback(getContainer().getDelegee(), rcFeedback, getInsertFeedbackTooltip()); |
| return; |
| } |
| |
| rc = getInsertFeedbackPosition(myMode, getContainer(), cellRect, feedbackRect); |
| feedbackLayer.putFeedback(getContainer().getDelegee(), rc, painter, getInsertFeedbackTooltip()); |
| } |
| |
| private String getInsertFeedbackTooltip() { |
| int displayRow = myRow + getContainer().getGridLayoutManager().getCellIndexBase(); |
| int displayColumn = myColumn + getContainer().getGridLayoutManager().getCellIndexBase(); |
| String displayName = getContainer().getDisplayName(); |
| switch(myMode) { |
| case ColumnBefore: return UIDesignerBundle.message("insert.feedback.before.col", displayName, displayRow, displayColumn); |
| case ColumnAfter: return UIDesignerBundle.message("insert.feedback.after.col", displayName, displayRow, displayColumn); |
| case RowBefore: return UIDesignerBundle.message("insert.feedback.before.row", displayName, displayColumn, displayRow); |
| case RowAfter: return UIDesignerBundle.message("insert.feedback.after.row", displayName, displayColumn, displayRow); |
| } |
| return null; |
| } |
| |
| public static Rectangle getInsertFeedbackPosition(final GridInsertMode mode, final RadContainer container, final Rectangle cellRect, |
| final Rectangle feedbackRect) { |
| final RadAbstractGridLayoutManager manager = container.getGridLayoutManager(); |
| int[] vGridLines = manager.getVerticalGridLines(container); |
| int[] hGridLines = manager.getHorizontalGridLines(container); |
| |
| Rectangle rc = feedbackRect; |
| int w=4; |
| switch (mode) { |
| case ColumnBefore: |
| rc = new Rectangle(vGridLines [cellRect.x] - w, feedbackRect.y - INSERT_ARROW_SIZE, |
| 2 * w, feedbackRect.height + 2 * INSERT_ARROW_SIZE); |
| if (cellRect.x > 0 && manager.isGapCell(container, false, cellRect.x-1)) { |
| rc.translate(-(vGridLines [cellRect.x] - vGridLines [cellRect.x-1]) / 2, 0); |
| } |
| break; |
| |
| case ColumnAfter: |
| rc = new Rectangle(vGridLines [cellRect.x + cellRect.width+1] - w, feedbackRect.y - INSERT_ARROW_SIZE, |
| 2 * w, feedbackRect.height + 2 * INSERT_ARROW_SIZE); |
| if (cellRect.x < manager.getGridColumnCount(container)-1 && manager.isGapCell(container, false, cellRect.x+1)) { |
| rc.translate((vGridLines [cellRect.x+2] - vGridLines [cellRect.x+1]) / 2, 0); |
| } |
| break; |
| |
| case RowBefore: |
| rc = new Rectangle(feedbackRect.x - INSERT_ARROW_SIZE, hGridLines [cellRect.y] - w, |
| feedbackRect.width + 2 * INSERT_ARROW_SIZE, 2 * w); |
| if (cellRect.y > 0 && manager.isGapCell(container, true, cellRect.y-1)) { |
| rc.translate(0, -(hGridLines [cellRect.y] - hGridLines [cellRect.y-1]) / 2); |
| } |
| break; |
| |
| case RowAfter: |
| rc = new Rectangle(feedbackRect.x - INSERT_ARROW_SIZE, hGridLines [cellRect.y+cellRect.height+1] - w, |
| feedbackRect.width + 2 * INSERT_ARROW_SIZE, 2 * w); |
| if (cellRect.y < manager.getGridRowCount(container)-1 && manager.isGapCell(container, true, cellRect.y+1)) { |
| rc.translate(0, (hGridLines [cellRect.y+2] - hGridLines [cellRect.y+1]) / 2); |
| } |
| break; |
| } |
| |
| return rc; |
| } |
| |
| |
| @Override |
| public void processDrop(final GuiEditor editor, |
| final RadComponent[] components, |
| @Nullable final GridConstraints[] constraintsToAdjust, |
| final ComponentDragObject dragObject) { |
| int row = getRow(); |
| int col = getColumn(); |
| RadContainer container = getContainer(); |
| boolean canGrow = isRowInsert() ? dragObject.isVGrow() : dragObject.isHGrow(); |
| int cell = isRowInsert() ? getRow() : getColumn(); |
| |
| int cellsToInsert = 1; |
| if (components.length > 0) { |
| int cellSize = container.getGridCellCount(isRowInsert()); |
| Rectangle rc = getDragObjectDimensions(dragObject, cell < cellSize - 1); |
| int size = isRowInsert() ? rc.height : rc.width; |
| if (size > 0) { |
| cellsToInsert = size; |
| } |
| } |
| |
| GridSpanInsertProcessor spanInsertProcessor = |
| mySpanInsertMode && dragObject.getComponentCount() == 1 ? new GridSpanInsertProcessor(container, getRow(), getColumn(), myMode, |
| dragObject) : null; |
| |
| int newCell = insertGridCells(container, cell, cellsToInsert, canGrow, isRowInsert(), !isInsertAfter(), constraintsToAdjust); |
| if (isRowInsert()) { |
| row = newCell; |
| } |
| else { |
| col = newCell; |
| } |
| |
| if (components.length > 0) { |
| if (spanInsertProcessor != null) { |
| spanInsertProcessor.doBefore(newCell); |
| } |
| |
| dropIntoGrid(container, components, row, col, dragObject); |
| |
| if (spanInsertProcessor != null) { |
| spanInsertProcessor.doAfter(newCell); |
| } |
| } |
| } |
| |
| private static int insertGridCells(RadContainer container, int cell, int cellsToInsert, boolean canGrow, boolean isRow, boolean isBefore, |
| GridConstraints[] constraintsToAdjust) { |
| int insertedCells = 1; |
| for(int i=0; i<cellsToInsert; i++) { |
| insertedCells = container.getGridLayoutManager().insertGridCells(container, cell, isRow, isBefore, canGrow); |
| } |
| // for insert after, shift only by one cell + possibly one gap cell, not by entire number of insertions |
| if (!isBefore) { |
| cell += insertedCells; |
| } |
| checkAdjustConstraints(constraintsToAdjust, isRow, cell, insertedCells); |
| return cell; |
| } |
| |
| private static void checkAdjustConstraints(@Nullable final GridConstraints[] constraintsToAdjust, |
| final boolean isRow, |
| final int index, final int count) { |
| if (constraintsToAdjust != null) { |
| for(GridConstraints constraints: constraintsToAdjust) { |
| GridChangeUtil.adjustConstraintsOnInsert(constraints, isRow, index, count); |
| } |
| } |
| } |
| |
| |
| @NonNls @Override public String toString() { |
| return "GridInsertLocation(" + myMode.toString() + ", row=" + getRow() + ", col=" + getColumn() + ")"; |
| } |
| |
| @Override @Nullable |
| public ComponentDropLocation getAdjacentLocation(Direction direction) { |
| if (isRowInsert()) { |
| if (direction == Direction.RIGHT) { |
| if (getColumn() < myContainer.getGridColumnCount()-1) { |
| return new GridInsertLocation(myContainer, getRow(), FormEditingUtil.adjustForGap(myContainer, getColumn()+1, false, 1), getMode()); |
| } |
| return new GridInsertLocation(myContainer, getRow(), getColumn(), GridInsertMode.ColumnAfter); |
| } |
| if (direction == Direction.LEFT) { |
| if (getColumn() > 0) { |
| return new GridInsertLocation(myContainer, getRow(), FormEditingUtil.adjustForGap(myContainer, getColumn()-1, false, -1), getMode()); |
| } |
| return new GridInsertLocation(myContainer, getRow(), getColumn(), GridInsertMode.ColumnBefore); |
| } |
| if (direction == Direction.DOWN || direction == Direction.UP) { |
| int adjRow = (myMode == GridInsertMode.RowAfter) ? getRow() : getRow()-1; |
| if (direction == Direction.DOWN && adjRow+1 < myContainer.getGridRowCount()) { |
| return new GridDropLocation(myContainer, FormEditingUtil.adjustForGap(myContainer, adjRow+1, true, 1), getColumn()); |
| } |
| if (direction == Direction.UP && adjRow >= 0) { |
| return new GridDropLocation(myContainer, FormEditingUtil.adjustForGap(myContainer, adjRow, true, -1), getColumn()); |
| } |
| return getLocationAtParent(direction); |
| } |
| } |
| else { |
| if (direction == Direction.DOWN) { |
| if (getRow() < myContainer.getGridRowCount()-1) { |
| return new GridInsertLocation(myContainer, FormEditingUtil.adjustForGap(myContainer, getRow()+1, true, 1), getColumn(), getMode()); |
| } |
| return new GridInsertLocation(myContainer, getRow(), getColumn(), GridInsertMode.RowAfter); |
| } |
| if (direction == Direction.UP) { |
| if (getRow() > 0) { |
| return new GridInsertLocation(myContainer, FormEditingUtil.adjustForGap(myContainer, getRow()-1, true, -1), getColumn(), getMode()); |
| } |
| return new GridInsertLocation(myContainer, getRow(), getColumn(), GridInsertMode.RowBefore); |
| } |
| if (direction == Direction.LEFT || direction == Direction.RIGHT) { |
| int adjCol = (myMode == GridInsertMode.ColumnAfter) ? getColumn() : getColumn()-1; |
| if (direction == Direction.RIGHT && adjCol+1 < myContainer.getGridColumnCount()) { |
| return new GridDropLocation(myContainer, getRow(), FormEditingUtil.adjustForGap(myContainer, adjCol+1, false, 1)); |
| } |
| if (direction == Direction.LEFT && adjCol >= 0) { |
| return new GridDropLocation(myContainer, getRow(), FormEditingUtil.adjustForGap(myContainer, adjCol, false, -1)); |
| } |
| return getLocationAtParent(direction); |
| } |
| } |
| return null; |
| } |
| |
| private ComponentDropLocation getLocationAtParent(final Direction direction) { |
| final RadContainer parent = myContainer.getParent(); |
| if (parent.getLayoutManager().isGrid()) { |
| final GridConstraints c = myContainer.getConstraints(); |
| switch(direction) { |
| case LEFT: return new GridInsertLocation(parent, c.getRow(), c.getColumn(), GridInsertMode.ColumnBefore); |
| case RIGHT: return new GridInsertLocation(parent, c.getRow(), c.getColumn()+c.getColSpan()-1, GridInsertMode.ColumnAfter); |
| case UP: return new GridInsertLocation(parent, c.getRow(), c.getColumn(), GridInsertMode.RowBefore); |
| case DOWN: return new GridInsertLocation(parent, c.getRow()+c.getRowSpan()-1, c.getColumn(), GridInsertMode.RowAfter); |
| } |
| } |
| return null; |
| } |
| } |
