| /* |
| * Copyright (C) 2013 The Android Open Source Project |
| * |
| * 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.android.tools.idea.rendering.multi; |
| |
| import com.android.tools.idea.configurations.RenderContext; |
| import com.intellij.openapi.util.Pair; |
| import org.jetbrains.annotations.NotNull; |
| import org.jetbrains.annotations.Nullable; |
| |
| import java.awt.*; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.List; |
| |
| import static com.android.tools.idea.rendering.multi.RenderPreviewManager.*; |
| |
| /** |
| * Layout algorithm for render previews which layouts out all |
| * the previews in a regular tile. Suitable for XML preview where |
| * the layout view isn't dominant since it is not directly manipulated on. |
| */ |
| public class PreviewTileLayout { |
| private static final boolean FILL_FROM_BOTTOM = false; |
| |
| private final @NotNull List<RenderPreview> myPreviews; |
| private final @NotNull RenderContext myRenderContext; |
| private final boolean myFixedOrder; |
| |
| public PreviewTileLayout(@NotNull List<RenderPreview> previews, @NotNull RenderContext renderContext, boolean fixedOrder) { |
| myPreviews = previews; |
| myRenderContext = renderContext; |
| myFixedOrder = fixedOrder; |
| } |
| |
| private int myLayoutHeight; |
| private Dimension myFixedRenderSize; |
| |
| @Nullable |
| public Dimension getFixedRenderSize() { |
| return myFixedRenderSize; |
| } |
| |
| public void performLayout() { |
| Rectangle clientArea = myRenderContext.getClientArea(); |
| int availableWidth = clientArea.width; |
| int availableHeight = clientArea.height; |
| availableWidth -= HORIZONTAL_GAP; |
| |
| Dimension fullImageSize = myRenderContext.getFullImageSize(); |
| List<RenderPreview> aspectOrder = new ArrayList<RenderPreview>(myPreviews); |
| if (!myFixedOrder) { |
| if (FILL_FROM_BOTTOM) { |
| Collections.sort(aspectOrder, fullImageSize.width <= fullImageSize.height |
| ? RenderPreview.DECREASING_ASPECT_RATIO |
| : RenderPreview.INCREASING_ASPECT_RATIO); |
| } else { |
| Collections.sort(aspectOrder, fullImageSize.width >= fullImageSize.height ? |
| RenderPreview.DECREASING_ASPECT_RATIO : RenderPreview.INCREASING_ASPECT_RATIO); |
| } |
| } |
| |
| // Compute best row/column size |
| int cellCount = aspectOrder.size() + 1; // +1: for main preview |
| |
| Pair<Integer,Integer> shape = computeOptimalShape(availableWidth, availableHeight, cellCount); |
| int rows = shape.getFirst(); |
| int columns = shape.getSecond(); |
| int tileWidth = (availableWidth - HORIZONTAL_GAP * (columns - 1)) / columns; |
| int tileHeight = (availableHeight - VERTICAL_GAP * (rows - 1) - TITLE_HEIGHT * rows) / rows; |
| |
| RenderPreview[][] grid = computeGrid(aspectOrder, fullImageSize, rows, columns); |
| |
| // Assign positions. |
| // Work row by row; compute the minimum required height by the elements in |
| // the row, and use that height rather than the originally allocated cell height. |
| // If we for example have a row where all devices are in landscape mode, the entire |
| // row is likely not as tall as assigned, so we can recapture that space and use |
| // it for later rows near the top. |
| |
| layoutRows(availableWidth, availableHeight, rows, columns, tileWidth, tileHeight, grid); |
| |
| myLayoutHeight = availableHeight; |
| } |
| |
| private void layoutRows(int availableWidth, |
| int availableHeight, |
| int rows, |
| int columns, |
| int tileWidth, |
| int tileHeight, |
| RenderPreview[][] grid) { |
| int y = availableHeight - 2; |
| int left = availableWidth - columns * tileWidth; |
| if (left > HORIZONTAL_GAP) { |
| // Some spacing on the right |
| left -= HORIZONTAL_GAP; |
| } |
| for (int row = rows - 1; row >= 0; row--) { |
| int rowHeight = 0; |
| //int rowWidth = 0; |
| for (int column = 0; column < columns; column++) { |
| RenderPreview preview = grid[row][column]; |
| if (preview != null) { |
| preview.setMaxSize(tileWidth, tileHeight); |
| rowHeight = Math.max(rowHeight, preview.getLayoutHeight()); |
| //rowWidth += preview.getLayoutWidth(); |
| } |
| } |
| // Handle the fact that the grid doesn't actually contain an entry for the |
| // main rendering |
| if (row == 0) { |
| rowHeight = Math.max(rowHeight, tileHeight); |
| //rowWidth += tileWidth; |
| } |
| |
| // Assign positions -- and perform cell center alignment |
| y -= rowHeight; |
| if (row < rows - 1) { |
| y -= VERTICAL_GAP; |
| } |
| y -= TITLE_HEIGHT; |
| if (y < 0 || row == 0 && rows == 2) { |
| y = 0; |
| } |
| layoutRow(availableHeight, rows, columns, tileWidth, tileHeight, grid[row], y, left, row, rowHeight); |
| |
| if (row == rows - 1) { |
| // Look at the last row; we might be able to grow the last element |
| int last = columns - 1; |
| for (; last >= 0; last--) { |
| if (grid[rows - 1][last] != null) { |
| break; |
| } |
| } |
| if (last != -1 && last < columns - 1) { |
| int x = left + last * (tileWidth + HORIZONTAL_GAP) - HORIZONTAL_GAP; |
| int max = availableWidth; |
| RenderPreview preview = grid[row][last]; |
| int maxWidth = preview.getMaxWidth(); |
| int maxHeight = preview.getMaxHeight(); |
| int layoutWidth = preview.getLayoutWidth(); |
| int layoutHeight = preview.getLayoutHeight(); |
| preview.setMaxSize(Math.min(availableWidth - x, Math.max(maxWidth, max - x - HORIZONTAL_GAP / 2)), |
| Math.min(availableHeight - y, Math.max(maxHeight, rowHeight - TITLE_HEIGHT))); |
| if (preview.getLayoutWidth() != layoutWidth || preview.getLayoutHeight() != layoutHeight) { |
| preview.setPosition(x + HORIZONTAL_GAP / 2, y); |
| } |
| } |
| } |
| } |
| |
| if (rows == 1) { |
| // Center in row |
| int row = 0; |
| for (int column = 0; column < columns; column++) { |
| RenderPreview preview = grid[row][column]; |
| if (preview != null) { |
| preview.setPosition(preview.getX(), (availableHeight - preview.getLayoutHeight()) / 2); |
| } |
| } |
| } else if (columns == 1) { |
| // Center in column |
| int column = 0; |
| for (int row = 0; row < rows; row++) { |
| RenderPreview preview = grid[row][column]; |
| if (preview != null) { |
| preview.setPosition((availableWidth - preview.getLayoutWidth()) / 2, preview.getY()); |
| } |
| } |
| } |
| } |
| |
| private void layoutRow(int availableHeight, |
| int rows, |
| int columns, |
| int tileWidth, |
| int tileHeight, |
| RenderPreview[] renderPreviews, |
| int y, |
| int left, |
| int row, |
| int rowHeight) { |
| for (int column = 0; column < columns; column++) { |
| RenderPreview preview = renderPreviews[column]; |
| if (preview != null) { |
| int x = left + column * (tileWidth + HORIZONTAL_GAP); |
| preview.setPosition(x + (tileWidth - preview.getLayoutWidth()) / 2, y + (rowHeight - preview.getLayoutHeight()) / 2); |
| // TODO: Consider distributing extra space to the last item |
| preview.setVisible(true); |
| } else if (row == 0 && column == 0) { |
| // TODO: This might allow room on remaining row for other views to be larger too!!! Consider giving it to them, |
| // This requires me knowing the aspect ratio of the main view in order to determine whether it's actually going to |
| // use up the allocated width! |
| |
| // Allocate one cell plus |
| int maxWidth = left + tileWidth/* + HORIZONTAL_GAP*/; |
| |
| int maxHeight = TITLE_HEIGHT + tileHeight + availableHeight - rows * tileHeight - VERTICAL_GAP * (rows - 1); |
| myFixedRenderSize = new Dimension(maxWidth, maxHeight); |
| myRenderContext.setMaxSize(myFixedRenderSize.width, myFixedRenderSize.height); |
| } |
| } |
| } |
| |
| private RenderPreview[][] computeGrid(List<RenderPreview> previews, Dimension fullImageSize, int rows, int columns) { |
| int row; |
| int column; |
| RenderPreview[][] grid = new RenderPreview[rows][columns]; |
| |
| if (FILL_FROM_BOTTOM) { |
| // Attempt to leave room in the top row and to the left. |
| // In other words, if we have a partial row, we want the |
| // shape on the left instead of the one on the right: |
| // |
| // XX XXXXX |
| // XXXXX XXXXX |
| // XXXXX XXXXX |
| // XXXXX XX |
| |
| row = rows - 1; |
| column = columns - 1; |
| for (RenderPreview preview : previews) { |
| grid[row][column] = preview; |
| column--; |
| if (column < 0) { |
| column = columns - 1; |
| row--; |
| if (row < 0) { |
| break; |
| } |
| } |
| } |
| } else { |
| if (columns > 1) { |
| row = 0; |
| //// Reserve spot 0 for the default preview |
| column = 1; |
| } else { |
| row = 1; |
| column = 0; |
| } |
| for (RenderPreview preview : previews) { |
| grid[row][column] = preview; |
| column++; |
| if (column == columns) { |
| column = 0; |
| row++; |
| if (row == rows) { |
| break; |
| } |
| } |
| } |
| } |
| return grid; |
| } |
| |
| private double pickAspectRatio() { |
| double minAspect = myPreviews.get(0).getAspectRatio(); |
| double maxAspect = minAspect; |
| |
| for (RenderPreview preview : myPreviews) { |
| double aspect = preview.getAspectRatio(); |
| if (aspect > maxAspect) { |
| maxAspect = aspect; |
| } |
| if (aspect < minAspect) { |
| minAspect = aspect; |
| } |
| } |
| |
| // Aspect: figure out the aspect ratio with the title embedded! |
| double aspect; |
| if (minAspect < 1 && maxAspect > 1) { |
| aspect = 1; |
| } else if (minAspect < 1) { |
| aspect = minAspect; |
| } else { |
| aspect = maxAspect; |
| } |
| return aspect; |
| } |
| |
| private Pair<Integer, Integer> computeOptimalShape(int availableWidth, int availableHeight, int count) { |
| double aspect = pickAspectRatio(); |
| int bestColumns = 1; |
| int bestRows = count; |
| int bestSize = 0; |
| for (int columns = 1; columns <= count; columns++) { |
| int rows = count / columns; |
| if (count % columns > 0) { |
| rows++; |
| } |
| int width = (availableWidth - HORIZONTAL_GAP * (columns - 1)) / columns; |
| int height = (int)(width / aspect); |
| int requiredHeight = height * rows + VERTICAL_GAP * (rows - 1) + TITLE_HEIGHT * rows; |
| if (requiredHeight > availableHeight) { |
| height = (availableHeight - VERTICAL_GAP * (rows - 1) - TITLE_HEIGHT * rows) / rows; |
| width = (int)(height * aspect); |
| } |
| |
| if (width > bestSize) { |
| bestSize = width; |
| bestColumns = columns; |
| bestRows = rows; |
| } |
| } |
| return Pair.create(bestRows, bestColumns); |
| } |
| |
| public int getLayoutHeight() { |
| return myLayoutHeight; |
| } |
| } |
