Erreur due à un JLabel

Version imprimable

23/01/2015, 10h00
lednic

2 pièce(s) jointe(s)

Erreur due à un JLabel

Bonjour à tous, voila je debute en Java mais pas en programmation, je suis a la base orienté web avec html, css , php et javascript.

J'aimerai donc changer un peu d'horizon et apprendre de nouveau truc, d'où mon etude du java.

Je tente de faire une fenetre perso car je trouve celle d'origine bien degueux, tous ce passe pour le mieux (encore un bug a regler pour le cursor de redimension mais bon ca ira).

Là où j'ai un reel soucis est lorsque je tente de mettre du contenu dans la partie droite de l'ecran....

Voici un apercu :

Pièce jointe 167044
Pièce jointe 167045

Comme vous pouvez le voir lors de l'ajout d'un JLabel dans la partie de droite, cela degrade mon image, mais je ne sais pas pourquoi?
Quelqu'un a une idée??

Merci en tous cas
23/01/2015, 10h05
joel.drigo

Salut,

On a besoin du code pour se faire une idée.

Mince... j'ai oublié :p

VOici la page main qui est le point d'entrée du programme.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
package customwindow;
import customwindow.customWindow.CustomWindow;
import javax.swing.SwingUtilities;
 
/**
 *
 * @author Nicolas
 */
public class Main {
    public static void main(String[] args) {
        //Singleton.getInstance().maj();
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                CustomWindow fenetre = new CustomWindow();  
            }
        });
    }
 
}

Ensuite le code de ma CustomWindow class

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
package customwindow.customWindow;
import java.awt.Dimension;
import java.awt.Graphics;
import javax.swing.JFrame;
 
/**
 *
 * @author Nicolas
 */
public class CustomWindow extends JFrame{
    private final Dimension dimension= new Dimension(1000,600);
    private final MainPanel pannel;
    public CustomWindow(){
        pannel = MainPanel.getInstance(dimension,this);
        setTitle("Custom Window");
        setSize(dimension);
        setUndecorated(true);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
        setVisible(true);
        setContentPane(pannel);
    }
}

Ensuite le code de mon MainPanel -> qui est le contentPane

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
package customwindow.customWindow;
 
import java.awt.Color;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Toolkit;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.BorderFactory;
import javax.swing.JPanel;
 
/**
 *
 * @author Nicolas
 */
public class MainPanel extends JPanel{
    private static MainPanel instance;
    //Les differents panneau.
    private final Menu      mainMenu;
    private final Content   myContent;
    private final MainTitle Title;
    private final MenuWindow actionWindow;
    //les couleurs
    private final Color grisfonce           =   Color.decode("#222222");
    //Divers
    private final GridBagConstraints gbc    = 	new GridBagConstraints();
    private boolean candrag                 =   true;
    private String  redimension             =   "non";
    private static int     mainPanelHeight  =   600;
    private static int     mainPanelWidth   =   1000;
    //Gestion du redimensionnement
    private int minWidth                    = 800;
    private int minHeight                   = 400;
    //Constructeur
    private MainPanel(Dimension dimension,CustomWindow fenetre){
        setPreferredSize(dimension);
        mainPanelHeight =   (int) dimension.getHeight();
        mainPanelWidth  =   (int) dimension.getWidth();
        mainMenu        =   Menu.getInstance(dimension);
        myContent       =   Content.getInstance(dimension);
        Title           =   MainTitle.getInstance(new Dimension(mainPanelWidth-302,50),fenetre);
        actionWindow    =   MenuWindow.getInstance(fenetre);
        System.out.println(mainPanelHeight+"-"+mainPanelWidth);
        setLayout(new GridBagLayout());
        setBackground(grisfonce);
	gbc.gridx       =   0;
        gbc.gridy       =   0;
        gbc.gridheight  =   2;
        gbc.gridwidth   =   1;
        add(mainMenu, gbc);
        gbc.gridx       =   1;
        gbc.gridheight  =   1;
        add(Title, gbc);
        gbc.gridx       =   2;
        add(actionWindow, gbc);
        gbc.gridx       =   1;
        gbc.gridy       =   1;
        gbc.gridwidth   =   2;
        add(myContent,gbc);
 
 
 
    }
 
