5f704f9b5f6d013a33dfa6fe42abbc5fbfaed2c4
[idea/community.git] / plugins / ui-designer / src / com / intellij / uiDesigner / designSurface / GridInsertLocation.java
1 /*
2  * Copyright 2000-2009 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 package com.intellij.uiDesigner.designSurface;
18
19 import com.intellij.openapi.diagnostic.Logger;
20 import com.intellij.uiDesigner.FormEditingUtil;
21 import com.intellij.uiDesigner.GridChangeUtil;
22 import com.intellij.uiDesigner.UIDesignerBundle;
23 import com.intellij.uiDesigner.core.GridConstraints;
24 import com.intellij.uiDesigner.radComponents.RadAbstractGridLayoutManager;
25 import com.intellij.uiDesigner.radComponents.RadComponent;
26 import com.intellij.uiDesigner.radComponents.RadContainer;
27 import org.jetbrains.annotations.NonNls;
28 import org.jetbrains.annotations.NotNull;
29 import org.jetbrains.annotations.Nullable;
30
31 import java.awt.*;
32
33 /**
34  * @author yole
35  */
36 public class GridInsertLocation extends GridDropLocation {
37   private static final Logger LOG = Logger.getInstance("#com.intellij.uiDesigner.designSurface.GridInsertLocation");
38
39   public static final int INSERT_ARROW_SIZE = 3;
40   public static final int INSERT_RECT_MIN_SIZE = 15;  // should be larger than the insets increase on Shift
41
42   private GridInsertMode myMode;
43
44   public GridInsertLocation(@NotNull final RadContainer container,
45                             final int row,
46                             final int column,
47                             final GridInsertMode mode) {
48     super(container, row, column);
49     myMode = mode;
50     assert container.getLayoutManager().isGrid();
51   }
52
53   public GridInsertLocation normalize() {
54     final RadAbstractGridLayoutManager gridManager = myContainer.getGridLayoutManager();
55
56     if (myMode == GridInsertMode.RowBefore && myRow > 0) {
57       myMode = GridInsertMode.RowAfter;
58       myRow--;
59     }
60     else if (myMode == GridInsertMode.ColumnBefore && myColumn > 0) {
61       myMode = GridInsertMode.ColumnAfter;
62       myColumn--;
63     }
64
65     if (myMode == GridInsertMode.RowAfter && gridManager.isGapCell(myContainer, true, myRow)) {
66       myRow--;
67     }
68     else if (myMode == GridInsertMode.RowBefore && gridManager.isGapCell(myContainer, true, myRow)) {
69       myRow++;
70     }
71     else if (myMode == GridInsertMode.ColumnAfter && gridManager.isGapCell(myContainer, false, myColumn)) {
72       myColumn--;
73     }
74     else if (myMode == GridInsertMode.ColumnBefore && gridManager.isGapCell(myContainer, false, myColumn)) {
75       myColumn++;
76     }
77
78     return this;
79   }
80
81   public GridInsertMode getMode() {
82     return myMode;
83   }
84
85   private boolean isColumnInsert() {
86     return myMode == GridInsertMode.ColumnAfter || myMode == GridInsertMode.ColumnBefore;
87   }
88
89   private boolean isRowInsert() {
90     return myMode == GridInsertMode.RowAfter || myMode == GridInsertMode.RowBefore;
91   }
92
93   public boolean isInsert() {
94     return isColumnInsert() || isRowInsert();
95   }
96
97   private int getInsertCell() {
98     return isRowInsert() ? myRow : myColumn;
99   }
100
101   private int getOppositeCell() {
102     return isRowInsert() ? myColumn : myRow;
103   }
104
105   private boolean isInsertAfter() {
106     return myMode == GridInsertMode.ColumnAfter || myMode == GridInsertMode.RowAfter;
107   }
108
109   @Override public boolean canDrop(ComponentDragObject dragObject) {
110     Rectangle rc = getDragObjectDimensions(dragObject);
111     int size = isRowInsert() ? rc.width : rc.height;
112     if (isInsertInsideComponent(size)) {
113       LOG.debug("GridInsertLocation.canDrop()=false because insert inside component");
114       return false;
115     }
116
117     // TODO[yole]: any other conditions to check here?
118     LOG.debug("GridInsertLocation.canDrop()=true");
119     return true;
120   }
121
122   private static boolean isSameCell(final ComponentDragObject dragObject, boolean isRow) {
123     if (dragObject.getComponentCount() == 0) {
124       return true;
125     }
126     int cell = isRow ? dragObject.getRelativeRow(0) : dragObject.getRelativeCol(0);
127     for(int i=1; i<dragObject.getComponentCount(); i++) {
128       int cell2 = isRow ? dragObject.getRelativeRow(i) : dragObject.getRelativeCol(i);
129       if (cell2 != cell) {
130         return false;
131       }
132     }
133     return true;
134   }
135
136   private boolean isInsertInsideComponent(final int size) {
137     int endColumn = getInsertCell();
138     if (isInsertAfter()) endColumn++;
139     int row = getOppositeCell();
140
141     for(int r=row; r<row+size; r++) {
142       for(int col = 0; col<endColumn; col++) {
143         RadComponent component;
144         if (isColumnInsert()) {
145           component = RadAbstractGridLayoutManager.getComponentAtGrid(getContainer(), r, col);
146         }
147         else {
148           component = RadAbstractGridLayoutManager.getComponentAtGrid(getContainer(), col, r);
149         }
150
151         if (component != null) {
152           GridConstraints constraints = component.getConstraints();
153           final boolean isRow = !isColumnInsert();
154           if (constraints.getCell(isRow) + constraints.getSpan(isRow) > endColumn &&
155               constraints.getSpan(isRow) > 1) {
156             return true;
157           }
158         }
159       }
160     }
161     return false;
162   }
163
164   @Override public void placeFeedback(FeedbackLayer feedbackLayer, ComponentDragObject dragObject) {
165     final int insertCol = getColumn();
166     final int insertRow = getRow();
167
168     Rectangle feedbackRect = getGridFeedbackRect(dragObject, isColumnInsert(), isRowInsert());
169     if (feedbackRect == null) {
170       feedbackLayer.removeFeedback();
171       return;
172     }
173     Rectangle cellRect = getGridFeedbackCellRect(dragObject, isColumnInsert(), isRowInsert());
174     assert cellRect != null;
175
176     final RadAbstractGridLayoutManager layoutManager = getContainer().getGridLayoutManager();
177     int[] vGridLines = layoutManager.getVerticalGridLines(getContainer());
178     int[] hGridLines = layoutManager.getHorizontalGridLines(getContainer());
179
180     FeedbackPainter painter = (myMode == GridInsertMode.ColumnBefore ||
181                                myMode == GridInsertMode.ColumnAfter)
182                               ? VertInsertFeedbackPainter.INSTANCE
183                               : HorzInsertFeedbackPainter.INSTANCE;
184     Rectangle rc;
185
186     Rectangle rcFeedback = null;
187     if (dragObject.getComponentCount() == 1) {
188       int cellWidth = vGridLines [insertCol+1] - vGridLines [insertCol];
189       int cellHeight = hGridLines [insertRow+1] - hGridLines [insertRow];
190       RadComponent component = layoutManager.getComponentAtGrid(getContainer(), insertRow, insertCol);
191       if (component != null) {
192         Rectangle bounds = component.getBounds();
193         bounds.translate(-vGridLines [insertCol], -hGridLines [insertRow]);
194
195         int spaceToRight = vGridLines [insertCol+1] - vGridLines [insertCol] - (bounds.x + bounds.width);
196         int spaceBelow = hGridLines [insertRow+1] - hGridLines [insertRow] - (bounds.y + bounds.height);
197         if (myMode == GridInsertMode.RowBefore && bounds.y > INSERT_RECT_MIN_SIZE) {
198           rcFeedback = new Rectangle(0, 0, cellWidth, bounds.y);
199         }
200         else if (myMode == GridInsertMode.RowAfter && spaceBelow > INSERT_RECT_MIN_SIZE) {
201           rcFeedback = new Rectangle(0, bounds.y + bounds.height, cellWidth, spaceBelow);
202         }
203         else if (myMode == GridInsertMode.ColumnBefore && bounds.x > INSERT_RECT_MIN_SIZE) {
204           rcFeedback = new Rectangle(0, 0, bounds.x, cellHeight);
205         }
206         else if (myMode == GridInsertMode.ColumnAfter && spaceToRight > INSERT_RECT_MIN_SIZE) {
207           rcFeedback = new Rectangle(bounds.x + bounds.width, 0, spaceToRight, cellHeight);
208         }
209
210         if (rcFeedback != null) {
211           rcFeedback.translate(vGridLines [insertCol], hGridLines [insertRow]);
212         }
213       }
214
215       if (rcFeedback == null) {
216         if (insertCol == layoutManager.getGridColumnCount(getContainer())-1 && myMode == GridInsertMode.ColumnAfter) {
217           final Dimension initialSize = dragObject.getInitialSize(getContainer());
218           int feedbackX = vGridLines [vGridLines.length-1] + layoutManager.getGapCellSize(myContainer, false);
219           int remainingSize = getContainer().getDelegee().getWidth() - feedbackX;
220           if (!dragObject.isHGrow() && remainingSize > initialSize.width) {
221            if (dragObject.isVGrow() || initialSize.height > cellHeight) {
222               rcFeedback = new Rectangle(feedbackX, hGridLines [insertRow], initialSize.width, cellHeight);
223             }
224             else {
225               rcFeedback = new Rectangle(feedbackX, hGridLines [insertRow] + (cellHeight - initialSize.height)/2,
226                                          initialSize.width, initialSize.height);
227             }
228           }
229           else if (remainingSize >= 4) {
230             rcFeedback = new Rectangle(feedbackX, hGridLines [insertRow], remainingSize, cellHeight);
231           }
232         }
233         else if (insertRow == layoutManager.getGridRowCount(getContainer())-1 && myMode == GridInsertMode.RowAfter) {
234           final Dimension initialSize = dragObject.getInitialSize(getContainer());
235           int feedbackY = hGridLines [hGridLines.length-1] + layoutManager.getGapCellSize(myContainer, true);
236           int remainingSize = getContainer().getDelegee().getHeight() - feedbackY;
237           if (!dragObject.isVGrow() && remainingSize > initialSize.height) {
238             rcFeedback = new Rectangle(vGridLines [insertCol], feedbackY, cellWidth, initialSize.height);
239           }
240           else if (remainingSize >= 4) {
241             rcFeedback = new Rectangle(vGridLines [insertCol], feedbackY, cellWidth, remainingSize);
242           }
243         }
244       }
245     }
246
247     if (rcFeedback != null) {
248       feedbackLayer.putFeedback(getContainer().getDelegee(), rcFeedback, getInsertFeedbackTooltip());
249       return;
250     }
251
252     rc = getInsertFeedbackPosition(myMode, getContainer(), cellRect, feedbackRect);
253     feedbackLayer.putFeedback(getContainer().getDelegee(), rc, painter, getInsertFeedbackTooltip());
254   }
255
256   private String getInsertFeedbackTooltip() {
257     int displayRow = myRow + getContainer().getGridLayoutManager().getCellIndexBase();
258     int displayColumn = myColumn + getContainer().getGridLayoutManager().getCellIndexBase();
259     String displayName = getContainer().getDisplayName();
260     switch(myMode) {
261       case ColumnBefore: return UIDesignerBundle.message("insert.feedback.before.col", displayName, displayRow, displayColumn);
262       case ColumnAfter:  return UIDesignerBundle.message("insert.feedback.after.col", displayName, displayRow, displayColumn);
263       case RowBefore:    return UIDesignerBundle.message("insert.feedback.before.row", displayName, displayColumn, displayRow);
264       case RowAfter:     return UIDesignerBundle.message("insert.feedback.after.row", displayName, displayColumn, displayRow);
265     }
266     return null;
267   }
268
269   public static Rectangle getInsertFeedbackPosition(final GridInsertMode mode, final RadContainer container, final Rectangle cellRect,
270                                                     final Rectangle feedbackRect) {
271     final RadAbstractGridLayoutManager manager = container.getGridLayoutManager();
272     int[] vGridLines = manager.getVerticalGridLines(container);
273     int[] hGridLines = manager.getHorizontalGridLines(container);
274
275     Rectangle rc = feedbackRect;
276     int w=4;
277     switch (mode) {
278       case ColumnBefore:
279         rc = new Rectangle(vGridLines [cellRect.x] - w, feedbackRect.y - INSERT_ARROW_SIZE,
280                            2 * w, feedbackRect.height + 2 * INSERT_ARROW_SIZE);
281         if (cellRect.x > 0 && manager.isGapCell(container, false, cellRect.x-1)) {
282           rc.translate(-(vGridLines [cellRect.x] - vGridLines [cellRect.x-1]) / 2, 0);
283         }
284         break;
285
286       case ColumnAfter:
287         rc = new Rectangle(vGridLines [cellRect.x + cellRect.width+1] - w, feedbackRect.y - INSERT_ARROW_SIZE,
288                            2 * w, feedbackRect.height + 2 * INSERT_ARROW_SIZE);
289         if (cellRect.x < manager.getGridColumnCount(container)-1 && manager.isGapCell(container, false, cellRect.x+1)) {
290           rc.translate((vGridLines [cellRect.x+2] - vGridLines [cellRect.x+1]) / 2, 0);
291         }
292         break;
293
294       case RowBefore:
295         rc = new Rectangle(feedbackRect.x - INSERT_ARROW_SIZE, hGridLines [cellRect.y] - w,
296                            feedbackRect.width + 2 * INSERT_ARROW_SIZE, 2 * w);
297         if (cellRect.y > 0 && manager.isGapCell(container, true, cellRect.y-1)) {
298           rc.translate(0, -(hGridLines [cellRect.y] - hGridLines [cellRect.y-1]) / 2);
299         }
300         break;
301
302       case RowAfter:
303         rc = new Rectangle(feedbackRect.x - INSERT_ARROW_SIZE, hGridLines [cellRect.y+cellRect.height+1] - w,
304                            feedbackRect.width + 2 * INSERT_ARROW_SIZE, 2 * w);
305         if (cellRect.y < manager.getGridRowCount(container)-1 && manager.isGapCell(container, true, cellRect.y+1)) {
306           rc.translate(0, (hGridLines [cellRect.y+2] - hGridLines [cellRect.y+1]) / 2);
307         }
308         break;
309     }
310
311     return rc;
312   }
313
314
315   @Override
316   public void processDrop(final GuiEditor editor,
317                           final RadComponent[] components,
318                           @Nullable final GridConstraints[] constraintsToAdjust,
319                           final ComponentDragObject dragObject) {
320     int row = getRow();
321     int col = getColumn();
322     RadContainer container = getContainer();
323     boolean canGrow = isRowInsert() ? dragObject.isVGrow() : dragObject.isHGrow();
324     int cell = isRowInsert() ? getRow() : getColumn();
325
326     int cellsToInsert = 1;
327     if (components.length > 0) {
328       Rectangle rc = getDragObjectDimensions(dragObject);
329       int size = isRowInsert() ? rc.height : rc.width;
330       if (size > 0) {
331         cellsToInsert = size;
332       }
333     }
334
335     int newCell = insertGridCells(container, cell, cellsToInsert, canGrow, isRowInsert(), !isInsertAfter(), constraintsToAdjust);
336     if (isRowInsert()) {
337       row = newCell;
338     }
339     else {
340       col = newCell;
341     }
342
343     if (components.length > 0) {
344       dropIntoGrid(container, components, row, col, dragObject);
345     }
346   }
347
348   private static int insertGridCells(RadContainer container, int cell, int cellsToInsert, boolean canGrow, boolean isRow, boolean isBefore,
349                                      GridConstraints[] constraintsToAdjust) {
350     int insertedCells = 1;
351     for(int i=0; i<cellsToInsert; i++) {
352       insertedCells = container.getGridLayoutManager().insertGridCells(container, cell, isRow, isBefore, canGrow);
353     }
354     // for insert after, shift only by one cell + possibly one gap cell, not by entire number of insertions
355     if (!isBefore) {
356       cell += insertedCells;
357     }
358     checkAdjustConstraints(constraintsToAdjust, isRow, cell, insertedCells);
359     return cell;
360   }
361
362   private static void checkAdjustConstraints(@Nullable final GridConstraints[] constraintsToAdjust,
363                                              final boolean isRow,
364                                              final int index, final int count) {
365     if (constraintsToAdjust != null) {
366       for(GridConstraints constraints: constraintsToAdjust) {
367         GridChangeUtil.adjustConstraintsOnInsert(constraints, isRow, index, count);
368       }
369     }
370   }
371
372
373   @NonNls @Override public String toString() {
374     return "GridInsertLocation(" + myMode.toString() + ", row=" + getRow() + ", col=" + getColumn() + ")";
375   }
376
377   @Override @Nullable
378   public ComponentDropLocation getAdjacentLocation(Direction direction) {
379     if (isRowInsert()) {
380       if (direction == Direction.RIGHT) {
381         if (getColumn() < myContainer.getGridColumnCount()-1) {
382           return new GridInsertLocation(myContainer, getRow(), FormEditingUtil.adjustForGap(myContainer, getColumn()+1, false, 1), getMode());
383         }
384         return new GridInsertLocation(myContainer, getRow(), getColumn(), GridInsertMode.ColumnAfter);
385       }
386       if (direction == Direction.LEFT) {
387         if (getColumn() > 0) {
388           return new GridInsertLocation(myContainer, getRow(), FormEditingUtil.adjustForGap(myContainer, getColumn()-1, false, -1), getMode());
389         }
390         return new GridInsertLocation(myContainer, getRow(), getColumn(), GridInsertMode.ColumnBefore);
391       }
392       if (direction == Direction.DOWN || direction == Direction.UP) {
393         int adjRow = (myMode == GridInsertMode.RowAfter) ? getRow() : getRow()-1;
394         if (direction == Direction.DOWN && adjRow+1 < myContainer.getGridRowCount()) {
395           return new GridDropLocation(myContainer, FormEditingUtil.adjustForGap(myContainer, adjRow+1, true, 1), getColumn());
396         }
397         if (direction == Direction.UP && adjRow >= 0) {
398           return new GridDropLocation(myContainer, FormEditingUtil.adjustForGap(myContainer, adjRow, true, -1), getColumn());
399         }
400         return getLocationAtParent(direction);
401       }
402     }
403     else {
404       if (direction == Direction.DOWN) {
405         if (getRow() < myContainer.getGridRowCount()-1) {
406           return new GridInsertLocation(myContainer, FormEditingUtil.adjustForGap(myContainer, getRow()+1, true, 1), getColumn(), getMode());
407         }
408         return new GridInsertLocation(myContainer, getRow(), getColumn(), GridInsertMode.RowAfter);
409       }
410       if (direction == Direction.UP) {
411         if (getRow() > 0) {
412           return new GridInsertLocation(myContainer, FormEditingUtil.adjustForGap(myContainer, getRow()-1, true, -1), getColumn(), getMode());
413         }
414         return new GridInsertLocation(myContainer, getRow(), getColumn(), GridInsertMode.RowBefore);
415       }
416       if (direction == Direction.LEFT || direction == Direction.RIGHT) {
417         int adjCol = (myMode == GridInsertMode.ColumnAfter) ? getColumn() : getColumn()-1;
418         if (direction == Direction.RIGHT && adjCol+1 < myContainer.getGridColumnCount()) {
419           return new GridDropLocation(myContainer, getRow(), FormEditingUtil.adjustForGap(myContainer, adjCol+1, false, 1));
420         }
421         if (direction == Direction.LEFT && adjCol >= 0) {
422           return new GridDropLocation(myContainer, getRow(), FormEditingUtil.adjustForGap(myContainer, adjCol, false, -1));
423         }
424         return getLocationAtParent(direction);
425       }
426     }
427     return null;
428   }
429
430   private ComponentDropLocation getLocationAtParent(final Direction direction) {
431     final RadContainer parent = myContainer.getParent();
432     if (parent.getLayoutManager().isGrid()) {
433       final GridConstraints c = myContainer.getConstraints();
434       switch(direction) {
435         case LEFT: return new GridInsertLocation(parent, c.getRow(), c.getColumn(), GridInsertMode.ColumnBefore);
436         case RIGHT: return new GridInsertLocation(parent, c.getRow(), c.getColumn()+c.getColSpan()-1, GridInsertMode.ColumnAfter);
437         case UP: return new GridInsertLocation(parent, c.getRow(), c.getColumn(), GridInsertMode.RowBefore);
438         case DOWN: return new GridInsertLocation(parent, c.getRow()+c.getRowSpan()-1, c.getColumn(), GridInsertMode.RowAfter);
439       }
440     }
441     return null;
442   }
443 }