Hola los amigos ^^ , je vous rassure je me sent très bien aucune séquelle mental pour l'instant , que du plaisir c'est juste que je me suis mis à l'Espagnol , formation oblige =) ...aller, sans plus tarder
je vais commencer à exposer ce que contient ce fameux package graphique. Et c'est sans vous dire que nous allons traiter des tas de nouveaux concepts...
Avant de construire n'importe quel chose , nous aurons bien besoin d'outil , fini les temps des pharaons ou on soulevais des pierres de plusieurs centaine de Kilo en utilisant des moyens dérisoires,
ma table de jeu aura bien besoin d'outils permettant une intégration facile des éléments de jeu,
Avant de parler d’outils, on va commencer tout d'abord par expliquer en quoi consiste cette grille de jeu, une grille assez simple, contenant un Jpanel auquel nous avons définie un GridBagLayout,
je tiens à signaler qu'avant d'appliquer un GridBagLayout , j'ai fait quelques tests non concluant en utilisant un GridLayout , conclusion tiré , le GridBagLayout offre plus de flexibilité quand au positionnement et à la récupération de ses éléments .
Pour ajouter un élément à un GridBagLayout nous aurons forcement besoin d'un GridBagConstraints, qui nous permet de définir les contraintes relatifs à chaque élément (coordonnée sur la grille : gridx,gridy et nombre de case concernée :gridwidth,gridheight)
et c'est la que la définition d'un premier outil graphique s'est imposé , nous auront tellement d'éléments à gérer qu'il sera totalement bourrin le fait de modifier les paramètres de ces contraintes chaque ajout, ma Class DisplayingTools contient donc une fonction , GridBagTransformer qui prend comme paramètre mon GridBagConstraints , aussi bien que les valeurs des éléments à assigner à chacun de ses paramètres , se charge ensuite de les modifier et de retourner l'objet prêt à être utiliser lors du prochain ajout :
public GridBagConstraints GBTransformer(GridBagConstraints GridBagCInput,int x,int y,int px, int py)
{
GridBagCInput.gridx=x;
GridBagCInput.gridy=y;
GridBagCInput.gridwidth=px;
GridBagCInput.gridheight=py;
return GridBagCInput;
}
Enfin, et pour illustrer l'utilisation de cet outil , je vais devoir passer à la classe DisplayingTable , sur laquelle la grille aussi bien que tout les éléments de jeu sont instanciée et ajouté.
Chaque case de ma grille aura forcement besoin d'un élément définissant aussi bien sa couleur qu'éventuellement l'icone (pion, tour, cheval , reine ...etc. ) désignant l'élément présent. Nous opterons alors pour des Jlabel , ce qui nous évitera d'avoir a chaque fois à dessiner un rectangle et d'y ajouter une icône ,
Nous aurons donc à initialiser les éléments suivant :
private JLabel [][] labes=new JLabel[8][8];
private JPanel table=new JPanel();
private Color [][] colors=new Color[8][8];
private GridBagConstraints GBC=new GridBagConstraints();
private DisplayingTools TransformerTool=new DisplayingTools();
le premier tableau labes contient tout les éléments à ajouter à chaque case de notre Jpanel,
notre Jpanel a été initialisé juste en dessous,
le tableau Colors, nous permet d'avoir en mémorisation la couleur de chaque case. Enfin et en dernier , nous avons définie nos deux éléments GridBagConstraints GBC et TransformerTool qui vont nous aider en quelque sorte à ajouter nos éléments d'une manière assez soft .
Notre constructeur, DisplayingTable se chargera donc d'initialiser chaque élément , de modifier notre GBC à travers l'outils définie précédemment pour au final l'ajouter à notre Jpanel table :
public DisplayingTable()
{
Container container=getContentPane();
container.setLayout(null);
table.setLayout(new GridBagLayout());
boolean commute=false;
for(int i=0;i<8;i++)
{
for(int j=0;j<8;j++)
{
if(i%2==0)
{
if(commute==true)
{
labes[i][j]=new JLabel();
labes[i][j].setOpaque(true);
labes[i][j].setBackground(Color.green);
colors[i][j]=Color.green;
labes[i][j].setPreferredSize(new Dimension(50,50));
table.add(labes[i][j],TransformerTool.GBTransformer(GBC,i,j,1,1));
commute=false;
}
else if (commute==false)
{
labes[i][j]=new JLabel();
labes[i][j].setOpaque(true);
labes[i][j].setBackground(Color.yellow);
colors[i][j]=Color.yellow;
labes[i][j].setPreferredSize(new Dimension(50,50));
table.add(labes[i][j],TransformerTool.GBTransformer(GBC,i,j,1,1));
commute=true;
}
}
else {
if(commute==false)
{
labes[i][j]=new JLabel();
labes[i][j].setOpaque(true);
labes[i][j].setBackground(Color.green);
colors[i][j]=Color.green;
labes[i][j].setPreferredSize(new Dimension(50,50));
table.add(labes[i][j],TransformerTool.GBTransformer(GBC,i,j,1,1));
commute=true;
}
else if(commute=true)
{
labes[i][j]=new JLabel();
labes[i][j].setOpaque(true);
labes[i][j].setBackground(Color.yellow);
colors[i][j]=Color.yellow;
labes[i][j].setPreferredSize(new Dimension(50,50));
table.add(labes[i][j],TransformerTool.GBTransformer(GBC,i,j,1,1));
commute=false;
}
}
}
}
table.setBounds(0,0,500,500);
container.add(table);
}
le raisonnement est assez logique , on initialise à chaque fois un nouveau Jlabel, on lui assigne une couleur , en faisant en sorte à travers une variable booléenne commute , de générer un effet de commutation ,donnant ainsi à la grille la distribution exacte en jeune et vert :
premiere ligne : jaune – vert -jaune – vert ... ect
deuxieme ligne : vert- jaune -vert- jaune ... ect
pour à la fin ajouter chaque element à la table .
Je vous laisse un peu de temps pour vous imprégner de tout ça, de toute façon j'y reviendrai sur mon prochain tuto... ;)
