| /* |
| * Copyright 2000-2012 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.android.designer.designSurface.layout.actions; |
| |
| import com.android.SdkConstants; |
| import com.intellij.android.designer.designSurface.feedbacks.TextFeedback; |
| import com.intellij.android.designer.designSurface.graphics.DirectionResizePoint; |
| import com.intellij.android.designer.designSurface.graphics.DrawingStyle; |
| import com.intellij.android.designer.designSurface.graphics.RectangleFeedback; |
| import com.intellij.android.designer.designSurface.layout.grid.GridSelectionDecorator; |
| import com.intellij.android.designer.model.RadComponentOperations; |
| import com.intellij.android.designer.model.RadViewComponent; |
| import com.intellij.android.designer.model.grid.GridInfo; |
| import com.intellij.android.designer.model.grid.IGridProvider; |
| import com.intellij.designer.designSurface.DecorationLayer; |
| import com.intellij.designer.designSurface.EditOperation; |
| import com.intellij.designer.designSurface.FeedbackLayer; |
| import com.intellij.designer.designSurface.OperationContext; |
| import com.intellij.designer.designSurface.feedbacks.AlphaFeedback; |
| import com.intellij.designer.designSurface.feedbacks.LineMarginBorder; |
| import com.intellij.designer.model.RadComponent; |
| import com.intellij.designer.utils.Position; |
| import com.intellij.openapi.application.ApplicationManager; |
| import com.intellij.psi.xml.XmlTag; |
| import com.intellij.ui.JBColor; |
| import com.intellij.util.containers.IntArrayList; |
| import org.jetbrains.annotations.Nullable; |
| |
| import java.awt.*; |
| import java.util.List; |
| |
| /** |
| * @author Alexander Lobas |
| */ |
| public abstract class LayoutSpanOperation implements EditOperation { |
| public static final String TYPE = "layout_span"; |
| |
| protected static final Color COLOR = JBColor.GREEN.darker(); |
| |
| protected final OperationContext myContext; |
| private final GridSelectionDecorator myDecorator; |
| protected RadViewComponent myComponent; |
| private RectangleFeedback myFeedback; |
| private TextFeedback myTextFeedback; |
| private ErrorFeedback myErrorFeedback; |
| private Rectangle myBounds; |
| private Rectangle myContainerBounds; |
| private boolean myShowErrorFeedback; |
| protected int mySpan; |
| private int[] mySpans; |
| private int[] myOffsets; |
| private int[] myCells; |
| private int myIndex = -1; |
| |
| public LayoutSpanOperation(OperationContext context, GridSelectionDecorator decorator) { |
| myContext = context; |
| myDecorator = decorator; |
| } |
| |
| @Override |
| public void setComponent(RadComponent component) { |
| myComponent = (RadViewComponent)component; |
| myBounds = myDecorator.getCellBounds(myContext.getArea().getFeedbackLayer(), myComponent); |
| } |
| |
| @Override |
| public void setComponents(List<RadComponent> components) { |
| } |
| |
| protected void createFeedback() { |
| if (myFeedback == null) { |
| FeedbackLayer layer = myContext.getArea().getFeedbackLayer(); |
| |
| myTextFeedback = new TextFeedback(); |
| myTextFeedback.setBorder(new LineMarginBorder(0, 5, 3, 0)); |
| layer.add(myTextFeedback); |
| |
| myFeedback = new RectangleFeedback(DrawingStyle.RESIZE_PREVIEW); |
| layer.add(myFeedback); |
| |
| myErrorFeedback = new ErrorFeedback(); |
| layer.add(myErrorFeedback); |
| |
| layer.repaint(); |
| } |
| } |
| |
| @Override |
| public void showFeedback() { |
| createFeedback(); |
| |
| int direction = myContext.getResizeDirection(); |
| if (direction == Position.WEST || direction == Position.EAST) { |
| handleColumns(direction == Position.EAST); |
| } |
| else { |
| handleRows(direction == Position.SOUTH); |
| } |
| } |
| |
| @Override |
| public void eraseFeedback() { |
| if (myFeedback != null) { |
| FeedbackLayer layer = myContext.getArea().getFeedbackLayer(); |
| layer.remove(myTextFeedback); |
| layer.remove(myFeedback); |
| layer.remove(myErrorFeedback); |
| layer.repaint(); |
| myTextFeedback = null; |
| myFeedback = null; |
| myErrorFeedback = null; |
| } |
| } |
| |
| protected abstract String getColumnAttribute(boolean asName); |
| |
| protected abstract String getColumnSpanAttribute(boolean asName); |
| |
| protected abstract String getRowAttribute(boolean asName); |
| |
| protected abstract String getRowSpanAttribute(boolean asName); |
| |
| private void handleRows(boolean bottom) { |
| calculateRows(bottom); |
| |
| Rectangle bounds = myContext.getTransformedRectangle(myBounds); |
| int location = bottom ? bounds.y + bounds.height : bounds.y; |
| |
| if (location < myOffsets[0]) { |
| myIndex = 0; |
| myErrorFeedback.setVisible(!bottom && myShowErrorFeedback); |
| } |
| else { |
| myIndex = -1; |
| |
| for (int i = 0; i < myOffsets.length - 1; i++) { |
| if (myOffsets[i] <= location && location <= myOffsets[i + 1]) { |
| int delta1 = location - myOffsets[i]; |
| int delta2 = myOffsets[i + 1] - location; |
| myIndex = delta2 >= delta1 ? i : i + 1; |
| break; |
| } |
| } |
| |
| if (myIndex == -1) { |
| myIndex = myOffsets.length - 1; |
| myErrorFeedback.setVisible(bottom && myShowErrorFeedback); |
| } |
| else { |
| myErrorFeedback.setVisible(false); |
| } |
| } |
| |
| if (bottom) { |
| myFeedback.setBounds(myBounds.x, myBounds.y, myBounds.width, myOffsets[myIndex] - myBounds.y); |
| } |
| else { |
| myFeedback.setBounds(myBounds.x, myOffsets[myIndex], myBounds.width, myBounds.y + myBounds.height - myOffsets[myIndex]); |
| } |
| |
| myTextFeedback.clear(); |
| |
| if (!bottom) { |
| myTextFeedback.append(getRowAttribute(true)); |
| myTextFeedback.append(" "); |
| myTextFeedback.append(Integer.toString(myCells[myIndex])); |
| myTextFeedback.append(", "); |
| } |
| |
| myTextFeedback.append(getRowSpanAttribute(true)); |
| myTextFeedback.append(" "); |
| myTextFeedback.append(Integer.toString(mySpans[myIndex])); |
| myTextFeedback.centerTop(myContainerBounds); |
| } |
| |
| private void handleColumns(boolean right) { |
| calculateColumns(right); |
| |
| Rectangle bounds = myContext.getTransformedRectangle(myBounds); |
| int location = right ? bounds.x + bounds.width : bounds.x; |
| |
| if (location < myOffsets[0]) { |
| myIndex = 0; |
| myErrorFeedback.setVisible(!right && myShowErrorFeedback); |
| } |
| else { |
| myIndex = -1; |
| |
| for (int i = 0; i < myOffsets.length - 1; i++) { |
| if (myOffsets[i] <= location && location <= myOffsets[i + 1]) { |
| int delta1 = location - myOffsets[i]; |
| int delta2 = myOffsets[i + 1] - location; |
| myIndex = delta2 >= delta1 ? i : i + 1; |
| break; |
| } |
| } |
| |
| if (myIndex == -1) { |
| myIndex = myOffsets.length - 1; |
| myErrorFeedback.setVisible(right && myShowErrorFeedback); |
| } |
| else { |
| myErrorFeedback.setVisible(false); |
| } |
| } |
| |
| if (right) { |
| myFeedback.setBounds(myBounds.x, myBounds.y, myOffsets[myIndex] - myBounds.x, myBounds.height); |
| } |
| else { |
| myFeedback.setBounds(myOffsets[myIndex], myBounds.y, myBounds.x + myBounds.width - myOffsets[myIndex], myBounds.height); |
| } |
| |
| myTextFeedback.clear(); |
| |
| if (!right) { |
| myTextFeedback.append(getColumnAttribute(true)); |
| myTextFeedback.append(" "); |
| myTextFeedback.append(Integer.toString(myCells[myIndex])); |
| myTextFeedback.append(", "); |
| } |
| |
| myTextFeedback.append(getColumnSpanAttribute(true)); |
| myTextFeedback.append(" "); |
| myTextFeedback.append(Integer.toString(mySpans[myIndex])); |
| myTextFeedback.centerTop(myContainerBounds); |
| } |
| |
| protected RadComponent getContainer() { |
| return myComponent.getParent(); |
| } |
| |
| protected abstract Point getCellInfo(); |
| |
| private void calculateRows(boolean bottom) { |
| if (mySpans != null) { |
| return; |
| } |
| |
| RadComponent container = getContainer(); |
| GridInfo gridInfo = ((IGridProvider)container).getVirtualGridInfo(); |
| RadComponent[][] components = gridInfo.components; |
| Point cellInfo = getCellInfo(); |
| int row = cellInfo.y; |
| |
| FeedbackLayer layer = myContext.getArea().getFeedbackLayer(); |
| myContainerBounds = container.getBounds(layer); |
| |
| IntArrayList spans = new IntArrayList(); |
| IntArrayList offsets = new IntArrayList(); |
| |
| if (bottom) { |
| int span = 1; |
| |
| for (int i = row; i < row + mySpan; i++) { |
| spans.add(span++); |
| offsets.add(myContainerBounds.y + gridInfo.getCellPosition(layer, i + 1, 0).y); |
| } |
| |
| for (int i = row + mySpan; i < components.length; i++) { |
| if (components[i][cellInfo.x] == null) { |
| spans.add(span++); |
| offsets.add(myContainerBounds.y + gridInfo.getCellPosition(layer, i + 1, 0).y); |
| } |
| else { |
| myErrorFeedback.setBounds(myDecorator.getCellBounds(layer, components[i][cellInfo.x])); |
| myShowErrorFeedback = true; |
| break; |
| } |
| } |
| } |
| else { |
| IntArrayList columns = new IntArrayList(); |
| int span = mySpan; |
| |
| for (int i = row; i < row + mySpan; i++) { |
| spans.add(span--); |
| offsets.add(myContainerBounds.y + gridInfo.getCellPosition(layer, i, 0).y); |
| columns.add(i); |
| } |
| |
| span = mySpan; |
| |
| for (int i = row - 1; i >= 0; i--) { |
| if (components[i][cellInfo.x] == null) { |
| spans.add(0, ++span); |
| offsets.add(0, myContainerBounds.y + gridInfo.getCellPosition(layer, i, 0).y); |
| columns.add(0, i); |
| } |
| else { |
| myErrorFeedback.setBounds(myDecorator.getCellBounds(layer, components[i][cellInfo.x])); |
| myShowErrorFeedback = true; |
| break; |
| } |
| } |
| |
| myCells = columns.toArray(); |
| } |
| |
| mySpans = spans.toArray(); |
| myOffsets = offsets.toArray(); |
| } |
| |
| private void calculateColumns(boolean right) { |
| if (mySpans != null) { |
| return; |
| } |
| |
| RadComponent container = getContainer(); |
| GridInfo gridInfo = ((IGridProvider)container).getVirtualGridInfo(); |
| Point cellInfo = getCellInfo(); |
| RadComponent[] rowComponents = gridInfo.components[cellInfo.y]; |
| int column = cellInfo.x; |
| |
| FeedbackLayer layer = myContext.getArea().getFeedbackLayer(); |
| myContainerBounds = container.getBounds(layer); |
| |
| IntArrayList spans = new IntArrayList(); |
| IntArrayList offsets = new IntArrayList(); |
| |
| if (right) { |
| int span = 1; |
| |
| for (int i = column; i < column + mySpan; i++) { |
| spans.add(span++); |
| offsets.add(myContainerBounds.x + gridInfo.getCellPosition(layer, 0, i + 1).x); |
| } |
| |
| for (int i = column + mySpan; i < rowComponents.length; i++) { |
| if (rowComponents[i] == null) { |
| spans.add(span++); |
| offsets.add(myContainerBounds.x + gridInfo.getCellPosition(layer, 0, i + 1).x); |
| } |
| else { |
| myErrorFeedback.setBounds(myDecorator.getCellBounds(layer, rowComponents[i])); |
| myShowErrorFeedback = true; |
| break; |
| } |
| } |
| } |
| else { |
| IntArrayList columns = new IntArrayList(); |
| int span = mySpan; |
| |
| for (int i = column; i < column + mySpan; i++) { |
| spans.add(span--); |
| offsets.add(myContainerBounds.x + gridInfo.getCellPosition(layer, 0, i).x); |
| columns.add(i); |
| } |
| |
| span = mySpan; |
| |
| for (int i = column - 1; i >= 0; i--) { |
| if (rowComponents[i] == null) { |
| spans.add(0, ++span); |
| offsets.add(0, myContainerBounds.x + gridInfo.getCellPosition(layer, 0, i).x); |
| columns.add(0, i); |
| } |
| else { |
| myErrorFeedback.setBounds(myDecorator.getCellBounds(layer, rowComponents[i])); |
| myShowErrorFeedback = true; |
| break; |
| } |
| } |
| |
| myCells = columns.toArray(); |
| } |
| |
| mySpans = spans.toArray(); |
| myOffsets = offsets.toArray(); |
| } |
| |
| @Override |
| public boolean canExecute() { |
| return true; |
| } |
| |
| @Override |
| public void execute() throws Exception { |
| if (mySpans[myIndex] == mySpan) { |
| return; |
| } |
| |
| ApplicationManager.getApplication().runWriteAction(new Runnable() { |
| @Override |
| public void run() { |
| int direction = myContext.getResizeDirection(); |
| if (direction == Position.WEST || direction == Position.EAST) { |
| execute(getColumnAttribute(false), getColumnSpanAttribute(false), direction == Position.WEST); |
| } |
| else { |
| execute(getRowAttribute(false), getRowSpanAttribute(false), direction == Position.NORTH); |
| } |
| } |
| }); |
| } |
| |
| private void execute(String cell, String span, boolean cellFix) { |
| XmlTag tag = myComponent.getTag(); |
| |
| if (cellFix) { |
| tag.setAttribute(cell, SdkConstants.NS_RESOURCES, Integer.toString(myCells[myIndex])); |
| } |
| |
| int spanValue = mySpans[myIndex]; |
| if (spanValue == 1) { |
| RadComponentOperations.deleteAttribute(tag, span); |
| } |
| else { |
| tag.setAttribute(span, SdkConstants.NS_RESOURCES, Integer.toString(spanValue)); |
| } |
| } |
| |
| private static class ErrorFeedback extends AlphaFeedback { |
| public ErrorFeedback() { |
| super(JBColor.PINK); |
| } |
| |
| @Override |
| protected void paintOther1(Graphics2D g2d) { |
| } |
| |
| @Override |
| protected void paintOther2(Graphics2D g2d) { |
| g2d.fillRect(0, 0, getWidth(), getHeight()); |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////////// |
| // |
| // ResizePoint |
| // |
| ////////////////////////////////////////////////////////////////////////////////////////// |
| |
| protected static class SpanPoint extends DirectionResizePoint { |
| private final GridSelectionDecorator myDecorator; |
| |
| public SpanPoint(int direction, |
| Object type, |
| @Nullable String description, |
| GridSelectionDecorator decorator) { |
| super(DrawingStyle.RESIZE_SPAN, direction, type, description); |
| myDecorator = decorator; |
| } |
| |
| @Override |
| protected Rectangle getBounds(DecorationLayer layer, RadComponent component) { |
| return myDecorator.getCellBounds(layer, component); |
| } |
| } |
| } |
