Diviser une plage uniformément, permettant des espaces et des marges

Question

J'ai un tableau de points et un panneau.getWidth() est basé sur le panneau.Imaginez des cartes dans votre main, donc HAND_CARD_WIDTH est assez explicite.Le but de cette boucle est de définir les points uniformément sur le panneau, ce qu'elle fait.Cependant, cela permet aux cartes de sortir du panneau, ce qui le rend très mauvais.Ce que je veux faire, c'est donner une petite marge vide des deux côtés du panneau, quel que soit le nombre de cartes que vous avez en main.

Voici le code

        int iteration = 1;
        int limiter = getWidth();
        int slice = (limiter/(handsize+1));

        while (points.size() < handsize) {
            int x = slice*(iteration++);
            x -= HAND_CARD_WIDTH/2;
            points.add(new Point(x, y));    
        }

Fondamentalement, je veux que le x le plus à gauche soit au moins 20 et le plus à droite au plus getWidth() - 20 - HAND_CARD_WIDTH.Je veux aussi que les cartes soient régulièrement espacées ... Je n'arrive tout simplement pas à trouver la bonne équation (arriver à ce point était malheureusement un exploit ...).

Merci, sur la base des réponses (toutes les 2) voici ce que j'ai choisi:

        if((int)points.get(0).getX() < margin){
            int boost = Math.abs(margin - (int)points.get(0).getX());
            slice = (boost*2)/handsize;
            for(Point p : points){
                p.x += boost;
                boost -= slice;
            }
        }

Answer 1

Je ne sais pas si je comprends votre mise en page, mais je pense que c'est quelque chose comme ça:

| marge | espace | carte | espace | carte | espace | marge |

ou

| marge | espace | carte | espace | marge |

Ainsi, le nombre d'espaces est un de plus que le nombre de cartes et la largeur totale est la largeur du composant moins les marges. componentWidth= numCards x cardWidth + (numCards + 1) x spaceWidth Il est maintenant facile de calculer l'espace nécessaire qui est (componentWidth - numCards x cardWidth) / (numCards + 1) donc la position gauche d'une carte est leftMargin + spaceWidth x cardNum + cardWidth x (cardNum - 1)

Des précautions doivent être prises lorsque l'espace est négatif, alors vous devez à la place calculer combien les cartes doivent se chevaucher.

Answer 2

Essayez ceci:

final int MARGIN = 20;
int availableWidth = getWidth() - 2 * MARGIN - HAND_CARD_WIDTH;
int cardSpaceWidth = availableWidth / handsize;
for (int i = 0; i < handsize; i++) {
    int x = MARGIN + ((i + 0.5) * cardSpaceWidth) - HAND_CARD_WIDTH / 2;
    points.add(new Point(x, y));
}

Donc:

• calculer la largeur disponible en soustrayant les marges de la largeur totale du panneau
• calculez l'espace pour chaque carte en divisant l'espace restant par le nombre de cartes
• pour chaque carte, nous comptons son point le plus à gauche en prenant le milieu de l'espace de la carte et en soustrayant la moitié de la largeur de la carte.

Attention, avec cette solution, les cartes peuvent toujours chevaucher les marges, si HAND_CARD_WIDTH est plus grand que l'espace disponible pour la carte.