JYearChooser is a bean for choosing a year
/*
* JYearChooser.java - A bean for choosing a year
* Copyright (C) 2004 Kai Toedter
* kai@toedter.com
* www.toedter.com
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
//package com.myapp.util.swing.datechooser;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseListener;
import java.text.DateFormatSymbols;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JSpinner;
import javax.swing.JTextField;
import javax.swing.SpinnerNumberModel;
import javax.swing.SwingConstants;
import javax.swing.event.CaretEvent;
import javax.swing.event.CaretListener;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
/**
* JYearChooser is a bean for choosing a year.
*
* @author Kai Toedter
* @version 1.2
*/
@SuppressWarnings("serial")
public class JYearChooser extends JSpinField {
protected JDayChooser dayChooser;
protected int startYear;
protected int endYear;
/**
* Default JCalendar constructor.
*/
public JYearChooser() {
Calendar calendar = Calendar.getInstance();
dayChooser = null;
setMinimum(calendar.getMinimum(Calendar.YEAR));
setMaximum(calendar.getMaximum(Calendar.YEAR));
setValue(calendar.get(Calendar.YEAR));
}
/**
* Sets the year. This is a bound property.
*
* @param y
* the new year
*
* @see #getYear
*/
public void setYear(int y) {
int oldYear = getValue();
super.setValue(y, true, false);
if (dayChooser != null) {
dayChooser.setYear(value);
}
spinner.setValue(new Integer(value));
firePropertyChange("year", oldYear, value);
}
/**
* Sets the year value.
*
* @param value
* the year value
*/
public void setValue(int value) {
setYear(value);
}
/**
* Returns the year.
*
* @return the year
*/
public int getYear() {
return super.getValue();
}
/**
* Convenience method set a day chooser that might be updated directly.
*
* @param dayChooser
* the day chooser
*/
public void setDayChooser(JDayChooser dayChooser) {
this.dayChooser = dayChooser;
}
/**
* Returns "JYearChooser".
*
* @return the name value
*/
public String getName() {
return "JYearChooser";
}
/**
* Returns the endy ear.
*
* @return the end year
*/
public int getEndYear() {
return getMaximum();
}
/**
* Sets the end ear.
*
* @param endYear
* the end year
*/
public void setEndYear(int endYear) {
setMaximum(endYear);
}
/**
* Returns the start year.
*
* @return the start year.
*/
public int getStartYear() {
return getMinimum();
}
/**
* Sets the start year.
*
* @param startYear
* the start year
*/
public void setStartYear(int startYear) {
setMinimum(startYear);
}
/**
* Creates a JFrame with a JYearChooser inside and can be used for testing.
*
* @param s
* command line arguments
*/
static public void main(String[] s) {
JFrame frame = new JFrame("JYearChooser");
frame.getContentPane().add(new JYearChooser());
frame.pack();
frame.setVisible(true);
}
}
/*
* JSpinField.java - A spin field using a JSpinner (JDK 1.4)
* Copyright (C) 2004 Kai Toedter
* kai@toedter.com
* www.toedter.com
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
//package com.myapp.util.swing.datechooser;
/**
* JSpinField2 is a numeric field with 2 spin buttons to increase or decrease
* the value. It has the same interface as the "old" JSpinField but uses a
* JSpinner internally (since J2SE SDK 1.4) rather than a scrollbar for
* emulating the spin buttons.
*
* @author Kai Toedter
* @version 1.2
*/
@SuppressWarnings("serial")
class JSpinField extends JPanel implements ChangeListener,
CaretListener, ActionListener {
protected JSpinner spinner;
/** the text (number) field */
protected JTextField textField;
protected int min;
protected int max;
protected int value;
protected Color darkGreen;
/**
* Default JSpinField constructor.
*/
public JSpinField() {
this(0, Integer.MAX_VALUE);
}
/**
* JSpinField constructor with given minimum and maximum vaues..
* @param min
* @param max
*/
public JSpinField(int min, int max) {
super();
this.min = min;
if (max < min)
max = min;
this.max = max;
value = 0;
if (value < min)
value = min;
if (value > max)
value = max;
darkGreen = new Color(0, 150, 0);
setLayout(new BorderLayout());
textField = new JTextField();
textField.addCaretListener(this);
textField.addActionListener(this);
textField.setHorizontalAlignment(SwingConstants.RIGHT);
textField.setBorder(BorderFactory.createEmptyBorder());
textField.setText(Integer.toString(value));
spinner = new JSpinner();
spinner.setEditor(textField);
spinner.addChangeListener(this);
add(spinner, BorderLayout.CENTER);
}
public void adjustWidthToMaximumValue() {
JTextField testTextField = new JTextField(Integer.toString(max));
int width = testTextField.getPreferredSize().width;
int height = testTextField.getPreferredSize().height;
textField.setPreferredSize(new Dimension(width, height));
textField.revalidate();
}
/**
* Is invoked when the spinner model changes
*
* @param e
* the ChangeEvent
*/
public void stateChanged(ChangeEvent e) {
SpinnerNumberModel model = (SpinnerNumberModel) spinner.getModel();
int val = model.getNumber().intValue();
setValue(val);
}
/**
* Sets the value attribute of the JSpinField object.
*
* @param newValue
* The new value
* @param updateTextField
* true if text field should be updated
* @param firePropertyChange bleh
*/
protected void setValue(int newValue,
boolean updateTextField,
boolean firePropertyChange) {
int oldValue = value;
if (newValue < min) {
value = min;
} else if (newValue > max) {
value = max;
} else {
value = newValue;
}
if (updateTextField) {
textField.setText(Integer.toString(value));
textField.setForeground(Color.black);
}
if (firePropertyChange) {
firePropertyChange("value", oldValue, value);
}
}
/**
* Sets the value. This is a bound property.
*
* @param newValue
* the new value
*
* @see #getValue
*/
public void setValue(int newValue) {
setValue(newValue, true, true);
spinner.setValue(new Integer(value));
}
/**
* Returns the value.
*
* @return the value value
*/
public int getValue() {
return value;
}
/**
* Sets the minimum value.
*
* @param newMinimum
* the new minimum value
*
* @see #getMinimum
*/
public void setMinimum(int newMinimum) {
min = newMinimum;
}
/**
* Returns the minimum value.
*
* @return the minimum value
*/
public int getMinimum() {
return min;
}
/**
* Sets the maximum value and adjusts the preferred width.
*
* @param newMaximum
* the new maximum value
*
* @see #getMaximum
*/
public void setMaximum(int newMaximum) {
max = newMaximum;
}
/**
* Sets the horizontal alignment of the displayed value.
*
* @param alignment
* the horizontal alignment
*/
public void setHorizontalAlignment(int alignment) {
textField.setHorizontalAlignment(alignment);
}
/**
* Returns the maximum value.
*
* @return the maximum value
*/
public int getMaximum() {
return max;
}
/**
* Sets the font property.
*
* @param font
* the new font
*/
public void setFont(Font font) {
if (textField != null) {
textField.setFont(font);
}
}
/**
* DOCUMENT ME!
*
* @param fg
* DOCUMENT ME!
*/
public void setForeground(Color fg) {
if (textField != null) {
textField.setForeground(fg);
}
}
/**
* After any user input, the value of the textfield is proofed. Depending on
* being an integer, the value is colored green or red.
*
* @param e
* Description of the Parameter
*/
public void caretUpdate(CaretEvent e) {
try {
int testValue = Integer.valueOf(textField.getText()).intValue();
if ((testValue >= min) && (testValue <= max)) {
textField.setForeground(darkGreen);
setValue(testValue, false, true);
} else {
textField.setForeground(Color.red);
}
} catch (Exception ex) {
if (ex instanceof NumberFormatException) {
textField.setForeground(Color.red);
}
// Ignore all other exceptions, e.g. illegal state exception
}
textField.repaint();
}
/**
* After any user input, the value of the textfield is proofed. Depending on
* being an integer, the value is colored green or red. If the textfield is
* green, the enter key is accepted and the new value is set.
*
* @param e
* Description of the Parameter
*/
public void actionPerformed(ActionEvent e) {
if (textField.getForeground().equals(darkGreen)) {
setValue(Integer.valueOf(textField.getText()).intValue());
}
}
/**
* Enable or disable the JSpinField.
*
* @param enabled
* The new enabled value
*/
public void setEnabled(boolean enabled) {
super.setEnabled(enabled);
textField.setEnabled(enabled);
spinner.setEnabled(enabled);
}
/**
* Returns the year chooser's spinner (which allow the focus to be set to
* it).
*
* @return Component the spinner or null, if the month chooser has no
* spinner
*/
public Component getSpinner() {
return spinner;
}
/**
* Returns "JSpinField".
*
* @return the name value
*/
public String getName() {
return "JSpinField";
}
/**
* Creates a JFrame with a JSpinField inside and can be used for testing.
*
* @param s
* The command line arguments
*/
public static void main(String[] s) {
JFrame frame = new JFrame("JSpinField2");
frame.getContentPane().add(new JSpinField());
frame.pack();
frame.setVisible(true);
}
}
/**
* JCalendar is a bean for choosing a day.
*
* @author Kai Toedter
* @version 1.2.1
*/
@SuppressWarnings("serial")
class JDayChooser extends JPanel implements ActionListener, KeyListener,
FocusListener {
protected JButton[] days;
protected JButton[] weeks;
protected JButton selectedDay;
protected JPanel weekPanel;
protected JPanel dayPanel;
protected int day;
protected Color oldDayBackgroundColor;
protected Color selectedColor;
protected Color sundayForeground;
protected Color weekdayForeground;
protected Color decorationBackgroundColor;
protected String[] dayNames;
protected Calendar calendar;
protected Calendar today;
protected Locale locale;
protected boolean initialized;
protected boolean weekOfYearVisible;
protected boolean decorationBackgroundVisible = true;
protected boolean decorationBordersVisible;
private boolean alwaysFireDayProperty;
/**
* Default JDayChooser constructor.
*/
public JDayChooser() {
this(false);
}
/**
* JDayChooser constructor.
*
* @param weekOfYearVisible
* true, if the weeks of a year shall be shown
*/
public JDayChooser(boolean weekOfYearVisible) {
setBackground(Color.blue);
this.weekOfYearVisible = weekOfYearVisible;
locale = Locale.getDefault();
days = new JButton[49];
selectedDay = null;
calendar = Calendar.getInstance(locale);
today = (Calendar) calendar.clone();
setLayout(new BorderLayout());
dayPanel = new JPanel();
dayPanel.setLayout(new GridLayout(7, 7));
sundayForeground = new Color(164, 0, 0);
weekdayForeground = new Color(0, 90, 164);
// decorationBackgroundColor = new Color(194, 211, 252);
// decorationBackgroundColor = new Color(206, 219, 246);
decorationBackgroundColor = new Color(210, 228, 238);
for (int y = 0; y < 7; y++) {
for (int x = 0; x < 7; x++) {
int index = x + (7 * y);
if (y == 0) {
// Create a button that doesn't react on clicks or focus
// changes.
// Thanks to Thomas Schaefer for the focus hint :)
days[index] = new JButton() {
public void addMouseListener(MouseListener l) {
}
public boolean isFocusable() {
return false;
}
};
days[index]
.setContentAreaFilled(decorationBackgroundVisible);
days[index].setBorderPainted(decorationBordersVisible);
days[index].setBackground(decorationBackgroundColor);
} else {
days[index] = new JButton("x");
days[index].addActionListener(this);
days[index].addKeyListener(this);
days[index].addFocusListener(this);
}
days[index].setMargin(new Insets(0, 0, 0, 0));
days[index].setFocusPainted(false);
dayPanel.add(days[index]);
}
}
weekPanel = new JPanel();
weekPanel.setLayout(new GridLayout(7, 1));
weeks = new JButton[7];
for (int i = 0; i < 7; i++) {
weeks[i] = new JButton() {
public void addMouseListener(MouseListener l) {
}
public boolean isFocusable() {
return false;
}
};
weeks[i].setMargin(new Insets(0, 0, 0, 0));
weeks[i].setFocusPainted(false);
weeks[i].setBackground(decorationBackgroundColor);
weeks[i].setForeground(new Color(100, 100, 100));
weeks[i].setContentAreaFilled(decorationBackgroundVisible);
weeks[i].setBorderPainted(decorationBordersVisible);
if (i != 0) {
weeks[i].setText("0" + (i + 1));
}
weekPanel.add(weeks[i]);
}
init();
drawWeeks();
setDay(Calendar.getInstance().get(Calendar.DAY_OF_MONTH));
add(dayPanel, BorderLayout.CENTER);
if (weekOfYearVisible) {
add(weekPanel, BorderLayout.WEST);
}
initialized = true;
}
/**
* Initilizes the locale specific names for the days of the week.
*/
protected void init() {
JButton testButton = new JButton();
oldDayBackgroundColor = testButton.getBackground();
selectedColor = new Color(160, 160, 160);
Date date = calendar.getTime();
calendar = Calendar.getInstance(locale);
calendar.setTime(date);
drawDayNames();
drawDays();
}
/**
* Draws the day names of the day columnes.
*/
private void drawDayNames() {
int firstDayOfWeek = calendar.getFirstDayOfWeek();
DateFormatSymbols dateFormatSymbols = new DateFormatSymbols(locale);
dayNames = dateFormatSymbols.getShortWeekdays();
int dayi = firstDayOfWeek;
for (int i = 0; i < 7; i++) {
days[i].setText(dayNames[dayi]);
if (dayi == 1) {
days[i].setForeground(sundayForeground);
} else {
days[i].setForeground(weekdayForeground);
}
if (dayi < 7) {
dayi++;
} else {
dayi -= 6;
}
}
}
/**
* Initializes both day names and weeks of the year.
*/
protected void initDecorations() {
for (int x = 0; x < 7; x++) {
days[x].setContentAreaFilled(decorationBackgroundVisible);
days[x].setBorderPainted(decorationBordersVisible);
weeks[x].setContentAreaFilled(decorationBackgroundVisible);
weeks[x].setBorderPainted(decorationBordersVisible);
}
}
/**
* Hides and shows the week buttons.
*/
protected void drawWeeks() {
Calendar tmpCalendar = (Calendar) calendar.clone();
for (int i = 1; i < 7; i++) {
tmpCalendar.set(Calendar.DAY_OF_MONTH, (i * 7) - 6);
int week = tmpCalendar.get(Calendar.WEEK_OF_YEAR);
String buttonText = Integer.toString(week);
if (week < 10) {
buttonText = "0" + buttonText;
}
weeks[i].setText(buttonText);
if ((i == 5) || (i == 6)) {
weeks[i].setVisible(days[i * 7].isVisible());
}
}
}
/**
* Hides and shows the day buttons.
*/
protected void drawDays() {
Calendar tmpCalendar = (Calendar) calendar.clone();
int firstDayOfWeek = tmpCalendar.getFirstDayOfWeek();
tmpCalendar.set(Calendar.DAY_OF_MONTH, 1);
int firstDay = tmpCalendar.get(Calendar.DAY_OF_WEEK) - firstDayOfWeek;
if (firstDay < 0) {
firstDay += 7;
}
int i;
for (i = 0; i < firstDay; i++) {
days[i + 7].setVisible(false);
days[i + 7].setText("");
}
tmpCalendar.add(Calendar.MONTH, 1);
Date firstDayInNextMonth = tmpCalendar.getTime();
tmpCalendar.add(Calendar.MONTH, -1);
Date dayi = tmpCalendar.getTime();
int n = 0;
Color foregroundColor = getForeground();
while (dayi.before(firstDayInNextMonth)) {
days[i + n + 7].setText(Integer.toString(n + 1));
days[i + n + 7].setVisible(true);
if ((tmpCalendar.get(Calendar.DAY_OF_YEAR) == today
.get(Calendar.DAY_OF_YEAR))
&& (tmpCalendar.get(Calendar.YEAR) == today
.get(Calendar.YEAR))) {
days[i + n + 7].setForeground(sundayForeground);
} else {
days[i + n + 7].setForeground(foregroundColor);
}
if ((n + 1) == this.day) {
days[i + n + 7].setBackground(selectedColor);
selectedDay = days[i + n + 7];
} else {
days[i + n + 7].setBackground(oldDayBackgroundColor);
}
n++;
tmpCalendar.add(Calendar.DATE, 1);
dayi = tmpCalendar.getTime();
}
for (int k = n + i + 7; k < 49; k++) {
days[k].setVisible(false);
days[k].setText("");
}
}
/**
* Returns the locale.
*
* @return the locale value
*
* @see #setLocale
*/
public Locale getLocale() {
return locale;
}
/**
* Sets the locale.
*
* @param locale
* the new locale value
*
* @see #getLocale
*/
public void setLocale(Locale locale) {
if (!initialized) {
super.setLocale(locale);
} else {
this.locale = locale;
super.setLocale(locale);
init();
}
}
/**
* Sets the day. This is a bound property.
*
* @param d
* the day
*
* @see #getDay
*/
public void setDay(int d) {
if (d < 1) {
d = 1;
}
Calendar tmpCalendar = (Calendar) calendar.clone();
tmpCalendar.set(Calendar.DAY_OF_MONTH, 1);
tmpCalendar.add(Calendar.MONTH, 1);
tmpCalendar.add(Calendar.DATE, -1);
int maxDaysInMonth = tmpCalendar.get(Calendar.DATE);
if (d > maxDaysInMonth) {
d = maxDaysInMonth;
}
int oldDay = day;
day = d;
if (selectedDay != null) {
selectedDay.setBackground(oldDayBackgroundColor);
selectedDay.repaint();
}
for (int i = 7; i < 49; i++) {
if (days[i].getText().equals(Integer.toString(day))) {
selectedDay = days[i];
selectedDay.setBackground(selectedColor);
break;
}
}
if (alwaysFireDayProperty) {
firePropertyChange("day", 0, day);
} else {
firePropertyChange("day", oldDay, day);
}
}
/**
* this is needed for JDateChooser.
*
* @param alwaysFire
* true, if day property shall be fired every time a day is
* chosen.
*/
public void setAlwaysFireDayProperty(boolean alwaysFire) {
alwaysFireDayProperty = alwaysFire;
}
/**
* Returns the selected day.
*
* @return the day value
*
* @see #setDay
*/
public int getDay() {
return day;
}
/**
* Sets a specific month. This is needed for correct graphical
* representation of the days.
*
* @param month
* the new month
*/
public void setMonth(int month) {
calendar.set(Calendar.MONTH, month);
// Since the day does not change,
// don't fire a day property change, even if alwaysFireDayProperty is
// true :)
boolean storedMode = alwaysFireDayProperty;
alwaysFireDayProperty = false;
setDay(day);
alwaysFireDayProperty = storedMode;
drawDays();
drawWeeks();
}
/**
* Sets a specific year. This is needed for correct graphical representation
* of the days.
*
* @param year
* the new year
*/
public void setYear(int year) {
calendar.set(Calendar.YEAR, year);
drawDays();
drawWeeks();
}
/**
* Sets a specific calendar. This is needed for correct graphical
* representation of the days.
*
* @param calendar
* the new calendar
*/
public void setCalendar(Calendar calendar) {
this.calendar = calendar;
drawDays();
}
/**
* Sets the font property.
*
* @param font
* the new font
*/
public void setFont(Font font) {
if (days != null) {
for (int i = 0; i < 49; i++) {
days[i].setFont(font);
}
}
}
/**
* Sets the foregroundColor color.
*
* @param foreground
* the new foregroundColor
*/
public void setForeground(Color foreground) {
super.setForeground(foreground);
if (days != null) {
for (int i = 7; i < 49; i++) {
days[i].setForeground(foreground);
}
drawDays();
}
}
/**
* Returns "JDayChooser".
*
* @return the name value
*/
public String getName() {
return "JDayChooser";
}
/**
* JDayChooser is the ActionListener for all day buttons.
*
* @param e
* the ActionEvent
*/
public void actionPerformed(ActionEvent e) {
JButton button = (JButton) e.getSource();
String buttonText = button.getText();
int dayi = new Integer(buttonText).intValue();
setDay(dayi);
}
/**
* JDayChooser is the FocusListener for all day buttons. (Added by Thomas
* Schaefer)
*
* @param e
* the FocusEvent
*/
/*
* Code below commented out by Mark Brown on 24 Aug 2004. This code breaks
* the JDateChooser code by triggering the actionPerformed method on the
* next day button. This causes the date chosen to always be incremented by
* one day.
*/
public void focusGained(FocusEvent e) {
// JButton button = (JButton) e.getSource();
// String buttonText = button.getText();
//
// if ((buttonText != null) && !buttonText.equals("") &&
// !e.isTemporary()) {
// actionPerformed(new ActionEvent(e.getSource(), 0, null));
// }
}
/**
* Does nothing.
*
* @param e
* the FocusEvent
*/
public void focusLost(FocusEvent e) {
}
/**
* JDayChooser is the KeyListener for all day buttons. (Added by Thomas
* Schaefer and modified by Austin Moore)
*
* @param e
* the KeyEvent
*/
public void keyPressed(KeyEvent e) {
int offset = (e.getKeyCode() == KeyEvent.VK_UP) ? (-7) : ((e
.getKeyCode() == KeyEvent.VK_DOWN) ? (+7)
: ((e.getKeyCode() == KeyEvent.VK_LEFT) ? (-1) : ((e
.getKeyCode() == KeyEvent.VK_RIGHT) ? (+1) : 0)));
int newDay = getDay() + offset;
if ((newDay >= 1)
&& (newDay <= calendar.getMaximum(Calendar.DAY_OF_MONTH))) {
setDay(newDay);
}
}
/**
* Does nothing.
*
* @param e
* the KeyEvent
*/
public void keyTyped(KeyEvent e) {
}
/**
* Does nothing.
*
* @param e
* the KeyEvent
*/
public void keyReleased(KeyEvent e) {
}
/**
* Enable or disable the JDayChooser.
*
* @param enabled
* The new enabled value
*/
public void setEnabled(boolean enabled) {
super.setEnabled(enabled);
for (short i = 0; i < days.length; i++) {
if (days[i] != null) {
days[i].setEnabled(enabled);
}
}
for (short i = 0; i < weeks.length; i++) {
if (weeks[i] != null) {
weeks[i].setEnabled(enabled);
}
}
}
/**
* In some Countries it is often usefull to know in which week of the year a
* date is.
*
* @return boolean true, if the weeks of the year is shown
*/
public boolean isWeekOfYearVisible() {
return weekOfYearVisible;
}
/**
* In some Countries it is often usefull to know in which week of the year a
* date is.
*
* @param weekOfYearVisible
* true, if the weeks of the year shall be shown
*/
public void setWeekOfYearVisible(boolean weekOfYearVisible) {
if (weekOfYearVisible == this.weekOfYearVisible) {
return;
} else if (weekOfYearVisible) {
add(weekPanel, BorderLayout.WEST);
} else {
remove(weekPanel);
}
this.weekOfYearVisible = weekOfYearVisible;
validate();
dayPanel.validate();
}
/**
* Returns the day panel.
*
* @return the day panel
*/
public JPanel getDayPanel() {
return dayPanel;
}
/**
* Returns the color of the decoration (day names and weeks).
*
* @return the color of the decoration (day names and weeks).
*/
public Color getDecorationBackgroundColor() {
return decorationBackgroundColor;
}
/**
* Sets the background of days and weeks of year buttons.
*
* @param decorationBackgroundColor
* The background to set
*/
public void setDecorationBackgroundColor(Color decorationBackgroundColor) {
this.decorationBackgroundColor = decorationBackgroundColor;
if (days != null) {
for (int i = 0; i < 7; i++) {
days[i].setBackground(decorationBackgroundColor);
}
}
if (weeks != null) {
for (int i = 0; i < 7; i++) {
weeks[i].setBackground(decorationBackgroundColor);
}
}
}
/**
* Returns the Sunday foreground.
*
* @return Color the Sunday foreground.
*/
public Color getSundayForeground() {
return sundayForeground;
}
/**
* Returns the weekday foreground.
*
* @return Color the weekday foreground.
*/
public Color getWeekdayForeground() {
return weekdayForeground;
}
/**
* Sets the Sunday foreground.
*
* @param sundayForeground
* The sundayForeground to set
*/
public void setSundayForeground(Color sundayForeground) {
this.sundayForeground = sundayForeground;
drawDayNames();
drawDays();
}
/**
* Sets the weekday foreground.
*
* @param weekdayForeground
* The weekdayForeground to set
*/
public void setWeekdayForeground(Color weekdayForeground) {
this.weekdayForeground = weekdayForeground;
drawDayNames();
drawDays();
}
/**
* Requests that the selected day also have the focus.
*/
public void setFocus() {
if (selectedDay != null) {
this.selectedDay.requestFocus();
}
}
/**
* The decoration background is the background color of the day titles and
* the weeks of the year.
*
* @return Returns true, if the decoration background is painted.
*/
public boolean isDecorationBackgroundVisible() {
return decorationBackgroundVisible;
}
/**
* The decoration background is the background color of the day titles and
* the weeks of the year.
*
* @param decorationBackgroundVisible
* true, if the decoration background shall be painted.
*/
public void setDecorationBackgroundVisible(
boolean decorationBackgroundVisible) {
this.decorationBackgroundVisible = decorationBackgroundVisible;
initDecorations();
}
/**
* The decoration border is the button border of the day titles and the
* weeks of the year.
*
* @return Returns true, if the decoration border is painted.
*/
public boolean isDecorationBordersVisible() {
return decorationBordersVisible;
}
/**
* The decoration border is the button border of the day titles and the
* weeks of the year.
*
* @param decorationBordersVisible
* true, if the decoration border shall be painted.
*/
public void setDecorationBordersVisible(boolean decorationBordersVisible) {
this.decorationBordersVisible = decorationBordersVisible;
initDecorations();
}
/**
* Creates a JFrame with a JDayChooser inside and can be used for testing.
*
* @param s
* The command line arguments
*/
public static void main(String[] s) {
JFrame frame = new JFrame("JDayChooser");
frame.getContentPane().add(new JDayChooser());
frame.pack();
frame.setVisible(true);
}
}
Related examples in the same category
