Faire un planning avec JTable

Version imprimable

04/03/2015, 19h20
totot

Faire un planning avec JTable

Bonjour,

Je chercher à faire un planning avec JTable.
En effet, je souhaiterais afficher les jours d'une semaine et pour voir changer de semaine en affichant les numéros des semaines en bas dans une scrollBar.

JE ne vois pas comment faire.

Pouvez-vous m'aider ou me donner des exemples de codes.

Merci d'avance

2 pièce(s) jointe(s)

Salut,

Une scrollbar pour afficher les fenêtres : ça va pas être simple à mon avis. Un JSlider peut-être, ou tout simplement une ligne de JLabel, sans un JScrollPane éventuellement.

Pour le JSlider, ça donnerait ça, par exemple :

Pièce jointe 170829
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 JSlider slider = new JSlider(); slider.setMinimum(1); slider.setMaximum(52); // 53 slider.setMajorTickSpacing(4); slider.setMinorTickSpacing(1); Hashtable<Integer, JLabel> labels = new Hashtable<Integer, JLabel>(); for(int i=1;i<52; i+=4) { labels.put(i, new JLabel(String.valueOf(i))); } labels.put(52, new JLabel("52")); slider.setLabelTable(labels); slider.setPaintLabels(true); slider.setPaintTicks(true); slider.setPaintTrack(true); slider.setSnapToTicks(true);
Pour les labels, par exemple :

