listeners = new ArrayList<>();
public void addDragCardGridListener(DragCardGridListener l) {
listeners.add(l);
}
private void notifyCardsSelected() {
for (DragCardGridListener listener : listeners) {
listener.cardsSelected();
}
}
private void selectCard(CardView targetCard) {
// Set the selected card to the target card
for (CardView card : allCards) {
if (card == targetCard) {
if (!card.isSelected()) {
card.setSelected(true);
cardViews.get(card.getId()).update(card);
}
} else if (card.isSelected()) {
card.setSelected(false);
cardViews.get(card.getId()).update(card);
}
}
}
private void toggleSelected(CardView targetCard) {
targetCard.setSelected(!targetCard.isSelected());
cardViews.get(targetCard.getId()).update(targetCard);
}
private void cardClicked(CardView targetCard, MouseEvent e) {
if (e.isShiftDown()) {
toggleSelected(targetCard);
} else {
selectCard(targetCard);
}
notifyCardsSelected();
}
private void removeCardView(CardView card) {
allCards.remove(card);
// Remove fromcounts
for (CardTypeCounter counter : allCounters) {
counter.remove(card);
}
updateCounts();
cardContent.remove(cardViews.get(card.getId()));
cardViews.remove(card.getId());
}
/**
* Add a card to the cardGrid, in the position that the current sort
* dictates.
*
* Warning, you must call trimGrid() after all cards inserted
*
* @param newCard Card to add to the cardGrid array.
*/
private void sortIntoGrid(CardView newCard, CardView duplicatedFromCard) {
// fast put duplicated card to the same place as original
if (duplicatedFromCard != null) {
for (List> gridRow : cardGrid) {
for (List gridStack : gridRow) {
for (int i = 0; i < gridStack.size(); i++) {
if (gridStack.get(i).equals(duplicatedFromCard)) {
gridStack.add(i, newCard);
return;
}
}
}
}
}
// row 1 must exists
if (cardGrid.isEmpty()) {
cardGrid.add(0, new ArrayList<>());
maxStackSize.add(0, 0);
}
// target row
List> targetRow;
if (separateCreatures) {
// separate mode (two rows mode)
// row 1 for creatures
// row 2 for other
// row 2 must exists
if (cardGrid.size() < 2) {
cardGrid.add(1, new ArrayList<>());
maxStackSize.add(1, 0);
// Populate with stacks matching the first row
for (int i = 0; i < cardGrid.get(0).size(); ++i) {
cardGrid.get(1).add(new ArrayList<>());
}
}
// workaround to fix wrong sorting on one card insert (if no creatures then trim will remove first row)
boolean isFirstRowWithCreatures = true;
for (int i = 0; i < cardGrid.get(0).size(); ++i) {
if (cardGrid.get(0).get(i).stream().anyMatch(card -> !card.isCreature())) {
isFirstRowWithCreatures = false;
break;
}
}
if (!isFirstRowWithCreatures) {
// move all cards to row 2 (at first position)
for (int i = 0; i < cardGrid.get(0).size(); ++i) {
if (!cardGrid.get(0).get(i).isEmpty()) {
cardGrid.get(1).add(cardGrid.get(0).get(i));
}
}
cardGrid.get(0).clear();
while (cardGrid.get(0).size() < cardGrid.get(1).size()) {
cardGrid.get(0).add(new ArrayList<>());
}
}
if (newCard.isCreature()) {
// creature cards goes to row 1
targetRow = cardGrid.get(0);
} else {
// non-creature cards goes to row 2
targetRow = cardGrid.get(1);
}
} else {
// one row mode
targetRow = cardGrid.get(0);
}
// Find the right column to insert into
boolean didInsert = false;
for (int currentColumn = 0; currentColumn < targetRow.size(); ++currentColumn) {
// Find an item from this column
CardView cardInColumn = null;
for (List> gridRow : cardGrid) {
for (CardView card : gridRow.get(currentColumn)) {
cardInColumn = card;
break;
}
}
// No card in this column?
if (cardInColumn == null) {
// Error, should not have an empty column
logger.error("Empty column! " + currentColumn);
} else {
CardViewComparator cardComparator = cardSort.getComparator();
int res = cardComparator.compare(newCard, cardInColumn);
if (res <= 0) {
// Insert into this col, but if less, then we need to create a new col here first
if (res < 0) {
for (int rowIndex = 0; rowIndex < cardGrid.size(); ++rowIndex) {
cardGrid.get(rowIndex).add(currentColumn, new ArrayList<>());
}
}
targetRow.get(currentColumn).add(newCard);
didInsert = true;
break;
} else {
// Nothing to do, go to next iteration
}
}
}
// If nothing else, insert in a new column after everything else
if (!didInsert) {
for (int rowIndex = 0; rowIndex < cardGrid.size(); ++rowIndex) {
cardGrid.get(rowIndex).add(new ArrayList<>());
}
targetRow.get(targetRow.size() - 1).add(newCard);
}
// empty row trim (trimGrid) must be called from outside after all cards inserted
}
/**
* Delete any empty columns / rows from the grid, and eleminate any empty
* space in stacks
*/
private void trimGrid() {
// Compact stacks and rows
for (int rowIndex = 0; rowIndex < cardGrid.size(); ++rowIndex) {
List> gridRow = cardGrid.get(rowIndex);
int rowMaxStackSize = 0;
for (List stack : gridRow) {
// Clear out nulls in the stack
for (int i = 0; i < stack.size(); ++i) {
if (stack.get(i) == null) {
stack.remove(i--);
}
}
// Is the stack still non-empty?
rowMaxStackSize = Math.max(rowMaxStackSize, stack.size());
}
// Is the row empty? If so remove it
if (rowMaxStackSize == 0) {
cardGrid.remove(rowIndex);
maxStackSize.remove(rowIndex);
--rowIndex;
} else {
maxStackSize.set(rowIndex, rowMaxStackSize);
}
}
// Remove empty columns
if (!cardGrid.isEmpty()) {
for (int colIndex = 0; colIndex < cardGrid.get(0).size(); ++colIndex) {
boolean hasContent = false; // Until contested
for (List> aCardGrid : cardGrid) {
if (!aCardGrid.get(colIndex).isEmpty()) {
hasContent = true;
break;
}
}
if (!hasContent) {
for (List> aCardGrid : cardGrid) {
aCardGrid.remove(colIndex);
}
--colIndex;
}
}
}
// Clean up extra column header count labels
while (stackCountLabels.size() > cardGrid.size()) {
List labels = stackCountLabels.remove(cardGrid.size());
for (JLabel label : labels) {
cardContent.remove(label);
}
}
int colCount = cardGrid.isEmpty() ? 0 : cardGrid.get(0).size();
for (List labels : stackCountLabels) {
while (labels.size() > colCount) {
cardContent.remove(labels.remove(colCount));
}
}
}
private int getCardWidth() {
if (GUISizeHelper.editorCardDimension == null) {
return 200;
}
return (int) (GUISizeHelper.editorCardDimension.width * cardSizeMod);
}
private int getCardHeight() {
return (int) (1.4 * getCardWidth());
}
private void repaintGrid() {
cardScroll.revalidate();
cardScroll.repaint();
repaint();
}
/**
* Position all of the card views correctly
*/
private void layoutGrid() {
// Basic dimensions
int cardWidth = getCardWidth();
int cardHeight = getCardHeight();
int cardTopHeight = CardRenderer.getCardTopHeight(cardWidth);
int countLabelHeight = getCountLabelHeight();
// Layout one at a time
int layerIndex = 0;
int currentY = countLabelHeight;
int maxWidth = 0;
for (int rowIndex = 0; rowIndex < cardGrid.size(); ++rowIndex) {
int rowMaxStackSize = 0;
List> gridRow = cardGrid.get(rowIndex);
for (int colIndex = 0; colIndex < gridRow.size(); ++colIndex) {
List stack = gridRow.get(colIndex);
// Stack count label
if (stackCountLabels.size() <= rowIndex) {
stackCountLabels.add(new ArrayList<>());
}
if (stackCountLabels.get(rowIndex).size() <= colIndex) {
// add new count label for the column
// ENABLE cards auto-selection in the stack
if (this.countLabelListener == null) {
this.countLabelListener = new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent e) {
if (!SwingUtilities.isLeftMouseButton(e)) {
return;
}
JLabel countLabel = (JLabel) e.getComponent();
List cards = findCardStackByCountLabel(countLabel);
boolean selected = !cards.isEmpty() && cards.get(0).isSelected();
cards.forEach(card -> {
card.setSelected(!selected);
cardViews.get(card.getId()).update(card);
});
}
};
}
JLabel countLabel = DragCardGrid.createCountLabel(this.countLabelListener);
cardContent.add(countLabel, (Integer) 0);
stackCountLabels.get(rowIndex).add(countLabel);
}
JLabel countLabel = stackCountLabels.get(rowIndex).get(colIndex);
if (stack.isEmpty()) {
countLabel.setVisible(false);
} else {
String description = cardSort.getComparator().getCategoryName(stack.get(0));
DragCardGrid.updateCountLabel(countLabel, stack.size(), description);
countLabel.setLocation(getGridPadding() + (cardWidth + getGridPadding()) * colIndex, currentY - countLabelHeight);
countLabel.setSize(cardWidth, countLabelHeight);
countLabel.setVisible(true);
}
// Max stack size
rowMaxStackSize = Math.max(rowMaxStackSize, stack.size());
// Layout cards in stack
for (int i = 0; i < stack.size(); ++i) {
CardView card = stack.get(i);
MageCard view = cardViews.get(card.getId());
int x = getGridPadding() + (cardWidth + getGridPadding()) * colIndex;
int y = currentY + i * cardTopHeight;
view.setCardBounds(x, y, cardWidth, cardHeight);
cardContent.setLayer(view, layerIndex++);
}
}
// Update the max stack size for this row and the max width
maxWidth = Math.max(maxWidth, getGridPadding() + (getGridPadding() + cardWidth) * gridRow.size());
maxStackSize.set(rowIndex, rowMaxStackSize);
currentY += (cardTopHeight * (rowMaxStackSize - 1) + cardHeight) + countLabelHeight;
}
// Resize card container
cardContent.setPreferredSize(new Dimension(maxWidth, currentY - countLabelHeight + getGridPadding()));
//cardContent.setSize(maxWidth, currentY - COUNT_LABEL_HEIGHT + getGridPadding());
}
private int getGridPadding() {
return Math.max(GRID_PADDING, Math.round(cardSizeMod * GRID_PADDING * GUISizeHelper.dialogGuiScale));
}
public static int getCountLabelHeight() {
// must allow 2 lines of text
return Math.round(1.3f * 2.0f * getCountLabelFontSize());
}
private static float getCountLabelFontSize() {
return 0.8f * GUISizeHelper.dialogFont.getSize();
}
public static Font getCountLabelFont() {
return GUISizeHelper.dialogFont.deriveFont(Font.BOLD, getCountLabelFontSize());
}
public static JLabel createCountLabel(MouseListener mouseListener) {
JLabel countLabel = new JLabel("", JLabel.CENTER);
countLabel.setFont(getCountLabelFont());
countLabel.setForeground(Color.WHITE); // TODO: add theme support for better visible text?
if (mouseListener != null) {
countLabel.addMouseListener(mouseListener);
}
return countLabel;
}
public static void updateCountLabel(JLabel countLabel, int amount, String description) {
// two modes:
// * small: one line with count
// * big: two lines with count and description
String labelText = ManaSymbols.replaceSymbolsWithHTML(description, Math.round(getCountLabelFontSize()));
String labelHint = ManaSymbols.replaceSymbolsWithHTML(description, ManaSymbols.Type.TOOLTIP);
boolean smallMode = description.isEmpty();
boolean supportCustomClicks = countLabel.getMouseListeners().length > 0
&& !(countLabel.getMouseListeners()[0] instanceof ToolTipManager); // ignore auto-added ToolTipManager for mouse over hints
// border: 1px solid black
// white-space: nowrap;
countLabel.setText(""
+ ""
+ "
" + amount + "
"
+ (smallMode ? "" : "
" + labelText + "
")
+ "
Click on the count label to select/unselect cards stack." : "")
);
countLabel.setVerticalAlignment(smallMode ? JLabel.CENTER : JLabel.TOP);
if (DebugUtil.GUI_DECK_EDITOR_DRAW_COUNT_LABEL_BORDER) {
countLabel.setBorder(BorderFactory.createLineBorder(Color.green));
}
}
private List findCardStackByCountLabel(JLabel countLabel) {
for (int rowIndex = 0; rowIndex < cardGrid.size(); ++rowIndex) {
List> gridRow = cardGrid.get(rowIndex);
for (int colIndex = 0; colIndex < gridRow.size(); ++colIndex) {
if (stackCountLabels.size() < rowIndex
|| stackCountLabels.get(rowIndex).size() < colIndex
|| !countLabel.equals(stackCountLabels.get(rowIndex).get(colIndex))) {
continue;
}
return gridRow.get(colIndex);
}
}
return new ArrayList<>();
}
private static void makeButtonPopup(final AbstractButton button, final JPopupMenu popup) {
button.addActionListener(e -> popup.show(button, 0, button.getHeight()));
}
}
/**
* Note: This class can't just be a JPanel, because a JPanel doesn't draw when
* it has Opaque = false, but this class needs to go into a JLayeredPane while
* being translucent, so it NEEDS Opaque = false in order to behave correctly.
* Thus this simple class is needed to implement a translucent box in a
* JLayeredPane.
*/
class SelectionBox extends JComponent {
public SelectionBox() {
setOpaque(false);
}
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
g = g.create();
g.setColor(new Color(100, 100, 200, 128));
g.fillRect(0, 0, getWidth(), getHeight());
g.setColor(new Color(0, 0, 255));
g.drawRect(0, 0, getWidth() - 1, getHeight() - 1);
g.dispose();
}
}