    @Override
 
    public void paintComponent(Graphics g){
	super.paintComponent(g); 
        Dimension dimension = new Dimension(getWidth(),getHeight());
	changeSize(dimension);
    }  
    public static MainPanel getInstance (Dimension dimension,CustomWindow fenetre){
    if (instance==null){
        instance = new MainPanel(dimension,fenetre);
    }
    return instance;
    }
    public static void changeSize(Dimension dimension){
        mainPanelHeight = (int)dimension.getHeight();
        mainPanelWidth = (int)dimension.getHeight();
	instance.setPreferredSize(dimension);
        Menu.changeSize(dimension);
        Content.changeSize(dimension);
        MainTitle.changeSize(dimension);
        System.out.println("lol"+mainPanelHeight+"-"+mainPanelWidth);
    }
}

J'ai retirer la partie listener qui ne sert a rien au probleme

Ma class Maintitle pour la partie barre de titre:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
package customwindow.customWindow;
 
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Toolkit;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
 
/**
 *
 * @author Nicolas
 */
public class MainTitle extends JPanel{
    private static MainTitle instance;
    private final Color grisfonce       =   Color.decode("#222222");
    private final JLabel LabelTitle	=   new JLabel();
    private static boolean candrag = true;
    private int dragOriginX,dragOriginY;
    private MainTitle(Dimension dimension,CustomWindow fenetre) {
        if(candrag){
		setCursor(new Cursor(Cursor.MOVE_CURSOR));
	}else{
		setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
	}
        setMinimumSize(dimension);
        setPreferredSize(dimension);
        setBackground(grisfonce);
        LabelTitle.setText("Ma premiere fenetre perso");
        LabelTitle.setBorder(new EmptyBorder(10,10,10,10));
        LabelTitle.setForeground(Color.white);
        setLayout(new BorderLayout());
        add(LabelTitle, BorderLayout.NORTH);
 
        /*-------------------------------------------------------------
	 * 
	 * GESTION DU DRAG DE LA FENETRE SUR LA BARRE TITRE
	 * 
	 -------------------------------------------------------------*/
    this.addMouseMotionListener(new MouseAdapter(){
    	 public void mouseDragged(MouseEvent e){ 
            if(candrag){
               int newX = fenetre.getLocation().x+e.getX() - dragOriginX;
               int newY = fenetre.getLocation().y+e.getY() - dragOriginY;
               fenetre.setLocation(newX,newY);
            }
    	 }
    });
    this.addMouseListener(new MouseAdapter(){
    	public void mousePressed(MouseEvent e){
    		dragOriginX=e.getX();
    		dragOriginY=e.getY();
    	}
    });
    }
    public static MainTitle getInstance (Dimension dimension,CustomWindow fenetre){
    if (instance==null){
    instance = new MainTitle(dimension,fenetre);
    }
    return instance;
    }
    public static void changeSize(Dimension dimension){
       Toolkit toolkit = Toolkit.getDefaultToolkit();
    	Dimension screenX = toolkit.getScreenSize();
      if((int)dimension.getWidth() == (int)screenX.getWidth()){
          candrag = false;
          instance.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
      }else{
          instance.setCursor(new Cursor(Cursor.MOVE_CURSOR));
          candrag = true;
      }
      instance.setMinimumSize(new Dimension((int)dimension.getWidth()-302,50));
      instance.setPreferredSize(new Dimension((int)dimension.getWidth()-302,50));
    }
}