Pièce jointe 170832
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 Color color = new Color(111,199,227); JPanel weeks = new JPanel(); weeks.setLayout(new GridLayout(1, 0)); for(int i=1; i<=52; i++) { JLabel label = new JLabel(String.valueOf(i), JLabel.CENTER); label.setBorder(BorderFactory.createEmptyBorder(0,5,0,5)); label.setOpaque(true); if ( i%2==0 ) { label.setBackground(Color.WHITE); } else { label.setBackground(color); } label.setEnabled(true); label.addMouseListener(new MouseAdapter() { @Override public void mouseClicked(MouseEvent e) { // selection d'une semaine } }); weeks.add(label); } JScrollPane slider = new JScrollPane(weeks, JScrollPane.VERTICAL_SCROLLBAR_NEVER, JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
Pour la JTable, ça dépend un peu de la présentation. A part une JTable avec 7 lignes (une par jour, et encore, il y a des semaines de moins de jours, tout dépend ce qu'on appelle semaine d'ailleurs) et combien de colonnes (un nombre fixe, dynamique ?). Enfin, c'est un peu du standard : tu trouveras des centaines d'exemples sur le net, et en particulier dans les tutoriels Developpez, comme celui-là, par exemple.

04/03/2015, 21h29
totot

Je voudrais une JTable avec 7 colonnes pour les jours de la semaine et 2 ligne pour matin et après midi
04/03/2015, 22h19
totot

Ce que je cherche donc c'est associer un JTable et un JCalendar
04/03/2015, 23h18
totot

1 pièce(s) jointe(s)

J'ai trouvé ce code mais je vois pas comment l'adapter:
https://students.cs.byu.edu/~cs240ta...darViewer.java

Pièce jointe 170841
05/03/2015, 15h26
totot

Personne peut m'aider?
Cela fait deux semaine que je galère desus
05/03/2015, 15h36
joel.drigo

T'aider à quoi : tu as un source, il ne reste qu'à le lire, à l'adapter (là où y a un mois de 28, 30 ou 31 jours), il y a une semaine de 7 jours. Si tu as des questions précises sur un truc que tu ne comprends pas ou que tu n'arrives pas à faire fonctionner, dis-le et on t'aidera surement.
05/03/2015, 15h43
totot

Je Chercher à faire une basse comme la seconde que tu m'a mi sauf que je souhaite afficher dans chaque label cliquable bien sur pour pouvoir changer de semaine à afficher par exemple : 23 - 29 mars (13)

Donc juste changer le label : à partir d'un numéro de semaine, obtenir la date du premier jour et du dernier, formatée.

Exemples en Java7 et Java8 :

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
public class WeekDate {
 
	public static void main(String[] args) {
		System.out.println(toLabelJ7(13, 2015));
		System.out.println(toLabelJ8(13, 2015));
	}
 
 
 
	private final static DateTimeFormatter LOCAL_DATE_DEBUT_FORMAT = DateTimeFormatter.ofPattern("dd");
	private final static DateTimeFormatter LOCAL_DATE_FORMAT = DateTimeFormatter.ofPattern("dd MMMM");
 
	private static String toLabelJ8(int week, int year) {
 
		LocalDate date = Year.of(year).atDay(1);
 
		date = date.plusWeeks(week - 1).with(DayOfWeek.MONDAY);
 
		LocalDate premierJour = date;
 
		LocalDate dernierJour = date.plusDays(6);
 
		String debut;
		if (premierJour.getMonth().equals(dernierJour.getMonth()) ) {
			debut = LOCAL_DATE_DEBUT_FORMAT.format(premierJour);
		} else {
			debut = LOCAL_DATE_FORMAT.format(premierJour);
		}
 
		String milieu = dernierJour.format(DateTimeFormatter.ofPattern("dd MMMM"));
 
		String fin = " (" + week + ")";
 
		return debut + " - " + milieu + fin;
 
	} 
 
	private final static DateFormat DATE_DEBUT_FORMAT = new SimpleDateFormat(
			"dd");
	private final static DateFormat DATE_FORMAT = new SimpleDateFormat(
			"dd MMMM");
 
	public static String toLabelJ7(int week, int year) {
 
		Calendar calendar = Calendar.getInstance();
		calendar.clear();
		calendar.set(Calendar.WEEK_OF_YEAR, week);
		calendar.set(Calendar.YEAR, year);
 
		Date premierJour = calendar.getTime();
		int monthPremierJour = calendar.get(Calendar.MONTH);
 
		calendar.add(Calendar.DATE, 6);
 
		Date dernierJour = calendar.getTime();
 
		int monthDernierJour = calendar.get(Calendar.MONTH);
 
		String debut;
		if (monthDernierJour == monthPremierJour) {
			debut = DATE_DEBUT_FORMAT.format(premierJour);
		} else {
			debut = DATE_FORMAT.format(premierJour);
		}
 
		String milieu = DATE_FORMAT.format(dernierJour);
 
		String fin = " (" + week + ")";
 
		return debut + " - " + milieu + fin;
 
	}
 
 
}

05/03/2015, 20h13
totot

Je suis complètement perdu!!!
J'arrive pas du tout à faire ce que je veux
05/03/2015, 20h16
joel.drigo

Si tu nous dis pas ou çà coince, je ne vois pas comment on pourrait t'aider.

1 pièce(s) jointe(s)

Voici mon code:

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
public class CalendarWeekTableModel     extends AbstractTableModel {
 
    private String[] dayNames;
    private Calendar calendar;
 
    public CalendarWeekTableModel(Calendar calendar) {
    	this.calendar = calendar;
        dayNames = getDayNames();
    }
 
    public int getColumnCount() {
    	// ramene les 7 jours de la semaine
        return 7;
    }
 
    public int getRowCount() {
    	// ramene le nombre de ligne
    	// nombre de demi journée 
    	return 2;
    }
 
    public String getColumnName(int col) {
        return dayNames[col];
    }
 
    public Object getValueAt(int row, int col) {
        int dayOfMonth = row * 7 + col - getFirstDayOfWeek() + 2;
        if (dayOfMonth < 1 || dayOfMonth > getLastDayOfMonth()) {
            return "";
        }
        else {
            return new Integer(dayOfMonth).toString();
        }
    }
 
    public boolean isCellEditable(int row, int col) {
        return true;
    }
 
    public void setValueAt(Object value, int row, int col) {
 
    }
 
    private String[] getDayNames() {
        String[] dayNames = new String[7];
        SimpleDateFormat fmt = new SimpleDateFormat("EEEE");
        Calendar cal = Calendar.getInstance();
 
        cal.set(Calendar.DAY_OF_MONTH, 1);
 
        for (int i=0; i < 7; ++i) {
            cal.set(Calendar.DAY_OF_MONTH, cal.get(Calendar.DAY_OF_MONTH) + 1);
            dayNames[i] = fmt.format(cal.getTime());
        }
 
        return dayNames;
    }
 
    private int getFirstDayOfWeek() {
        return calendar.get(Calendar.DAY_OF_WEEK);
    }
 
    private int getLastDayOfMonth() {
        return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
    }
}

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
92
93
94
95
96
97
98
99
100
101
102
103
104
public class CalendarWeekViewer extends JFrame implements ActionListener {
 
    Calendar calendar;
    DateFormat dateFormatter;
 
    CalendarWeekTableModel tableModel;
 
    JLabel monthLabel;
    JTable table;
    JButton prevButton;
    JButton nextButton;
 
 
    public CalendarWeekViewer() {
        super("Calendar Viewer");
 
        calendar = Calendar.getInstance();
        calendar.set(Calendar.DAY_OF_MONTH, 0);
 
        dateFormatter = new SimpleDateFormat("MMMM yyyy");
 
        createComponents();
    }
 
    private void createComponents() {
        addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
 
        monthLabel = new JLabel(dateFormatter.format(calendar.getTime()));
        monthLabel.setFont(new Font(null, Font.PLAIN, 36));
        monthLabel.setVerticalAlignment(JLabel.CENTER);
        monthLabel.setHorizontalAlignment(JLabel.CENTER);
 
        tableModel = new CalendarWeekTableModel(calendar);
        table = new JTable((TableModel)tableModel);
        table.setPreferredScrollableViewportSize(new Dimension(700, 600));
        table.setDefaultRenderer(String.class, new CalendarDayRenderer());
        table.setRowHeight(200);
        TableColumnModel tableColumnModel = table.getColumnModel();
        for (int i=0; i < tableColumnModel.getColumnCount(); ++i) {
            TableColumn tableColumn = tableColumnModel.getColumn(i);
            tableColumn.setPreferredWidth(200);
        }
 
        JScrollPane tableScrollPane = new JScrollPane(table);
 
        prevButton = new JButton("<<");
        prevButton.addActionListener(this);
 
        nextButton = new JButton(">>");
        nextButton.addActionListener(this);
 
        JPanel btnPanel = new JPanel();
        btnPanel.add(prevButton);
        btnPanel.add(nextButton);
 
        getContentPane().add(monthLabel, BorderLayout.NORTH);
        getContentPane().add(tableScrollPane, BorderLayout.CENTER);
        getContentPane().add(btnPanel, BorderLayout.SOUTH);
    }
 
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == prevButton) {
            int curMonth = calendar.get(Calendar.MONTH);
            if (curMonth == Calendar.JANUARY) {
                int curYear = calendar.get(Calendar.YEAR);
                calendar.set(Calendar.YEAR, curYear - 1);
                calendar.set(Calendar.MONTH, Calendar.DECEMBER);
            }
            else {
                calendar.set(Calendar.MONTH, curMonth - 1);
            }
            monthLabel.setText(dateFormatter.format(calendar.getTime()));
            tableModel.fireTableDataChanged();
        }
        else if (e.getSource() == nextButton) {
            int curMonth = calendar.get(Calendar.MONTH);
            if (curMonth == Calendar.DECEMBER) {
                int curYear = calendar.get(Calendar.YEAR);
                calendar.set(Calendar.YEAR, curYear + 1);
                calendar.set(Calendar.MONTH, Calendar.JANUARY);
            }
            else {
                calendar.set(Calendar.MONTH, curMonth + 1);
            }
            monthLabel.setText(dateFormatter.format(calendar.getTime()));
            tableModel.fireTableDataChanged();
        }
    }
 
    public static void main(String[] args) {
 
		EventQueue.invokeLater(new Runnable() {
			public void run() {
		        CalendarWeekViewer frame = new CalendarWeekViewer();
		        frame.pack();
		        frame.setVisible(true);
			}
		});
    }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class CalendarWeekRenderer extends JLabel implements TableCellRenderer {
 
    public CalendarWeekRenderer() {
        super();
        setFont(new Font(null, Font.PLAIN, 28));
        setVerticalAlignment(JLabel.TOP);
        setHorizontalAlignment(JLabel.LEFT);
        setOpaque(true);
    }
 
    public Component getTableCellRendererComponent(JTable table, Object value,
                                                    boolean isSelected, boolean hasFocus,
                                                    int row, int column) {
        setText((String)value);
        return this;
    }
}

Pièce jointe 170934

Je n'arrive pas à mette ta basse. Et lorsque que je clique sur les flèches, sa passe directement au mois suivants. Je pense qu'il faut remplacer MONTH par WEEK mais je n'y arrive pas.

Le programme que tu as pris étaient prévu pour afficher des mois : maintenant tu dois afficher des semaines.

Premièrement, il faut donc changer la valeur qui est mise dans le Calendar au démarrage : déjà choisir une semaine, mettons la première de l'année en cours. Il suffit de changer le constructeur :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public CalendarWeekViewer() {
        super("Calendar Viewer");
 
        calendar = Calendar.getInstance();
 
        //calendar.set(Calendar.DAY_OF_MONTH, 0); // ça c'est ce qu'il y avait avant : on commençait au mois courant, et on choisissait le premier jour de ce mois
 
        calendar.set(Calendar.WEEK_OF_YEAR,calendar.getMinimum(Calendar.WEEK_OF_YEAR)); // on se positionne sur la première semaine de l'année
                calendar.set(Calendar.DAY_OF_WEEK,calendar.getMinimum(Calendar.DAY_OF_WEEK)); // on se positionne sur le premier jour de la semaine
 
 
        dateFormatter = new SimpleDateFormat("MMMM yyyy");
 
        createComponents();
    }

Ensuite le libellé en haut affiche le nom du mois : ce serait mieux d'afficher le nom de la semaine n'est-ce-pas ? Le label qui affiche cette information est monthLabel(je te laisse faire le ménage et donner le bon nom aux variables). On ne peut plus utiliser un simple formatter de date comme c'était avant : on a utiliser la méthode que je t'ai donné pour avoir le rendu que tu voulais, qu'on va mettre dans une méthode (je l'ai un peu changée) :

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
private String getWeekLabel() {
 
	    	Calendar calendar = Calendar.getInstance(); // on créé un nouveau calendar pour pas modifier le calendar qui nous sert pour savoir quelle semaine on affiche
	    	calendar.setTime(this.calendar.getTime()); // on recopie dedans la date actuellement mise dans le calendar qui ser pour savoir quelle semaine on affiche
 
	    	int week = calendar.get(Calendar.WEEK_OF_YEAR); // on récupère le numéro de la semaine
 
                // le premier jour de cette semaine
	    	Date premierJour = calendar.getTime();
		int monthPremierJour = calendar.get(Calendar.MONTH);
 
	        // le dernier jour de cette semaine
		calendar.add(Calendar.WEEK_OF_YEAR, 1);
		calendar.add(Calendar.DAY_OF_WEEK, -1);
		Date dernierJour = calendar.getTime();
 
		int monthDernierJour = calendar.get(Calendar.MONTH);
 
		String debut;
		if (monthDernierJour == monthPremierJour) {
			debut = DATE_DEBUT_FORMAT.format(premierJour);
		} else {
			debut = DATE_FORMAT.format(premierJour);
		}
 
		String milieu = DATE_FORMAT.format(dernierJour);
 
		String fin = " (" + week + ")";
 
		return debut + " - " + milieu + fin; 
}

Ensuite il suffit de remplacer :

Code:

1
2
3
 
 //monthLabel = new JLabel(dateFormatter.format(calendar.getTime()));
 monthLabel = new JLabel(getWeekLabel());

Les boutons sont prévus pour incrémenter ou décrémenter les mois à l'origine (on verra plus tard pour mettre la barre de semaine que je t'avais indiquée) : tu dois modifier ces boutons pour modifier la numéro de semaine. L'action qui est faite sur ces boutons est dans la méthode actionPerformed :

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
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == prevButton) {
    		calendar.add(Calendar.WEEK_OF_YEAR, -1); // on décrémente
    		enabledButtons();
 
            monthLabel.setText(getWeekLabel());
        	tableModel.fireTableDataChanged(); 
        }
        else if (e.getSource() == nextButton) {
    		calendar.add(Calendar.WEEK_OF_YEAR, 1); // on incrémente
    		enabledButtons();
 
            monthLabel.setText(getWeekLabel());
        	tableModel.fireTableDataChanged(); 
        }
    } 
 
    // cette méthode permet d'empêcher les boutons de changer d'année
    private void enabledButtons() {
    	int curWeek = calendar.get(Calendar.WEEK_OF_YEAR);
		boolean previousEnabled=true;
		boolean nextEnabled=true;
		if ( curWeek==calendar.getMinimum(Calendar.WEEK_OF_YEAR) ) {
			previousEnabled=false;
    	}
		if ( curWeek==calendar.getMaximum(Calendar.WEEK_OF_YEAR) ) {
			nextEnabled=false;
    	}
		prevButton.setEnabled(previousEnabled);
		nextButton.setEnabled(nextEnabled);
    }

