null
* for no minimum).
*/
private Comparable start;
/**
* A constraint on the end or latest permitted date (null for no
* maximum).
*/
private Comparable end;
/**
* The calendar field used to calculate the previous or next date.
*/
private int calendarField;
/**
* For compatability with Sun's JDK
*/
private static final long serialVersionUID = -4802518107105940612L;
/**
* Constructs a SpinnerDateModel using the current date,
* no start or end limit, and {@link Calendar#DAY_OF_MONTH} as the calendar
* field.
*/
public SpinnerDateModel()
{
this(new Date(), null, null, Calendar.DAY_OF_MONTH);
}
/**
* Constructs a SpinnerDateModel with the specified value, lower
* and upper bounds, and which spins the specified calendar field.
*
* The start and end limits must have a
* compareTo method that supports instances of {@link Date}, but
* do not themselves need to be instances of {@link Date} (although typically
* they are).
*
* @param value the initial value/date (null not permitted).
* @param start a constraint that specifies the earliest permitted date
* value, or null for no lower limit.
* @param end a constraint that specifies the latest permitted date value,
* or null for no upper limit.
* @param calendarField the Calendar field to spin,
* (Calendar.ZONE_OFFSET and Calendar.DST_OFFSET are invalid)
*/
public SpinnerDateModel(Date value, Comparable start, Comparable end,
int calendarField)
{
if (value == null)
throw new IllegalArgumentException("Null 'value' argument.");
if (start != null && start.compareTo(value) > 0)
throw new IllegalArgumentException("Require value on or after start.");
if (end != null && end.compareTo(value) < 0)
throw new IllegalArgumentException("Require value on or before end.");
date = Calendar.getInstance();
date.setTime(value);
this.start = start;
this.end = end;
setCalendarField(calendarField);
}
/**
* Returns the {@link Calendar} field used to calculate the previous and
* next dates in the sequence.
*
* @return The date field code.
*/
public int getCalendarField()
{
return calendarField;
}
/**
* Returns the current date/time.
*
* @return The current date/time (never null).
*
* @see #getValue()
*/
public Date getDate()
{
return date.getTime();
}
/**
* Returns the lower limit on the date/time value, or null if
* there is no minimum date/time.
*
* @return The lower limit.
*
* @see #setStart(Comparable)
*/
public Comparable getStart()
{
return start;
}
/**
* Returns the upper limit on the date/time value, or null if
* there is no maximum date/time.
*
* @return The upper limit.
*
* @see #setEnd(Comparable)
*/
public Comparable getEnd()
{
return end;
}
/**
* Returns the current date in the sequence (this method returns the same as
* {@link #getDate()}).
*
* @return The current date (never null).
*/
public Object getValue()
{
return date.getTime();
}
/**
* Returns the next date in the sequence, or null if the
* next date is past the upper limit (if one is specified). The current date
* is not changed.
*
* @return The next date, or null if the current value is
* the latest date represented by the model.
*
* @see #getEnd()
*/
public Object getNextValue()
{
Calendar nextCal = Calendar.getInstance();
nextCal.setTime(date.getTime());
nextCal.roll(calendarField, true);
Date nextDate = nextCal.getTime();
if (end != null)
if (end.compareTo(nextDate) < 0)
return null;
return nextDate;
}
/**
* Returns the previous date in the sequence, or null if the
* previous date is prior to the lower limit (if one is specified). The
* current date is not changed.
*
* @return The previous date, or null if the current value is
* the earliest date represented by the model.
*
* @see #getStart()
*/
public Object getPreviousValue()
{
Calendar prevCal = Calendar.getInstance();
prevCal.setTime(date.getTime());
prevCal.roll(calendarField, false);
Date prevDate = prevCal.getTime();
if (start != null)
if (start.compareTo(prevDate) > 0)
return null;
return prevDate;
}
/**
* Sets the date field to change when calculating the next and previous
* values. It must be a valid {@link Calendar} field, excluding
* {@link Calendar#ZONE_OFFSET} and {@link Calendar#DST_OFFSET}.
*
* @param calendarField the calendar field to set.
*
* @throws IllegalArgumentException if calendarField is not
* a valid code.
*/
public void setCalendarField(int calendarField)
{
if (calendarField < 0 || calendarField >= Calendar.FIELD_COUNT
|| calendarField == Calendar.ZONE_OFFSET
|| calendarField == Calendar.DST_OFFSET)
throw new IllegalArgumentException("Illegal calendarField");
if (this.calendarField != calendarField)
{
this.calendarField = calendarField;
fireStateChanged();
}
}
/**
* Sets the lower limit for the date/time value and, if the new limit is
* different to the old limit, sends a {@link ChangeEvent} to all registered
* listeners. A null value is interpreted as "no lower limit".
* No check is made to ensure that the current date/time is on or after the
* new lower limit - the caller is responsible for ensuring that this
* relationship holds. In addition, the caller should ensure that
* start is {@link Serializable}.
*
* @param start the new lower limit for the date/time value
* (null permitted).
*/
public void setStart(Comparable start)
{
if (this.start != start)
{
this.start = start;
fireStateChanged();
}
}
/**
* Sets the upper limit for the date/time value and, if the new limit is
* different to the old limit, sends a {@link ChangeEvent} to all registered
* listeners. A null value is interpreted as "no upper limit".
* No check is made to ensure that the current date/time is on or before the
* new upper limit - the caller is responsible for ensuring that this
* relationship holds. In addition, the caller should ensure that
* end is {@link Serializable}.
*
* @param end the new upper limit for the date/time value (null
* permitted).
*/
public void setEnd(Comparable end)
{
if (this.end != end)
{
this.end = end;
fireStateChanged();
}
}
/**
* Sets the current date and, if the new value is different to the old
* value, sends a {@link ChangeEvent} to all registered listeners.
*
* @param value the new date (null not permitted, must be an
* instance of Date).
*
* @throws IllegalArgumentException if value is not an instance
* of Date.
*/
public void setValue(Object value)
{
if (! (value instanceof Date) || value == null)
throw new IllegalArgumentException("Value not a date.");
if (!date.getTime().equals(value))
{
date.setTime((Date) value);
fireStateChanged();
}
}
}