Ma class pour mon menu principale (l'orange)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
package customwindow.customWindow;
 
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import javax.swing.BorderFactory;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
 
/**
 *
 * @author Nicolas
 */
public class Menu extends JPanel{
    private static Menu instance;
    private final Color orange      = Color.decode("#f2a809");
    private final Color grisfonce   =   Color.decode("#222222");
    JPanel pane = new JPanel();
    JLabel image = new JLabel(new ImageIcon("D:\\JavaWorkspace\\CustomWindow\\src\\images\\perso\\master.png"));
    private Menu(Dimension dimension){
        setMinimumSize(dimension);
        setPreferredSize(dimension);
        setBackground(orange);
        setBorder(BorderFactory.createLineBorder(grisfonce));
        setLayout(new BorderLayout());
        image.setPreferredSize(new Dimension(180,180));
        image.setBorder(new EmptyBorder(10,10,10,10));
        add(image, BorderLayout.NORTH);
    }
    public static Menu getInstance (Dimension dimension){
    if (instance==null){
    instance = new Menu(new Dimension(200, (int) dimension.getHeight()-2));
    }
    return instance;
    }
 
    public static void changeSize(Dimension dimension){
      instance.setMinimumSize(new Dimension(200, (int) dimension.getHeight()-2));
      instance.setPreferredSize(new Dimension(200, (int) dimension.getHeight()-2));
    }
}

La page pour le menu fenetre (fermer agrandir reduire)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
package customwindow.customWindow;
 
import java.awt.Color;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Frame;
import java.awt.Toolkit;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.BorderFactory;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
/**
 *
 * @author Nicolas
 */
public class MenuWindow extends JPanel{
    private static MenuWindow instance;
    private final JLabel LabelExit	=   new JLabel(new ImageIcon("D:\\JavaWorkspace\\CustomWindow\\src\\images\\icon_exit.png"));
    private static  JLabel LabelMaximize =   new JLabel(new ImageIcon("D:\\JavaWorkspace\\CustomWindow\\src\\images\\icon_maximize.png"));
    private final JLabel LabelMinimize 	=   new JLabel(new ImageIcon("D:\\JavaWorkspace\\CustomWindow\\src\\images\\icon_minimize.png"));
    private final Color grisfonce       =   Color.decode("#222222");
 
 
    private MenuWindow(CustomWindow fenetre){
        setPreferredSize(new Dimension(100,50));
        setMinimumSize(new Dimension(100,50));
        setBackground(grisfonce);
 
	LabelExit.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
        LabelExit.setCursor(new Cursor(Cursor.HAND_CURSOR));
 
	LabelMaximize.setCursor(new Cursor(Cursor.HAND_CURSOR));
	LabelMaximize.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
 
	LabelMinimize.setCursor(new Cursor(Cursor.HAND_CURSOR));
	LabelMinimize.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
 
	add(LabelMinimize);
	add(LabelMaximize);
	add(LabelExit);
 
 
    }
    public static MenuWindow getInstance (CustomWindow fenetre){
    if (instance==null){
        instance = new MenuWindow(fenetre);
    }
    return instance;
    }
}

'ai retire la partie listener ici aussi

Reste plus que la partie Content (qui contient le contenu de l'app)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
package customwindow.customWindow;
 
import java.awt.Color;
import java.awt.Dimension;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
/**
 *
 * @author Nicolas
 */
public class Content extends JPanel{
    private final Color grisfonce   =   Color.decode("#222222");
    private static Content instance;
    private Content(Dimension dimension) {
        setMinimumSize(dimension);
        setPreferredSize(dimension);
        setBackground(grisfonce);
    }
    public static Content getInstance (Dimension dimension){
    if (instance==null){
    instance = new Content(new Dimension((int)dimension.getWidth()-200, (int) dimension.getHeight()-52));
    }
    return instance;
    }
    public static void changeSize(Dimension dimension){
      instance.setMinimumSize(new Dimension((int)dimension.getWidth()-200, (int) dimension.getHeight()-52));
      instance.setPreferredSize(new Dimension((int)dimension.getWidth()-200, (int) dimension.getHeight()-52));
    }
 
}

Voila merci

23/01/2015, 10h33
joel.drigo

Ça fait beaucoup de code à analyser, je regarderai en détail plus tard, quand j'aurai le temps. Mais j'ai regardé vite fait et je vois que tu redimensionnes tes composants à partir des méthodes paint() : pour rédimensionner des composants en réaction de redimensionnment d'autres composants, tu devrais plutôt utiliser ComponentAdapter (méthode componentResized()), parce que là tu redimensionnes des composants en cours de (re)dessin : ça risque forcément d'avoir des effets de bord sur l'affichage.

OK merci!
Tu parles de la methode paintComponent(); que je devrais remplacer par quoi???

Dois je la redefinir dans chaque class extends du JPanel?

encore merci!

Edit:
En modifiant ce code :
Code:

1 2 3 4 5 public void paintComponent(Graphics g){ super.paintComponent(g); Dimension dimension = new Dimension(getWidth(),getHeight()); changeSize(dimension); }
par ce code
Code:

1 2 3 4 5 public void componentResized(Graphics g){ Dimension dimension = new Dimension(getWidth(),getHeight()); changeSize(dimension); }
Alors je n'ai que ma MAINPANEL qui se modifie.. les autres composants non...

Normalement, on ne devrait pas avoir à redimensionner soi-même les composants : on confie le dimensionnement, et le placement, à des LayoutManager, et on applique des contraintes (par setPreferredSize(), setMinimumSize() et setMaximumSize()) qui seront exploitées par les LayoutManager. Si on veut contrôler soi-même le dimensionnement, sans LayoutManager, le mieux est d'enregistrer (par addComponentListener()) un écouteur de type ComponentListener (dont ComponentAdapter est une implémentation par défaut, qui ne fait rien, et qui permet de n'implémenter que les méthodes de ComponentListener qu'on a besoin de modifier). Lorsque la taille d'un composant est modifié, la méthode componentResized() du listener (ou des listeners, parce qu'on peut en enregistrer plusieurs) est invoquée : dans cette méthode, on répercute les modifications de taille des composants fils, qui eux-même, donc, vont déclencher l'évenement de redimensionnement, qu'on interceptera dans leur propre ComponentListener,.componentResized(), et donc on pourra redimensionner leurs fils, et ainsi de suite.

Exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 public class DemoComponentResized { public static void main(String[] args) { SwingUtilities.invokeLater( () -> new DemoComponentResized() ); } public DemoComponentResized() { JFrame frame = new JFrame("Exemple"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.getContentPane().add( createPanel() ); frame.setSize(100, 100); frame.setLocationRelativeTo(null); frame.setVisible(true); } private Component createPanel() { JPanel panel = new JPanel(); panel.setLayout(null); // on supprime le LayoutManager, pour gérer soi-même les dimensionnements JPanel subPanel = new JPanel(); subPanel.setBackground(Color.RED); panel.add(subPanel); panel.addComponentListener(new ComponentAdapter() { @Override public void componentResized(ComponentEvent e) { int componentWidth = e.getComponent().getWidth(); int componentHeight = e.getComponent().getHeight(); int subPanelWidth = componentWidth/3; // largeur égale tiers de la largeur du parent int subPanelHeight = 50; // hauteur fixe int x = (componentWidth - subPanelWidth ) / 2; // centrage int y = (componentHeight/3) - subPanelHeight / 2; // centrage au tiers de la hauteur if ( y<0 ) { // si le composant dépasse en haut y=0; // on le force au bord haut } if ( y + subPanelHeight > componentHeight ) { // si le composant dépasse en bas subPanelHeight = 0; // le composant disparait } subPanel.setBounds(x, y,subPanelWidth, subPanelHeight); // on applique les dimensions calculées } }); return panel; } }

1 pièce(s) jointe(s)

VOila en gros l'architecture de mon design:

Pièce jointe 167060

Pour se faire j'ai utilisé le gridbagLayout :

Menu x,y : 0 tailleHeight :2
Title x,y=1,0 tailleHeight:1
Zoneferme x,y=2,0
contenu x,y=1,1 tailleWidth: 2

Voila en gros...

Comment je fais alors pour une fois que mon contentpane se redimensionne, le reste (menu,title,zoneferme,contenu etc) soit mis a jours??

Edit ok j'ai tenté une autre approche avec le borderlayout:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
/*Partie de droite contentu la zone titre, zone action (fermer, reduire, etc) ainsi que le contenu de l'app*/
        ContentAndTitle.setBackground(grisfonce);
        ContentAndTitle.setLayout(new BorderLayout());
 
        TitleAndClose.setPreferredSize(new Dimension(ContentAndTitle.getWidth(),50));
        TitleAndClose.setLayout(new BorderLayout());
        TitleAndClose.add(Title,BorderLayout.CENTER);
        TitleAndClose.add(actionWindow,BorderLayout.EAST);
 
        ContentAndTitle.add(TitleAndClose,BorderLayout.NORTH);
        ContentAndTitle.add(myContent,BorderLayout.CENTER);
        setBackground(grisfonce);
        setBorder(BorderFactory.createLineBorder(grisfonce));
        setLayout(new BorderLayout());
        add(mainMenu, BorderLayout.WEST);
        add(ContentAndTitle, BorderLayout.CENTER);
        /*
        setLayout(new GridBagLayout());
        setBackground(grisfonce);
	gbc.gridx       =   0;
        gbc.gridy       =   0;
        gbc.gridheight  =   2;
        gbc.gridwidth   =   1;
        add(mainMenu, gbc);
        gbc.gridx       =   1;
        gbc.gridheight  =   1;
        add(Title, gbc);
        gbc.gridx       =   2;
        add(actionWindow, gbc);
        gbc.gridx       =   1;
        gbc.gridy       =   1;
        gbc.gridwidth   =   2;
        add(myContent,gbc);
        
        */

En commentaire c'est l'ancienne version.

23/01/2015, 13h19
joel.drigo

Si ton but est de modifier l'apparence de l'interface graphique, parce qu'elle ne te plait pas, tu peux changer le Look And Feel, voire même faire ton propre Look And Feel (mais c'est beaucoup de travail, éventuellement étendre un Look And Feel existant peut faire gagner du temps). Changer le thème du Look And Feel peut être une solution également, beaucoup plus simple. Ensuite, il suffit de faire confiance à SWING et d'utiliser les LayoutManager adaptés à la présentation que tu veux : c'est le plus simple.

Maintenant, si tu veux tout redéfinir à la main, tu fais comme dans mon exemple (s'il y a d'autres composants dans subPanel, tu enregistres un componentListener() sur subPanel, sur le même mode que celui mis sur panel).

Pour le bug particulier de ton code, je regarderai quand j'aurai le temps.
23/01/2015, 14h50
lednic

1 pièce(s) jointe(s)

Ok,
J'aime tester, je trouve que c'est comme ca qu'on apprend le mieux...
Ma fenetre commence a etre top, elle gere tous les aspects d'une fenetre standard :)

J'ai remarqué ceci:

Pièce jointe 167070

Comme tu peux voir, l'image du dessus foire, celle du dessous non !!

Mes boutons aussi font une tronche bizarre...

merci pour ton aide et ta patience
23/01/2015, 18h00
joel.drigo
J'ai testé ton programme et je ne constate pas de problème d'affichage de l'image sur mon environnement. C'est typique d'un code SWING qui n'est pas fait tout à fait comme il faudrait : ça semble fonctionner (ça donne le résultat escompté à l'écran), mais ça "tombe en marche", à cause surtout de code redondant, et dans certains cas aléatoires ça ne fonctionne pas, ou mal, selon l'environnement/os, ou dès qu'on va ajouter le truc qui va faire que quelque chose va foirer, et qu'on ne pourra pas faire fonctionner (parce que les raisons résultent de la combinaison de mauvais choix).
1. Utiliser des singletons pour des composants graphiques rend peut-être plus pratiques certaines manipulations, mais à terme, ça t'empechera un certain nombre de choses (comme, par exemple, avoir plusieurs fenêtres), tu auras un modèle objet peu souple à évoluer, sans parler des risques d'accumulation d'instances inutiles en mémoire ;
2. Mélanger du layouting et des appels explicites pour modifier les preferredSize complique inutilement le code (en augmentant son volume inutilement), provoque des effets disgracieux (dus au fait que du code s'exécute inutilement, ce qui prend du temps, ce qui nuit à la fluidité), mais qu'on ne voit pas pour l'instant (en particulier parce que ton interface est hyper simplifiée : peu de composants, des composants simples (label et panel)...),
3. Au final, tu crois apprendre parce que visuellement ça correspond à ce que tu attends en l'état, mais tu n'apprends pas les bonnes pratiques et les bons réflexes (rendre visible un composant quand il est prêt - je parle de la JFrame affichée avant d'y mettre son contenu), parce que ton code redondant pallie certains dysfonctionnements, courants lorsqu'on fait des UI SWING (ou autre d'ailleurs), mais qui finiront par t'arriver (comme le fait qu'il n'y ait pas besoin de revalidate() dans ton code, fait que tu ne peux pas prendre le réflexe de le faire quand c'est nécessaire). En plus, apprendre, c'est aussi comprendre : là, tu n'auras qu'une vision déformée des concepts de SWING.
Accessoirement, je comprends que, pour un TP, ou un POC, on fasse un accès direct à des ressources par chemin absolu, mais c'est un peu dans la même veine que le reste : au final, ça posera des problèmes (tu ne sauras pas déployer par exemple), alors que prendre le réflexe d’accéder par résolution d'URL à des ressources dans le classpath ne demande pas beaucoup plus de travail (on peut se faire rapidement une classe utilitaire pour le gérer aussi simplement que des paths absolus), et il plus facile de prendre ce genre d'habitude au début, que de changer d'habitude ensuite.
23/01/2015, 18h29
lednic

Ok ceci n était qu un test je compte par la suite me mettre au mvc avant de vraiment développer une applications donc je suppose que je ferais un controler pour récupérer les images etc par contre tu le ferais comment toi alors jje veux dire sans singletons etc ... qu est ce qui est redondant etc
23/01/2015, 18h52
lednic

1 pièce(s) jointe(s)

A savoir que le code je l'ai deja changé mais y a toujours des erreurs( sur les affichages)
Je t'ai joins un dossier .rar pour t'eviter de copier coller...

Pour répondre a tes points afin d’évoluer :

1.Comment ferais-tu d'autre notamment pour modifier le content du panel "content", ou encore pour pouvoir deplacer la fenetre comme je le fais via le maintitle.
2. J'ai pas tous saisis.. :p
3.J'aimerai ravoir ton avis une fois que tu auras vu le nouveau code :)

Encore merci!
23/01/2015, 18h55
joel.drigo

Citation:

Envoyé par lednic

ferais comment toi alors jje veux dire sans singletons etc ... qu est ce qui est redondant etc

Le système évènementiel est justement là pour faire communiquer les composants entre eux, sans qu'ils aient directement besoin d'une référence de l'un sur l'autre, ou une référence à un singleton (qui correspond à une forme de référence globale). Il y a des évenements d'UI, mais également de changement de propriétés (regarde la classe SwingPropertyChangeSupport, avec un exemple dans le code de AbstractAction). Et si tu prévois de faire une vue complexe composées de plusieurs composants, avec un contrôleur unique commun, il peut servir à concentrer et de dispatcher les évènements des uns vers les autres. Il suffit alors que le processus de construction puisse faire le binding entre les différentes variables du modèles et les composants. Essaye par exemple, de faire ça d'abord sur un composant constitué de 2 JButtons : lorsque l'un est enabled l'autre est disabled. Chaque fois que tu cliques sur un bouton, il devient disabled (donc l'autre devient enabled). Le modèle n'a qu'un seul état : qui dit quel bouton est enabled. Le clic sur un bouton change donc cet état, ce qui provoque un évenement, et l'autre bouton réagit.
23/01/2015, 19h37
joel.drigo

Je l'ai déjà dit : si j'avais à faire un système personnalisé comme le tiens, je passerais par les Look And Feel, thèmes de Look And Feel, et le système de LayoutManager, quitte à me faire mes propres LayoutManager au besoin (ce que je fais au boulot mais en SWT, mais les principes sont les même LNF, thèmes et LayoutManager).

Je regarderai ton nouveau code quand j'aurais le temps.

Je m'aperçois que je ne t'ai pas répondu à ta question sur ce que je considérais comme redondant : je considère que modifier les dimensions des composants en parallèle de ce que fait déjà les LayoutManager est redondant. Normalement, les contraintes et le bon LayoutManager doit permettre à ce que les composants soient toujours correctement placés et dimensionnés, sans méthodes supplémentaires.
23/01/2015, 20h23
lednic

Alors le côté redondant à été réglé par contre toujours le même soucis :'(
24/01/2015, 03h01
tchize_

Alors, sans allez voir dans le code car il est trop long, typiquement en swing, le fait d'avoir un composant "corrompu" c'est quand un composant fait n'importe quoi avec un Graphics dans sa méthode de paint. Dans le n'importe quoi typique:

le composant est opaque, mais on oublie de redessiner le background via un appel à super.paintComponent()
on tripatouille l'objet Graphics directement au niveau de ses boundary / affineTransform, au lieu de faire ça sur une copie. Pour raisons de performanes, le Graphics que tu reçois dans paintComponent est partagé par tous les composant, donc éviter de faire le con avec
on écrit en dehors de sa zone réservée dans le Graphics, du coup on écrit sur un autre Component. Cas typique quand on calcule mal les dimension du composant.
Pour les bouts de code que j'ai vu, tu mélange du dessin est du redimenssionement. C'est mal, très mal. Au moment où tu dessine, rien ne dois bouger sur l'interface. Swing travaille dans une sorte de cycle: on met à jour les contenus / postion des composants, on redessine, on recommence.
Autre erreur typique, appeler component.getGraphics() dans le code. Ne touche jamais à ça, c'est réservé à swing.
24/01/2015, 13h03
joel.drigo

J'ai regardé ton code. Tu as juste déplacé le code qui était fait dans la méthode changeSize() directement dans la méthode paintComponent. Ça change rien et ça continue de modifier les contraintes dimensionnelles dans paintComponent(), donc ça déclenche le layouting pendant qu'on dessine, d'où résultat foireux. En plus, j'ai vu qu'il manque des super.paintComponent() dans certaines rediffinitions (voir la remarque de @Tchize_ à ce sujet).

Sinon updateUI() ne sert pas à informer que tu as changé le contenu d'un conteneur, mais à informer que tu as changé quelque chose qui concerne le LaF. Quand on change le contenu d'un conteneur, on fait un revalidate(), et un repaint(), ce qui informe SWING et lui laisse faire le boulot qu'il sait qu'il a à faire.

Pour les images, comme elles sont (heureusement) dans les sources, tu peux faire, au lieu de :

Code:

new JLabel(new ImageIcon("D:\\JavaWorkspace\\CustomWindow\\src\\images\\perso\\master.png"));

Code:

new JLabel(new ImageIcon(getClass().getResource("/images/perso/master.png"));