Pour rendre cohérent les boutons dès le départ, en ajoutant juste après leur création l'appel de la méthode enabledButtons() :

Code:

1
2
3
4
JPanel btnPanel = new JPanel();
btnPanel.add(prevButton);
btnPanel.add(nextButton);
enabledButtons();

[EDIT]Maintenant supposons qu'on veuille que les titres des colonnes soit variables en fonction de la semaine. On va modifier le modèle pour rendre les noms des jours dynamiques. On va en profiter pour refaire la méthode de détermination des jours un peu moins bidouille :

Premièrement, on remplace la méthode getDayNames() :

Code:

1
2
3
4
5
6
private String getDayName(int day) {
    	Calendar calendarDay = Calendar.getInstance();
    	calendarDay.setTime(calendar.getTime());
		calendarDay.add(Calendar.DATE, day);
		return calendar.getDisplayName(Calendar.DAY_OF_WEEK, Calendar.LONG_FORMAT, Locale.getDefault())+" "+calendarDay.get(Calendar.DATE);
}

On supprime le tableau en variable :

Code:

1
2
3
4
5
6
7
 //private String[] dayNames;
    private Calendar calendar;
 
    public CalendarWeekTableModel(Calendar calendar) {
    	this.calendar = calendar;
        //dayNames = getDayNames();
    }

Et on fait pointer la méthode qui détermine le nom d'une colonne :

Code:

1
2
3
    public String getColumnName(int col) {
        return getDayName(col);
    }

Ensuite, il faut indiquer qu'on ne change pas que les données à chaque changement de semaine, mais aussi la structure de la table : on va faire fireTableStructureChanged() au lieu de fireTableDataChanged() quand on incrémente ou décrémente le numéro de semaine, dans actionPerformed

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == prevButton) {
    		calendar.add(Calendar.WEEK_OF_YEAR, -1); // on décrémente
    		enabledButtons();
 
            monthLabel.setText(getWeekLabel());
        	//tableModel.fireTableDataChanged(); 
        	tableModel.fireTableStructureChanged(); 
        }
        else if (e.getSource() == nextButton) {
    		calendar.add(Calendar.WEEK_OF_YEAR, 1); // on incrémente
    		enabledButtons();
 
            monthLabel.setText(getWeekLabel());
        	//tableModel.fireTableDataChanged(); 
        	tableModel.fireTableStructureChanged(); 
        }
    }

Et maintenant, la suite : le panel du bas.

On va en faire un composant : on reprend le code que je t'ai donné et on fait une classe qui étend JPanel et qui le contient. Pour l'intégrer, il faut pouvoir l'interfacer avec le CalendarWeekViewer et l'instance de Calendar qui s'y trouve. On va donc les passer aux contructeurs du composant.

On en profite pour factoriser un peu : mettre les couleurs en constantes pour pouvoir les modifier rapidement (à défaut d'en faire des paramètres, ce qu'on pourrait faire).

Ensuite on a besoin :

de savoir quelle semaine est sélecitonnée : j'ai ajouté une variable selection
de pouvoir facilement retrouve un label de semaine : j'ai ajouté un tableau qui les stocke
de pouvoir rafraichir le composant
- d'afficher la semaine sélectionnée, ce que je fais dans une couleur spéciale
- de pouvoir automatiquement rafraichir le panel en fonction de la semaine sélectionnée si elle est sélectionnée par les autres boutons, ce que je fais par la méthode updateSelection(), avec appel de scrollToRectVisible pour qu'on voit le label la semaine sélectionnée
d'afficher les semaines du calendar et non plus une liste arbitraire de 1 à 52 (ou 53), donc récupérer cette liste à partir du calendar
d'afficher les labels qu'on veut (la j'ai pris les mêmes que pour le semainier (le getWeekLabel())

Donc voici la classe :

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
public class WeekPanel extends JPanel {
 
	private final static Color COLOR_EVEN = new Color(111, 199, 227);
	private final static Color COLOR_ODD = Color.WHITE;
	private final static Color COLOR_SELECTION = Color.YELLOW;
 
	private final Calendar calendar;
	private JLabel[] labels;
	private int selection;
	private CalendarWeekViewer viewer;
	private JPanel weekPanel;
 
	public WeekPanel(CalendarWeekViewer viewer, Calendar calendar) {
		this.viewer=viewer;
		this.calendar = calendar;
 
		selection = calendar.get(Calendar.WEEK_OF_YEAR);
 
		setLayout(new BorderLayout());
 
		int premiereSemaine = calendar.getMinimum(Calendar.WEEK_OF_YEAR);
		int derniereSemaine = calendar.getMaximum(Calendar.WEEK_OF_YEAR);
 
		labels=new JLabel[derniereSemaine-premiereSemaine+1];
 
		weekPanel = new JPanel(new GridLayout(1, 0));
		for (int i = premiereSemaine; i <= derniereSemaine; i++) {
			JLabel label = new JLabel(getWeekLabel(i), JLabel.CENTER);
			label.setBorder(BorderFactory.createEmptyBorder(0, 5, 0, 5));
			label.setOpaque(true);
			labels[i-premiereSemaine]=label;
			setLabelColor(i);
			label.setEnabled(true);
			final int week = i;
			label.addMouseListener(new MouseAdapter() {
				@Override
				public void mouseClicked(MouseEvent e) {
					setSelection(week);
				}
			});
			weekPanel.add(label);
		}
 
		JScrollPane slider = new JScrollPane(weekPanel,
				JScrollPane.VERTICAL_SCROLLBAR_NEVER,
				JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
		add(slider, BorderLayout.CENTER);
	}
 
	private void setLabelColor(int week) {
		int premiereSemaine = calendar.getMinimum(Calendar.WEEK_OF_YEAR);
		JLabel label=labels[week-premiereSemaine];
		if ( week==selection ) {
			label.setBackground(COLOR_SELECTION);
		}
		else if (week % 2 == 0) {
			label.setBackground(COLOR_ODD);
		} else {
			label.setBackground(COLOR_EVEN);
		}
 
	}
 
	public void updateSelection() {
		int premiereSemaine = calendar.getMinimum(Calendar.WEEK_OF_YEAR);
		int oldSelection = selection;
		selection = calendar.get(Calendar.WEEK_OF_YEAR);
		setLabelColor(oldSelection);
		setLabelColor(selection);
		weekPanel.scrollRectToVisible(labels[selection-premiereSemaine].getBounds());
	}
 
	private void setSelection(int selection) {
		int oldSelection = this.selection;
		this.selection = selection;
		setLabelColor(oldSelection);
		setLabelColor(selection);
		viewer.setWeek(selection);
	}
 
	private String getWeekLabel(int week) {
 
		Calendar calendar = Calendar.getInstance(); 
		calendar.setTime(this.calendar.getTime()); 
		calendar.set(Calendar.WEEK_OF_YEAR, week);
 
		// le premier jour de cette semaine
		Date premierJour = calendar.getTime();
		int monthPremierJour = calendar.get(Calendar.MONTH);
 
		// le dernier jour de cette semaine
		calendar.add(Calendar.WEEK_OF_YEAR, 1);
		calendar.add(Calendar.DAY_OF_WEEK, -1);
		Date dernierJour = calendar.getTime();
 
		int monthDernierJour = calendar.get(Calendar.MONTH);
 
        return getWeekLabel(week, premierJour, dernierJour, monthPremierJour, monthDernierJour);		
 
	}
 
	private final static DateFormat DATE_DEBUT_FORMAT = new SimpleDateFormat(
			"dd");
	private final static DateFormat DATE_FORMAT = new SimpleDateFormat(
			"dd MMMM");
 
	public static  String getWeekLabel(int week, Date premierJour, Date dernierJour, int monthPremierJour, int monthDernierJour) {
		String debut;
		if (monthDernierJour == monthPremierJour) {
			debut = DATE_DEBUT_FORMAT.format(premierJour);
		} else {
			debut = DATE_FORMAT.format(premierJour);
		}
 
		String milieu = DATE_FORMAT.format(dernierJour);
 
		String fin = " (" + week + ")";
 
		return debut + " - " + milieu + fin;
	}
 
}

Puis on la branche dans CalendarWeekViewer.

On ajoute une variable pour stocker l'instance de WeekPanel, et surtout intéragir avec :

Code:

private WeekPanel weekPanel;

Dans createComponents, on le créé, et pour le mettre en bas, on va créé un panel intermédiaire qui contiendra aussi le btnPanel

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
JPanel southPanel = new JPanel(new BorderLayout()); // le panel intermédiaire
 
// ça, ça ne change pas
JPanel btnPanel = new JPanel(); 
btnPanel.add(prevButton);
btnPanel.add(nextButton);
enabledButtons();
 
// on créé le weekPanel	
weekPanel = new WeekPanel(this, calendar);
 
// on met le btnPanel et le weekPanel dans le panel intermédiaire
southPanel.add(btnPanel, BorderLayout.NORTH); 
southPanel.add(weekPanel, BorderLayout.SOUTH);

et à la place de getContentPane().add(btnPanel, BorderLayout.SOUTH);, on fait :

Code:

getContentPane().add(southPanel, BorderLayout.SOUTH);

On a besoin d'appeler updateSelection() quand les boutons du CalendarWeekViewer, en modifiant actionPerformed

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public void actionPerformed(ActionEvent e) {
        if (e.getSource() == prevButton) {
    		calendar.add(Calendar.WEEK_OF_YEAR, -1); // on décrémente
    		enabledButtons();
 
            monthLabel.setText(getWeekLabel());
        	//tableModel.fireTableDataChanged(); 
        	tableModel.fireTableStructureChanged(); 
    		weekPanel.updateSelection();
        }
        else if (e.getSource() == nextButton) {
    		calendar.add(Calendar.WEEK_OF_YEAR, 1); // on incrémente
    		enabledButtons();
 
            monthLabel.setText(getWeekLabel());
        	//tableModel.fireTableDataChanged(); 
        	tableModel.fireTableStructureChanged(); 
    		weekPanel.updateSelection();
        }
    }

pour que le weekPanel puisse faire la sélection et propager les mises à jour nécessaire (de la JTable, du calendar, des boutons), on ajoute une méthode :

Code:

1
2
3
4
5
6
7
8
public void setWeek(int selection) {
	calendar.set(Calendar.WEEK_OF_YEAR, selection);
	enabledButtons();
        monthLabel.setText(getWeekLabel());
    	//tableModel.fireTableDataChanged(); 
    	tableModel.fireTableStructureChanged(); 
    	weekPanel.updateSelection();
}

En plus cette méthode permettra de sélectionner la semaine par le code (sans passer par l'interface graphique, mais en la mettant à jour)

accessoirement pour factoriser on peut appeler getWeekLabel() de weekPanel dans CalendarWeekViewer ( et supprimer les 2 constantes de format) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
    private String getWeekLabel() {
 
    	Calendar calendar = Calendar.getInstance(); // on créé un nouveau calendar pour pas modifier le calendar qui nous sert pour savoir quelle semaine on affiche
    	calendar.setTime(this.calendar.getTime()); // on recopie dedans la date actuellement mise dans le calendar qui ser pour savoir quelle semaine on affiche
 
    	int week = calendar.get(Calendar.WEEK_OF_YEAR); // on récupère le numéro de la semaine
 
            // le premier jour de cette semaine
    	Date premierJour = calendar.getTime();
	int monthPremierJour = calendar.get(Calendar.MONTH);
 
        // le dernier jour de cette semaine
	calendar.add(Calendar.WEEK_OF_YEAR, 1);
	calendar.add(Calendar.DAY_OF_WEEK, -1);
	Date dernierJour = calendar.getTime();
 
	int monthDernierJour = calendar.get(Calendar.MONTH);
 
	return WeekPanel.getWeekLabel(week, premierJour, dernierJour, monthPremierJour, monthDernierJour); 
}

08/03/2015, 14h50
totot

Ok
Merci bien,

Et je veux afficher ce planning pour une année de septembre à aout, c'est possible?

Tu parles d'avoir de parcourir les semaines de septembre à août au lieu de janvier à décembre ? Oui, c'est possible, il suffit de parcourir les semaines de septembre à août, au lieu de janvier à décembre, et de changer la façon de gérer les bornes pour les boutons << et >>.

Pour commencer la liste de semaines à la première de septembre, il faudra modifier la façon d'initialiser le début de notre liste de semaines :
Code:

1 2 3 4 5 6 7 8 9 // le calendar à l'initialisation contient la date du jour int month = calendar.get(Calendar.MONTH); if ( month<Calendar.SEPTEMBER ) { // si le mois courant est avant septembre // on doit passer à l'année d'avant pour commencer en septembre calendar.add(Calendar.YEAR, -1); } calendar.set(Calendar.MONTH,Calendar.SEPTEMBER); // on se positionne sur le mois de septembre (le début de notre liste de semaines) calendar.set(Calendar.DAY_OF_WEEK,calendar.getMinimum(Calendar.DAY_OF_WEEK)); // on se positionne sur le premier jour de la semaine

15/03/2015, 16h58
totot

Je revient vers toi car je ne vois pas ou je doit modifier le code pour commencer mon calendrier à partir de septembre et le finir en août

Je te l'ai dit pourtant.

Je ne peux pas t'aider si tu ne comprends pas à quoi servent les différentes parties du code et pourquoi elles se trouvent là où elles se trouvent, et à quoi elles servent.

A quoi sert ce code et que fait-il ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public CalendarWeekViewer() {
        super("Calendar Viewer");
 
        calendar = Calendar.getInstance();
 
        //calendar.set(Calendar.DAY_OF_MONTH, 0); // ça c'est ce qu'il y avait avant : on commençait au mois courant, et on choisissait le premier jour de ce mois
           calendar.set(Calendar.WEEK_OF_YEAR,calendar.getMinimum(Calendar.WEEK_OF_YEAR)); // on se positionne sur la première semaine de l'année
                calendar.set(Calendar.DAY_OF_WEEK,calendar.getMinimum(Calendar.DAY_OF_WEEK)); // on se positionne sur le premier jour de la semaine
 
 
        dateFormatter = new SimpleDateFormat("MMMM yyyy");
 
        createComponents();
    }

Et celui-là :

Code:

1
2
3
4
5
6
7
8
9
10
public WeekPanel(CalendarWeekViewer viewer, Calendar calendar) {
		this.viewer=viewer;
		this.calendar = calendar;
 
		selection = calendar.get(Calendar.WEEK_OF_YEAR);
 
		setLayout(new BorderLayout());
 
		int premiereSemaine = calendar.getMinimum(Calendar.WEEK_OF_YEAR);
		int derniereSemaine = calendar.getMaximum(Calendar.WEEK_OF_YEAR);

Et ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// cette méthode permet d'empêcher les boutons de changer d'année
    private void enabledButtons() {
    	int curWeek = calendar.get(Calendar.WEEK_OF_YEAR);
		boolean previousEnabled=true;
		boolean nextEnabled=true;
		if ( curWeek==calendar.getMinimum(Calendar.WEEK_OF_YEAR) ) {
			previousEnabled=false;
    	}
		if ( curWeek==calendar.getMaximum(Calendar.WEEK_OF_YEAR) ) {
			nextEnabled=false;
    	}
		prevButton.setEnabled(previousEnabled);
		nextButton.setEnabled(nextEnabled);
    }

Si tu comprends à quoi servent ces bouts de code, tu dois être capable d'appliquer ce que je t'ai indiqué pour changer un programme qui affiche les semaines de la première à la dernière de l'année en un programme qui affiche les semaines de la première de septembre à la dernière du mois d'août de l'année suivante (aussi faut-il comprendres les différences entre ces deux façons d'énumérer les semaines en dehors de toute notion de programmation).

15/03/2015, 23h20
totot

1: initialise le calendrier
2: permet d'avoir la première et dernière semaine de l'année
3 empêche de changer d'année si on est sur la première ou dernière semaine de l'année

En plus, il y a un autre problème dans le code que tu m'a donner: les semaines vont du dimanche au samedi au lieu du lundi au dimanche et dans les colonnes c'est afficher que dimanche et non lundi, mardi, mercredi, ...
15/03/2015, 23h53
joel.drigo

Citation:

Envoyé par totot

1: initialise le calendrier

et le positionne sur la première semaine qu'on veut afficher

Citation:

Envoyé par totot

2: permet d'avoir la première et dernière semaine de l'année

Oui, mais pourquoi faire ? Parce qu'on veut la liste des semaines pour les afficher, et qu'on veut la liste de la première à la dernière de l'année

Citation:

Envoyé par totot

3 empêche de changer d'année si on est sur la première ou dernière semaine de l'année

Non : elle permet de gérer si un bouton suivant ou précédent est grisé, en fonction de la semaine actuellement affichée. Elle permet donc d'éviter qu'on sorte de l'intervalle de semaines qu'on gère.

Donc, maintenant, si tu sais à quoi servent ces méthodes, tu sais où mettre le code (et adapter l'exemple que je t'ai donné) qui permet d'alleur de la première semaine de septembre à la dernière d'août, à la place de la première de l'année à la dernière de l'année.

Citation:

Envoyé par totot

En plus, il y a un autre problème dans le code que tu m'a donner: les semaines vont du dimanche au samedi au lieu du lundi au dimanche et dans les colonnes c'est afficher que dimanche et non lundi, mardi, mercredi, ...

C'est parce que j'initialise le premier jour de la semaine par

Code:

calendar.set(Calendar.DAY_OF_WEEK,calendar.getMinimum(Calendar.DAY_OF_WEEK))

Pour l'initialiser au lundi :

Code:

calendar.set(Calendar.DAY_OF_WEEK,calendar.MONDAY)

Pour l'initialiser au jour officiel de début de la semaine :

Code:

calendar.set(Calendar.DAY_OF_WEEK,calendar.getFirstDayOfWeek())

Attention, du coup, là où le dernier jour de la semaine est géré, il faudra changer la façon de le gérer (on ne va plus du minimul (dimanche) au maximul (samedi)). En particulier lorsqu'on parcourt les jours du premier au dernier de la semaine.

Je reviens vers toi car je galère vraiment à faire commencer mon planning en Septembre et le faire finir en Août. Et j'arrive pas non plus à mettre les jours de la semaine.
Voici mes classe:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class CalendarWeekRenderer extends JLabel implements TableCellRenderer {
 
    public CalendarWeekRenderer() {
        super();
        setFont(new Font(null, Font.PLAIN, 28));
        setVerticalAlignment(JLabel.TOP);
        setHorizontalAlignment(JLabel.LEFT);
        setOpaque(true);
    }
 
    public Component getTableCellRendererComponent(JTable table, Object value,
                                                    boolean isSelected, boolean hasFocus,
                                                    int row, int column) {
        setText((String)value);
        return this;
    }
}

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
public class WeekPanel extends JPanel {
 
	private final static Color COLOR_EVEN = new Color(111, 199, 227);
	private final static Color COLOR_ODD = Color.WHITE;
	private final static Color COLOR_SELECTION = Color.YELLOW;
 
	private final Calendar calendar;
	private JLabel[] labels;
	private int selection;
	private CalendarWeekViewer viewer;
	private JPanel weekPanel;
 
	public WeekPanel(CalendarWeekViewer viewer, Calendar calendar) {
		this.viewer=viewer;
		this.calendar = calendar;
 
		selection = calendar.get(Calendar.WEEK_OF_YEAR);
 
		setLayout(new BorderLayout());
 
		int premiereSemaine = calendar.getMinimum(Calendar.SEPTEMBER);
		int derniereSemaine = calendar.getMaximum(Calendar.AUGUST);
 
		labels=new JLabel[derniereSemaine-premiereSemaine+1];
 
		weekPanel = new JPanel(new GridLayout(1, 0));
		for (int i = premiereSemaine; i <= derniereSemaine; i++) {
			JLabel label = new JLabel(getWeekLabel(i), JLabel.CENTER);
			label.setBorder(BorderFactory.createEmptyBorder(0, 5, 0, 5));
			label.setOpaque(true);
			labels[i-premiereSemaine]=label;
			setLabelColor(i);
			label.setEnabled(true);
			final int week = i;
			label.addMouseListener(new MouseAdapter() {
				@Override
				public void mouseClicked(MouseEvent e) {
					setSelection(week);
				}
			});
			weekPanel.add(label);
		}
 
		JScrollPane slider = new JScrollPane(weekPanel,
				JScrollPane.VERTICAL_SCROLLBAR_NEVER,
				JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
		add(slider, BorderLayout.CENTER);
	}
 
	private void setLabelColor(int week) {
		int premiereSemaine = calendar.getMinimum(Calendar.WEEK_OF_YEAR);
		JLabel label=labels[week-premiereSemaine];
		if ( week==selection ) {
			label.setBackground(COLOR_SELECTION);
		}
		else if (week % 2 == 0) {
			label.setBackground(COLOR_ODD);
		} else {
			label.setBackground(COLOR_EVEN);
		}
 
	}
 
	public void updateSelection() {
		int premiereSemaine = calendar.getMinimum(Calendar.WEEK_OF_YEAR);
		int oldSelection = selection;
		selection = calendar.get(Calendar.WEEK_OF_YEAR);
		setLabelColor(oldSelection);
		setLabelColor(selection);
		weekPanel.scrollRectToVisible(labels[selection-premiereSemaine].getBounds());
	}
 
	private void setSelection(int selection) {
		int oldSelection = this.selection;
		this.selection = selection;
		setLabelColor(oldSelection);
		setLabelColor(selection);
		viewer.setWeek(selection);
	}
 
	private String getWeekLabel(int week) {
 
		Calendar calendar = Calendar.getInstance(); 
		calendar.setTime(this.calendar.getTime()); 
		calendar.set(Calendar.WEEK_OF_YEAR, week);
 
		// le premier jour de cette semaine
		Date premierJour = calendar.getTime();
		int monthPremierJour = calendar.get(Calendar.MONTH);
 
		// le dernier jour de cette semaine
		calendar.add(Calendar.WEEK_OF_YEAR, 1);
		calendar.add(Calendar.DAY_OF_WEEK, -1);
		Date dernierJour = calendar.getTime();
 
		int monthDernierJour = calendar.get(Calendar.MONTH);
 
        return getWeekLabel(week, premierJour, dernierJour, monthPremierJour, monthDernierJour);		
 
	}
 
	private final static DateFormat DATE_DEBUT_FORMAT = new SimpleDateFormat(
			"dd");
	private final static DateFormat DATE_FORMAT = new SimpleDateFormat(
			"dd MMMM");
 
	public static  String getWeekLabel(int week, Date premierJour, Date dernierJour, int monthPremierJour, int monthDernierJour) {
		String debut;
		if (monthDernierJour == monthPremierJour) {
			debut = DATE_DEBUT_FORMAT.format(premierJour);
		} else {
			debut = DATE_FORMAT.format(premierJour);
		}
 
		String milieu = DATE_FORMAT.format(dernierJour);
 
		String fin = " (" + week + ")";
 
		return debut + " - " + milieu + fin;
	}
 
}

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
public class CalendarWeekTableModel extends AbstractTableModel {
 
    private Calendar calendar;
 
    public CalendarWeekTableModel(Calendar calendar) {
    	this.calendar = calendar;
    }
 
    public int getColumnCount() {
    	// ramene les 7 jours de la semaine
        return 7;
    }
 
    public int getRowCount() {
    	// ramene le nombre de ligne
    	// nombre de demi journée 
    	return 2;
    }
 
    public String getColumnName(int col) {
        return getDayName(col);
    }
 
    public Object getValueAt(int row, int col) {
        int dayOfMonth = row * 7 + col - getFirstDayOfWeek() + 2;
        if (dayOfMonth < 1 || dayOfMonth > getLastDayOfMonth()) {
            return "";
        }
        else {
            return new Integer(dayOfMonth).toString();
        }
    }
 
    public boolean isCellEditable(int row, int col) {
        return true;
    }
    private String getDayName(int day) {
    	Calendar calendarDay = Calendar.getInstance();
    	calendarDay.setTime(calendar.getTime());
		calendarDay.add(Calendar.DATE, day);
		return calendar.getDisplayName(Calendar.DAY_OF_WEEK, Calendar.LONG_FORMAT, Locale.getDefault())+" "+calendarDay.get(Calendar.DATE);
	}
 
    private int getFirstDayOfWeek() {
        return calendar.get(Calendar.DAY_OF_WEEK);
    }
 
    private int getLastDayOfMonth() {
        return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
    }
}

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
vpublic class CalendarWeekViewer extends JFrame implements ActionListener {
 
    Calendar calendar;
    DateFormat dateFormatter;
 
    CalendarWeekTableModel tableModel;
 
    JLabel monthLabel;
    JTable table;
    JButton prevButton;
    JButton nextButton;
    private WeekPanel weekPanel;
 
	public CalendarWeekViewer() {
        super("Calendar Viewer");
        calendar = Calendar.getInstance();
        calendar.set(Calendar.WEEK_OF_YEAR,calendar.SEPTEMBER); // on se positionne sur la première semaine de l'année
        calendar.set(Calendar.DAY_OF_WEEK,calendar.getFirstDayOfWeek()); // on se positionne sur le premier jour de la semaine
        dateFormatter = new SimpleDateFormat("MMMM yyyy");
        createComponents();
    }
 
    private void createComponents() {
        addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
 
        monthLabel = new JLabel(getWeekLabel());
        monthLabel.setFont(new Font(null, Font.PLAIN, 36));
        monthLabel.setVerticalAlignment(JLabel.CENTER);
        monthLabel.setHorizontalAlignment(JLabel.CENTER);
 
        tableModel = new CalendarWeekTableModel(calendar);
        table = new JTable((TableModel)tableModel);
        table.setPreferredScrollableViewportSize(new Dimension(700, 600));
        table.setDefaultRenderer(String.class, new CalendarWeekRenderer());
        table.setRowHeight(200);
        TableColumnModel tableColumnModel = table.getColumnModel();
        for (int i=0; i < tableColumnModel.getColumnCount(); ++i) {
            TableColumn tableColumn = tableColumnModel.getColumn(i);
            tableColumn.setPreferredWidth(200);
        }
 
        JScrollPane tableScrollPane = new JScrollPane(table);
 
        prevButton = new JButton("<<");
        prevButton.addActionListener(this);
 
        nextButton = new JButton(">>");
        nextButton.addActionListener(this);
 
        JPanel southPanel = new JPanel(new BorderLayout()); // le panel intermédiaire
        JPanel btnPanel = new JPanel();
        btnPanel.add(prevButton);
        btnPanel.add(nextButton);
        enabledButtons();
 
        // on créé le weekPanel	
        weekPanel = new WeekPanel(this, calendar);
        // on met le btnPanel et le weekPanel dans le panel intermédiaire
        southPanel.add(btnPanel, BorderLayout.NORTH); 
        southPanel.add(weekPanel, BorderLayout.SOUTH);
 
        getContentPane().add(monthLabel, BorderLayout.NORTH);
        getContentPane().add(tableScrollPane, BorderLayout.CENTER);
        getContentPane().add(southPanel, BorderLayout.SOUTH);
    }
 
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == prevButton) {
    		calendar.add(Calendar.WEEK_OF_YEAR, -1); // on décrémente
    		enabledButtons();
 
            monthLabel.setText(getWeekLabel());
        	tableModel.fireTableStructureChanged(); 
    		weekPanel.updateSelection();
        }
        else if (e.getSource() == nextButton) {
    		calendar.add(Calendar.WEEK_OF_YEAR, 1); // on incrémente
    		enabledButtons();
 
            monthLabel.setText(getWeekLabel());
        	//tableModel.fireTableDataChanged(); 
        	tableModel.fireTableStructureChanged(); 
    		weekPanel.updateSelection();
        }
    }
 
    public void setWeek(int selection) {
    	calendar.set(Calendar.WEEK_OF_YEAR, selection);
    	enabledButtons();
            monthLabel.setText(getWeekLabel());
        	tableModel.fireTableStructureChanged(); 
        	weekPanel.updateSelection();
    }
 
    private String getWeekLabel() {
 
    	Calendar calendar = Calendar.getInstance(); // on créé un nouveau calendar pour pas modifier le calendar qui nous sert pour savoir quelle semaine on affiche
    	calendar.setTime(this.calendar.getTime()); // on recopie dedans la date actuellement mise dans le calendar qui ser pour savoir quelle semaine on affiche
 
    	int week = calendar.get(Calendar.WEEK_OF_YEAR); // on récupère le numéro de la semaine
 
        // le premier jour de cette semaine
    	Date premierJour = calendar.getTime();
    	int monthPremierJour = calendar.get(Calendar.MONDAY);
 
        // le dernier jour de cette semaine
    	calendar.add(Calendar.WEEK_OF_YEAR, 1);
    	calendar.add(Calendar.DAY_OF_WEEK, -1);
    	Date dernierJour = calendar.getTime();
 
    	int monthDernierJour = calendar.get(Calendar.MONTH);
 
    	return WeekPanel.getWeekLabel(week, premierJour, dernierJour, monthPremierJour, monthDernierJour); 
    }
 
    // cette méthode permet d'empêcher les boutons de changer d'année
    private void enabledButtons() {
    	int curWeek = calendar.get(Calendar.WEEK_OF_YEAR);
		boolean previousEnabled=true;
		boolean nextEnabled=true;
		if ( curWeek==calendar.getMinimum(Calendar.WEEK_OF_YEAR) ) {
			previousEnabled=false;
    	}
		if ( curWeek==calendar.getMaximum(Calendar.WEEK_OF_YEAR) ) {
			nextEnabled=false;
    	}
		prevButton.setEnabled(previousEnabled);
		nextButton.setEnabled(nextEnabled);
    }
 
    public static void main(String[] args) {
    	CalendarWeekViewer frame = new CalendarWeekViewer();
    	frame.pack();
    	frame.setVisible(true);
    }
}

C'est sûr que comme tu fais n'importe quoi, ça risque pas de fonctionner.

Dans le WeekViewer tu as écris

Code:

1
2
3
calendar = Calendar.getInstance();
calendar.set(Calendar.WEEK_OF_YEAR,calendar.SEPTEMBER); // on se positionne sur la première semaine de l'année
calendar.set(Calendar.DAY_OF_WEEK,calendar.getFirstDayOfWeek()); // on se positionne sur le premier jour de la semaine

Ces trois lignes font :

Créer une instance de Calendar : par défaut, la date est celle du jour
Ensuite tu dis que la semaine courante est le mois de septembre ! C'est n'importe quoi : un mois et un numéro de semaine ça n'a rien à voir
Ensuite, tu dis que le jour doit être le premier jour officiel de la semaine (donc le lundi en France), mais comme la semaine est complètement fausse, ça reste faux

Dans le WeekViewer, on avait à l'origine, dans le code que tu avais pris :

Code:

1
2
3
 
calendar = Calendar.getInstance();
calendar.set(Calendar.DAY_OF_MONTH, 0);

Ces 2 lignes font :

Créer une instance de Calendar : par défaut, la date est celle du jour
Ensuite on dit qu'on se place au premier mois (parce que le calendrier d'origine affiche les mois du premier au dernier de l'année, donc il ne s'interesse pas aux jours.

Moi, je t'ai dit d'initialiser le calendrier puis de se placer sur le mois de septembre comme ça :

Code:

1
2
3
4
5
6
7
8
9
10
 
// le calendar à l'initialisation contient la date du jour
int month = calendar.get(Calendar.MONTH);
if ( month<Calendar.SEPTEMBER ) { // si le mois courant est avant septembre
   // on doit passer à l'année d'avant pour commencer en septembre
   calendar.add(Calendar.YEAR, -1);
}
 
calendar.set(Calendar.MONTH,Calendar.SEPTEMBER); // on se positionne sur le mois de septembre (le début de notre liste de semaines)    	           calendar.set(Calendar.WEEK_OF_MONTH, 1); // on se positionne sur la première semaine du mois
calendar.set(Calendar.DAY_OF_WEEK,calendar.getMinimum(Calendar.DAY_OF_WEEK)); // on se positionne sur le premier jour de la semaine

Il n'y aucun rapport avec ce code et celui que tu as fait. J'ai mis dans les commentaires pourquoi je faisais comme ça.

Evidemment, comme tu veux commencer la semaine au premier jour officiel (lundi), il faut changer ça, donc ça donne au final :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
	public CalendarWeekViewer() {
        super("Calendar Viewer");
        calendar = Calendar.getInstance();
 
     // le calendar à l'initialisation contient la date du jour
        int month = calendar.get(Calendar.MONTH);
        if ( month<Calendar.SEPTEMBER ) { // si le mois courant est avant septembre
           // on doit passer à l'année d'avant pour commencer en septembre
           calendar.add(Calendar.YEAR, -1);
        }
 
        calendar.set(Calendar.MONTH,Calendar.SEPTEMBER); // on se positionne sur le mois de septembre (le début de notre liste de semaines)    	   
        calendar.set(Calendar.WEEK_OF_MONTH, 1); // on se positionne sur la première semaine du mois
        calendar.set(Calendar.DAY_OF_WEEK, calendar.getFirstDayOfWeek()); // on se positionne sur le premier jour officiel
 
        dateFormatter = new SimpleDateFormat("MMMM yyyy");
        createComponents();
    }

Ensuite, il faut reprendre la même idée pour l'appliquer au weekpanel, pour que les semaines aillent de la première de septembre à la dernière d'aoùt

Toi tu as écrit :

Code:

1
2
3
 
int premiereSemaine = calendar.getMinimum(Calendar.SEPTEMBER);
int derniereSemaine = calendar.getMaximum(Calendar.AUGUST);

Ce qui n'a strictement aucun sens : le paramètre de getMinimum() est un identifant de champ (cf la doc de Calendar). Là tu passes un numéro de mois : ça fait donc n'importe quoi.

La première semaine c'est un numéro de semaine : et on l'a déjà déterminé dans le CalendarWeekViewer (puisqu'on se positionne sur cette première semaine).
La dernière semaine se détermine sur le même principe, sauf qu'on va aller chercher la semaine précédent la première du mois suivant du dernier mois de la période, donc en fait celui de l'année suivante, (on sait dire quelle est la première semaine d'un mois facilement (c'est 1), mais pour la dernière, il faut connaitre le nombre de semaines du mois : c'est donc bien plus simple d'avancer d'un mois et de reculer d'une semaine, par rapport à la première semaine du mois).

Mais il y a autre chose qui complique tout : avant on allait de la première semaine (0) à la dernière (52 ou 53). Et pour les labels c'était pareil. Donc je gérais la semaine sélectionnée par un int. Mais maintenant la semaine va d'une semaine en plein milieu d'année (la dernière de septembre), la 36 pour cette année, jusqu'à la 35 de l'année prochaine. Et ça change tous les ans (pas de beaucoup, mais ça change).

Donc, il est bien plus compliqué de gérer la boucle par un for ou un while. On va donc utiliser une instance de calendar pour gérer la sélection : ce sera bien plus simple.

Il y a beaucoup de code qui change du coup, alors je te mets directement la classe : j'ai mis des commentaires (comme les fois d'avant). Il est indispensable que tu les lises pour comprendre ce que ça fait et pourquoi c'est fait comme ça.

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
public class WeekPanel extends JPanel {
 
	private static final int CALENDAR_START = Calendar.SEPTEMBER;
	private final static Color COLOR_EVEN = new Color(111, 199, 227);
	private final static Color COLOR_ODD = Color.WHITE;
	private final static Color COLOR_SELECTION = Color.YELLOW;
 
	private final Calendar calendar;
	private JLabel[] labels;
	private Calendar selection; // la sélection est gérée par un Calendar et non plus un int
	private CalendarWeekViewer viewer;
	private JPanel weekPanel;
	private Map<Integer, Integer> weeks=new HashMap<>(); // on a besoin de retrouver la position d'une semaine dans la liste de label
 
	public WeekPanel(CalendarWeekViewer viewer, Calendar calendar) {
		this.viewer=viewer;
		this.calendar = calendar;
 
		// comme on ne va plus de la semaine 0 à la dernière, mais d'une semaine en plein milieu de l'année à une autre de l'année suivantre, on ne peut plus utiliser un entier pour la sélection : il est plus simple d'utiliser un calendar (parce qu'on a besoin d'une numéro de la seamine, mais aussi de l'année)
		selection = copyCalendar(calendar);
 
		setLayout(new BorderLayout());
 
		Calendar premiereSemaine = getPremiereSemaine(CALENDAR_START); 
		Calendar derniereSemaine = getDerniereSemaine(CALENDAR_START);
 
		int nbSemaines = compteSemaines(premiereSemaine, derniereSemaine);
		labels=new JLabel[nbSemaines];
 
		weekPanel = new JPanel(new GridLayout(1, 0));
 
		Calendar semaine = Calendar.getInstance(); // on a besoin de parcourir les semaines...
		semaine.setTime(premiereSemaine.getTime()); // on les parcourt de la première à la dernière
		for(int i=0; i<nbSemaines; i++) {
			final Calendar week = copyCalendar(semaine);
			weeks.put(week.get(Calendar.WEEK_OF_YEAR), i); // ceci nous permet de facilement trouver le numéro d'une semaine dans la liste de label
			JLabel label = new JLabel(getWeekLabel(semaine), JLabel.CENTER);
			label.setBorder(BorderFactory.createEmptyBorder(0, 5, 0, 5));
			label.setOpaque(true);
			labels[i]=label;
			setLabelColor(week);
			label.setEnabled(true);
			label.addMouseListener(new MouseAdapter() {
				@Override
				public void mouseClicked(MouseEvent e) {
					setSelection(week);
				}
			});
			weekPanel.add(label);
			semaine.add(Calendar.WEEK_OF_YEAR, 1); // on avance d'une semaine
		}
 
		JScrollPane slider = new JScrollPane(weekPanel,
				JScrollPane.VERTICAL_SCROLLBAR_NEVER,
				JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
		add(slider, BorderLayout.CENTER);
	}
 
 
	private Calendar copyCalendar(Calendar calendar) {
		Calendar copy = Calendar.getInstance();
		copy.setTime(calendar.getTime());
		return copy;
 	}
 
 
	private int compteSemaines(Calendar premiereSemaine,
			Calendar derniereSemaine) {
        Calendar calendar = copyCalendar(premiereSemaine); // on prend une nouvelle instance 
		int count=0;
		while(calendar.get(Calendar.WEEK_OF_YEAR)!=derniereSemaine.get(Calendar.WEEK_OF_YEAR)) { // tant qu'on a pas atteint la dernière semaine
			count++; // on compte une semaine de plus
			calendar.add(Calendar.WEEK_OF_YEAR, 1); // on avance d'une semaine
		}
		return count + 1; // on ajoute 1 parce qu'il faut compte la dernière semaine (qu'on a pas compter dans la boucle)
	}
 
 
	public static Calendar getPremiereSemaine(int month) {
        Calendar calendar = Calendar.getInstance();
 
     // le calendar à l'initialisation contient la date du jour
        int currentmonth = calendar.get(Calendar.MONTH);
        if ( currentmonth<CALENDAR_START ) { // si le mois courant est avant septembre
           // on doit passer à l'année d'avant pour commencer en septembre
           calendar.add(Calendar.YEAR, -1);
        }
 
        calendar.set(Calendar.MONTH,month); // on se positionne sur le mois demandé 
        calendar.set(Calendar.WEEK_OF_MONTH, 1); // on se positionne sur la première semaine du mois
        calendar.set(Calendar.DAY_OF_WEEK, calendar.getFirstDayOfWeek()); // on se positionne sur le premier jour officiel
 
        return calendar;
	}
 
	public static Calendar getDerniereSemaine(int month) {
		Calendar calendar = getPremiereSemaine(month); // on se place sur la première semaine du mois
		calendar.add(Calendar.YEAR, 1); // on avance d'un an
		calendar.add(Calendar.WEEK_OF_YEAR, -1); // on recule d'une semaine
		return calendar;
	}
 
	private void setLabelColor(Calendar calendar) {
		JLabel label=labels[weeks.get(calendar.get(Calendar.WEEK_OF_YEAR))]; // on utilise la map pour savoir le numéro du label correspondant à la semaine
		if ( calendar.equals(selection) ) {
			label.setBackground(COLOR_SELECTION); // la semaine sélectionnée
		}
		else if (calendar.get(Calendar.WEEK_OF_YEAR) % 2 == 0) { // les semaines impaires d'une couleur
			label.setBackground(COLOR_ODD);
		} else {
			label.setBackground(COLOR_EVEN); //  les paires d'une autre
		}
 
	}
 
	public void updateSelection() {
		Calendar oldSelection = selection;
		selection = copyCalendar(calendar);
		setLabelColor(oldSelection);
		setLabelColor(selection);
		weekPanel.scrollRectToVisible(labels[weeks.get(selection.get(Calendar.WEEK_OF_YEAR))].getBounds());
	}
 
	private void setSelection(Calendar selection) {
		Calendar oldSelection = this.selection;
		this.selection = selection;
		setLabelColor(oldSelection);
		setLabelColor(selection);
		viewer.setWeek(selection);
	}
 
	private String getWeekLabel(Calendar week) {
 
		Calendar calendar = copyCalendar(week);
 
		// le premier jour de cette semaine
		Date premierJour = calendar.getTime();
		int monthPremierJour = calendar.get(Calendar.MONTH);
 
		// le dernier jour de cette semaine
		calendar.add(Calendar.WEEK_OF_YEAR, 1);
		calendar.add(Calendar.DAY_OF_WEEK, -1);
		Date dernierJour = calendar.getTime();
 
		int monthDernierJour = calendar.get(Calendar.MONTH);
 
        return getWeekLabel(week.get(Calendar.WEEK_OF_YEAR), premierJour, dernierJour, monthPremierJour, monthDernierJour);		
 
	}
 
	private final static DateFormat DATE_DEBUT_FORMAT = new SimpleDateFormat(
			"dd");
	private final static DateFormat DATE_FORMAT = new SimpleDateFormat(
			"dd MMMM");
 
	public static  String getWeekLabel(int week, Date premierJour, Date dernierJour, int monthPremierJour, int monthDernierJour) {
		String debut;
		if (monthDernierJour == monthPremierJour) {
			debut = DATE_DEBUT_FORMAT.format(premierJour);
		} else {
			debut = DATE_FORMAT.format(premierJour);
		}
 
		String milieu = DATE_FORMAT.format(dernierJour);
 
		String fin = " (" + week + ")";
 
		return debut + " - " + milieu + fin;
	}
 
}

Il est évidemmant nécessaire de modifier la méthode setWeek de WeekPanel :

Code:

1
2
3
4
5
6
7
public void setWeek(Calendar selection) {
    	calendar.setTime( selection.getTime());
    	enabledButtons();
            monthLabel.setText(getWeekLabel());
        	tableModel.fireTableStructureChanged(); 
        	weekPanel.updateSelection();
    }

De plus, il faut que tu changes la méthode enableButtons de WeekPanel, parce que les première et dernière semaines ne sont plus les mêmes ! Donc les tests curWeek==calendar.getMinimum(Calendar.WEEK_OF_YEAR) && curWeek==calendar.getMaximum(Calendar.WEEK_OF_YEAR) ne sont plus les mêmes. Je t'ai rendu les méthodes getPremiereSemaine() et getDerniereSemaine() static pour que tu puisses les utiliser pour faire le bon test : normalement, si tu lis toutes les explications et la doc de la classe Calendar, tu devrais savoir comment faire le bon test.

Par ailleurs, il y avait un bug dans la méthode getDayNames du modèle. Le bon code est :

Code:

1
2
3
4
5
6
    private String getDayName(int day) {
    	Calendar calendarDay = Calendar.getInstance();
    	calendarDay.setTime(calendar.getTime());
		calendarDay.add(Calendar.DATE, day);
		return calendarDay.getDisplayName(Calendar.DAY_OF_WEEK, Calendar.LONG_FORMAT, Locale.getDefault())+" "+calendarDay.get(Calendar.DATE); // bug sur cette ligne calendar au lieu de calendarDay
	}

Et dans cette méthode aussi (de CalendarWeekViewer) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
    private String getWeekLabel() {
 
    	Calendar calendar = Calendar.getInstance(); // on créé un nouveau calendar pour pas modifier le calendar qui nous sert pour savoir quelle semaine on affiche
    	calendar.setTime(this.calendar.getTime()); // on recopie dedans la date actuellement mise dans le calendar qui ser pour savoir quelle semaine on affiche
 
    	int week = calendar.get(Calendar.WEEK_OF_YEAR); // on récupère le numéro de la semaine
 
        // le premier jour de cette semaine
    	Date premierJour = calendar.getTime();
    	int monthPremierJour = calendar.get(Calendar.MONTH); // bug ici (il y avait int monthPremierJour = calendar.get(Calendar.MONDAY); donc n'importe quoi)!!!
 
        // le dernier jour de cette semaine
    	calendar.add(Calendar.WEEK_OF_YEAR, 1);
    	calendar.add(Calendar.DAY_OF_WEEK, -1);
    	Date dernierJour = calendar.getTime();
 
    	int monthDernierJour = calendar.get(Calendar.MONTH);
 
    	return WeekPanel.getWeekLabel(week, premierJour, dernierJour, monthPremierJour, monthDernierJour); 
    }

22/03/2015, 13h14
totot

Merci de ton aide.
Les suivants et précédents j'ai décidé de les retirer car ils me servent pas vu que j'ai déjà les semaines en bas.
Maintenant je vais essayer d'indiquer le numéro du jour dans mes entêtes de colonne.
Par exemple, Lundi 23, Mardi 24, ...
22/03/2015, 13h25
joel.drigo

1 pièce(s) jointe(s)

Citation:

Envoyé par totot

Merci de ton aide.
Les suivants et précédents j'ai décidé de les retirer car ils me servent pas vu que j'ai déjà les semaines en bas.

Ça ne peut que te simplifier le boulot, même si c'est dommage.

Citation:

Envoyé par totot

Maintenant je vais essayer d'indiquer le numéro du jour dans mes entêtes de colonne.
Par exemple, Lundi 23, Mardi 24, ...

Euh, mais c'est ce que fait déjà le code :weird:

Pièce jointe 172442

PS : tiens, d'ailleurs on voit un petit bug sur cette vue : la semaine actuelle (sélectionnée) n'est pas affichée en jaune dans la liste en bas. Il suffit d'ajouter setLabelColor(selection); à la fin du constructeur de WeekPanel.
22/03/2015, 14h11
totot

Exacte, j'avais pas fait attention