CPDatePicker.j

Go to the documentation of this file.

/* CPDatePicker.j
* AppKit
*
* Created by Alexandre Wilhelm
* Copyright 2012 <[email protected]>
*
* This library 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.1 of the License, or (at your option) any later version.
*
* This library 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 library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/




@global CPLocaleLanguageCode
@global CPDateFormatterShortStyle

var CPDatePicker_validateProposedDateValue_timeInterval = 1 << 1;

CPSingleDateMode = 0;
CPRangeDateMode = 1;

CPTextFieldAndStepperDatePickerStyle    = 0;
CPClockAndCalendarDatePickerStyle       = 1;
CPTextFieldDatePickerStyle              = 2;

CPHourMinuteDatePickerElementFlag       = 0x000c;
CPHourMinuteSecondDatePickerElementFlag = 0x000e;
CPTimeZoneDatePickerElementFlag         = 0x0010;
CPYearMonthDatePickerElementFlag        = 0x00c0;
CPYearMonthDayDatePickerElementFlag     = 0x00e0;
CPEraDatePickerElementFlag              = 0x0100;

@implementation CPDatePicker : CPControl
{
    BOOL            _isBordered;
    BOOL            _isBezeled;
    BOOL            _drawsBackground;
    CPDate          _dateValue;
    CPDate          _minDate;
    CPDate          _maxDate;
    CPFont          _textFont;
    CPLocale        _locale;
    //CPCalendar  _calendar;
    CPTimeZone      _timeZone;
    id              _delegate;
    CPInteger       _datePickerElements;
    CPInteger       _datePickerMode;
    CPInteger       _datePickerStyle;
    CPInteger       _timeInterval;

    BOOL                    _invokedByUserEvent;
    _CPDatePickerTextField  _datePickerTextfield;
    _CPDatePickerCalendar   _datePickerCalendar;
    unsigned                _implementedCDatePickerDelegateMethods;
}


#pragma mark -
#pragma mark Theme methods

+ (CPString)defaultThemeClass
{
    return @"datePicker";
}

+ (CPDictionary)themeAttributes
{
    return @{
            @"bezel-color": [CPColor clearColor],
            @"border-width" : 1.0,
            @"border-color": [CPColor clearColor],
            @"content-inset": CGInsetMakeZero(),
            @"bezel-inset": CGInsetMakeZero(),
            @"datepicker-textfield-bezel-color": [CPColor clearColor],
            @"min-size-datepicker-textfield": CGSizeMakeZero(),
            @"content-inset-datepicker-textfield": CGInsetMakeZero(),
            @"content-inset-datepicker-textfield-separator": CGInsetMakeZero(),
            @"separator-content-inset": CGInsetMakeZero(),
            @"date-hour-margin": 5.0,
            @"stepper-margin": 5.0,
            @"bezel-color-calendar": [CPColor clearColor],
            @"title-text-color": [CPColor blackColor],
            @"title-text-shadow-color": [CPColor clearColor],
            @"title-text-shadow-offset": CGSizeMakeZero(),
            @"title-font": [CPNull null],
            @"weekday-text-color": [CPColor blackColor],
            @"weekday-text-shadow-color": [CPColor clearColor],
            @"weekday-text-shadow-offset": CGSizeMakeZero(),
            @"weekday-font": [CPNull null],
            @"arrow-image-left": [CPNull null],
            @"arrow-image-right": [CPNull null],
            @"arrow-image-left-highlighted": [CPNull null],
            @"arrow-image-right-highlighted": [CPNull null],
            @"arrow-inset": CGInsetMakeZero(),
            @"circle-image": [CPNull null],
            @"circle-image-highlighted": [CPNull null],
            @"tile-text-color": [CPColor blackColor],
            @"tile-text-shadow-color": [CPColor clearColor],
            @"tile-text-shadow-offset": CGSizeMakeZero(),
            @"tile-font": [CPNull null],
            @"size-tile": CGSizeMakeZero(),
            @"size-calendar": CGSizeMakeZero(),
            @"size-header": CGSizeMakeZero(),
            @"min-size-calendar": CGSizeMakeZero(),
            @"max-size-calendar": CGSizeMakeZero(),
            @"bezel-color-clock": [CPColor clearColor],
            @"clock-text-color": [CPColor blackColor],
            @"clock-text-shadow-color": [CPColor clearColor],
            @"clock-text-shadow-offset": CGSizeMakeZero(),
            @"clock-font": [CPNull null],
            @"second-hand-image": [CPNull null],
            @"hour-hand-image": [CPNull null],
            @"middle-hand-image": [CPNull null],
            @"minute-hand-image": [CPNull null],
            @"size-clock": CGSizeMakeZero(),
            @"second-hand-size": CGSizeMakeZero(),
            @"hour-hand-size": CGSizeMakeZero(),
            @"middle-hand-size": CGSizeMakeZero(),
            @"minute-hand-size": CGSizeMakeZero(),
    };
}


#pragma mark -
#pragma mark Binding methods

+ (Class)_binderClassForBinding:(CPString)theBinding
{
    if (theBinding == CPValueBinding || theBinding == CPMinValueBinding || theBinding == CPMaxValueBinding)
        return [_CPDatePickerValueBinder class];

    return [super _binderClassForBinding:theBinding];
}

- (CPString)_replacementKeyPathForBinding:(CPString)aBinding
{
    if (aBinding == CPValueBinding)
        return @"dateValue";

    if (aBinding == CPMinValueBinding)
        return @"minDate";

    if (aBinding == CPMaxValueBinding)
        return @"maxDate";

    return [super _replacementKeyPathForBinding:aBinding];
}


#pragma mark -
#pragma mark Init methods

- (id)initWithFrame:(CGRect)aFrame
{
    if (self = [super initWithFrame:aFrame])
    {
        _drawsBackground = YES;
        _datePickerStyle = CPTextFieldAndStepperDatePickerStyle;
        _datePickerMode = CPSingleDateMode;
        _datePickerElements = CPYearMonthDayDatePickerElementFlag | CPHourMinuteSecondDatePickerElementFlag;
        _timeInterval = 0;
        _implementedCDatePickerDelegateMethods = 0;

        [self setObjectValue:[CPDate date]];
        _minDate = [CPDate distantPast];
        _maxDate = [CPDate distantFuture];

        [self setBezeled:YES];
        [self setBordered:YES];

        [self _init];
    }

    return self
}

- (void)_init
{
    if (!_locale)
        _locale = [CPLocale currentLocale];

    _datePickerTextfield = [[_CPDatePickerTextField alloc] initWithFrame:[self bounds] withDatePicker:self];
    [_datePickerTextfield setDateValue:_dateValue];

    _datePickerCalendar = [[_CPDatePickerCalendar alloc] initWithFrame:[self bounds] withDatePicker:self];
    [_datePickerCalendar setDateValue:_dateValue];

    // We might have been unarchived in a disabled state.
    [_datePickerTextfield setEnabled:[self isEnabled]];

    [self setNeedsDisplay:YES];
    [self setNeedsLayout];
}


#pragma mark -
#pragma mark Control Size

- (void)setControlSize:(CPControlSize)aControlSize
{
    [super setControlSize:aControlSize];

    if ([self datePickerStyle] == CPTextFieldAndStepperDatePickerStyle || [self datePickerStyle] == CPTextFieldDatePickerStyle)
        [self _sizeToControlSize];
}


#pragma mark -
#pragma mark Delegate methods

- (void)setDelegate:(id)aDelegate
{
    _delegate = aDelegate;
    _implementedCDatePickerDelegateMethods = 0;

    // Look if the delegate implements or not the delegate methods
    if ([_delegate respondsToSelector:@selector(datePicker:validateProposedDateValue:timeInterval:)])
        _implementedCDatePickerDelegateMethods |= CPDatePicker_validateProposedDateValue_timeInterval;
}


#pragma mark -
#pragma mark Layout method

- (void)layoutSubviews
{
    [super layoutSubviews];

    if (_datePickerStyle == CPTextFieldAndStepperDatePickerStyle || _datePickerStyle == CPTextFieldDatePickerStyle)
    {
        if (![_datePickerTextfield superview])
            [self addSubview:_datePickerTextfield];

        if ([_datePickerCalendar superview])
            [_datePickerCalendar removeFromSuperview];

        [_datePickerTextfield setControlSize:[self controlSize]];
        [_datePickerTextfield setNeedsLayout];
        [_datePickerTextfield setNeedsDisplay:YES];
    }
    else
    {
        if (![_datePickerCalendar superview])
            [self addSubview:_datePickerCalendar];

        if ([_datePickerTextfield superview])
            [_datePickerTextfield removeFromSuperview];

        [_datePickerCalendar setNeedsLayout];
        [_datePickerCalendar setNeedsDisplay:YES];
    }
}

#pragma mark -
#pragma mark Setter

- (id)objectValue
{
    // TODO : add timeZone effect. How to do it because js ???
    return _dateValue
}

- (void)setObjectValue:(CPDate)aValue
{
    if (![aValue isKindOfClass:[CPDate class]])
        return;

    [self setDateValue:aValue];
}

/* Set the dateValue of the datePicker
    @param aDateValue the dateValue
*/
- (void)setDateValue:(CPDate)aDateValue
{
    if (aDateValue == nil)
        return;

    _invokedByUserEvent = NO;
    [self _setDateValue:aDateValue timeInterval:_timeInterval];
}

- (void)_setDateValue:(CPDate)aDateValue timeInterval:(CPTimeInterval)aTimeInterval
{
    // Make sure to have a valid date and avoid NaN values
    if (!isFinite(aDateValue))
    {
        [CPException raise:CPInvalidArgumentException
                    reason:@"aDateValue is not valid"];
        return;
    }

    if (_minDate)
        aDateValue = new Date (MAX(aDateValue, _minDate));

    if (_maxDate)
        aDateValue = new Date (MIN(aDateValue, _maxDate));

    aTimeInterval = MAX(MIN(aTimeInterval, [_maxDate timeIntervalSinceDate:aDateValue]), [_minDate timeIntervalSinceDate:aDateValue]);

    if ([aDateValue isEqualToDate:_dateValue] && aTimeInterval == _timeInterval)
    {
        if (_datePickerStyle == CPTextFieldAndStepperDatePickerStyle || _datePickerStyle == CPTextFieldDatePickerStyle)
            [_datePickerTextfield setDateValue:_dateValue];
        else
            [_datePickerCalendar setDateValue:_dateValue];

        return;
    }

    if (_implementedCDatePickerDelegateMethods & CPDatePicker_validateProposedDateValue_timeInterval)
    {
        // constrain timeInterval also
        var aStartDateRef = function(x){if (typeof x == 'undefined') return aDateValue; aDateValue = x;};
        var aTimeIntervalRef = function(x){if (typeof x == 'undefined') return aTimeInterval; aTimeInterval = x;};

        [_delegate datePicker:self validateProposedDateValue:aStartDateRef timeInterval:aTimeIntervalRef];
    }

    [self willChangeValueForKey:@"objectValue"];
    [self willChangeValueForKey:@"dateValue"];
    _dateValue = aDateValue;
    [super setObjectValue:_dateValue];
    [self didChangeValueForKey:@"objectValue"];
    [self didChangeValueForKey:@"dateValue"];

    [self willChangeValueForKey:@"timeInterval"];
    _timeInterval = (_datePickerMode == CPSingleDateMode)? 0 : aTimeInterval;
    [self didChangeValueForKey:@"timeInterval"];

    if (_invokedByUserEvent)
        [self sendAction:[self action] to:[self target]];

    if (_datePickerStyle == CPTextFieldAndStepperDatePickerStyle || _datePickerStyle == CPTextFieldDatePickerStyle)
        [_datePickerTextfield setDateValue:_dateValue];
    else
        [_datePickerCalendar setDateValue:_dateValue];
}

- (void)setMinDate:(CPDate)aMinDate
{
    [self willChangeValueForKey:@"minDate"];
    _minDate = aMinDate;
    [self didChangeValueForKey:@"minDate"];

    [self _setDateValue:_dateValue timeInterval:_timeInterval];
}

- (void)setMaxDate:(CPDate)aMaxDate
{
    [self willChangeValueForKey:@"maxDate"];
    _maxDate = aMaxDate;
    [self didChangeValueForKey:@"maxDate"];

    [self _setDateValue:_dateValue timeInterval:_timeInterval];
}

- (void)setDatePickerStyle:(CPInteger)aDatePickerStyle
{
    _datePickerStyle = aDatePickerStyle;

    [self setControlSize:[self controlSize]];

    [self setNeedsDisplay:YES];
    [self setNeedsLayout];
}

- (void)setDatePickerElements:(CPInteger)aDatePickerElements
{
    _datePickerElements = aDatePickerElements;

    [self setNeedsDisplay:YES];
    [self setNeedsLayout];
}

- (void)setDatePickerMode:(CPInteger)aDatePickerMode
{
    _datePickerMode = aDatePickerMode;

    if (_datePickerMode == CPSingleDateMode)
        [self _setDateValue:[self dateValue] timeInterval:0];

    [self setNeedsDisplay:YES];
    [self setNeedsLayout];
}

- (void)setTimeInterval:(CPInteger)aTimeInterval
{
    if (_datePickerMode == CPSingleDateMode)
        return;

    [self _setDateValue:[self dateValue] timeInterval:aTimeInterval];
}

- (void)setLocale:(CPLocale)aLocale
{
    _locale = aLocale;

    if (_formatter)
    {
        [self willChangeValueForKey:@"locale"];
        [_formatter setLocale:_locale];
        [self didChangeValueForKey:@"locale"];
    }

    // This will update the textFields (usefull when changing with a date with pm and am)
    [_datePickerTextfield setDateValue:_dateValue];
    [self setNeedsDisplay:YES];
    [self setNeedsLayout];
}

- (void)setBezeled:(BOOL)shouldBeBezeled
{
    _isBezeled = shouldBeBezeled;

    if (shouldBeBezeled)
        [self setThemeState:CPThemeStateBezeled];
    else
        [self unsetThemeState:CPThemeStateBezeled];
}

- (void)setBordered:(BOOL)shouldBeBordered
{
    _isBordered = shouldBeBordered;

    if (shouldBeBordered)
        [self setThemeState:CPThemeStateBordered];
    else
        [self unsetThemeState:CPThemeStateBordered];
}

- (void)setTextFont:(CPFont)aFont
{
    [self setFont:aFont];
}

- (void)setEnabled:(BOOL)aBoolean
{
    [super setEnabled:aBoolean];

    [_datePickerTextfield setEnabled:aBoolean];
    [_datePickerCalendar setEnabled:aBoolean];
}

- (void)setBackgroundColor:(CPColor)aColor
{
    _backgroundColor = aColor;
    [self setNeedsLayout];
}

- (void)setDrawsBackground:(BOOL)aBoolean
{
    [self willChangeValueForKey:@"drawsBackground"];
    _drawsBackground = aBoolean;
    [self didChangeValueForKey:@"drawsBackground"];

    [self setNeedsLayout];
}

- (void)setTimeZone:(CPTimeZone)aTimeZone
{
    [self willChangeValueForKey:@"timeZone"];
    _timeZone = aTimeZone;
    [self didChangeValueForKey:@"timeZone"];

    [self setNeedsLayout];

    if (_datePickerStyle == CPTextFieldAndStepperDatePickerStyle || _datePickerStyle == CPTextFieldDatePickerStyle)
        [_datePickerTextfield setDateValue:_dateValue];
    else
        [_datePickerCalendar setDateValue:_dateValue];
}


#pragma mark -
#pragma mark First responder methods

- (BOOL)becomeFirstResponder
{
    if (_datePickerStyle == CPTextFieldAndStepperDatePickerStyle || _datePickerStyle == CPTextFieldDatePickerStyle)
    {
        if (![super becomeFirstResponder])
            return NO;

        [_datePickerTextfield _selectTextFieldWithFlags:[[CPApp currentEvent] modifierFlags]];

        return YES;
    }

    return NO;
}

- (BOOL)acceptsFirstResponder
{
    return YES;
}

- (BOOL)resignFirstResponder
{
    if (_datePickerStyle == CPTextFieldAndStepperDatePickerStyle || _datePickerStyle == CPTextFieldDatePickerStyle)
        [_datePickerTextfield resignFirstResponder];

    return YES;
}


#pragma mark -
#pragma mark getter

- (BOOL)isBezeled
{
    return [self hasThemeState:CPThemeStateBezeled];
}

- (BOOL)isBordered
{
    return [self hasThemeState:CPThemeStateBordered];
}

- (CPFont)textFont
{
    return [self font];
}

- (BOOL)_isAmericanFormat
{
    return [[_locale objectForKey:CPLocaleCountryCode] isEqualToString:@"US"];
}

#pragma mark -
#pragma mark Key event

- (void)keyDown:(CPEvent)anEvent
{
    if (_datePickerStyle == CPTextFieldAndStepperDatePickerStyle || _datePickerStyle == CPTextFieldDatePickerStyle)
        [_datePickerTextfield keyDown:anEvent];
}

@end

var CPDatePickerModeKey         = @"CPDatePickerModeKey",
    CPIntervalKey               = @"CPIntervalKey",
    CPMinDateKey                = @"CPMinDateKey",
    CPMaxDateKey                = @"CPMaxDateKey",
    CPBackgroundColorKey        = @"CPBackgroundColorKey",
    CPDrawsBackgroundKey        = @"CPDrawsBackgroundKey",
    CPTextFontKey               = @"CPTextFontKey",
    CPDatePickerElementsKey     = @"CPDatePickerElementsKey",
    CPDatePickerStyleKey        = @"CPDatePickerStyleKey",
    CPLocaleKey                 = @"CPLocaleKey",
    CPBorderedKey               = @"CPBorderedKey",
    CPDateValueKey              = @"CPDateValueKey";

@implementation CPDatePicker (CPCoding)

- (id)initWithCoder:(CPCoder)aCoder
{
    self = [super initWithCoder:aCoder];

    if (self)
    {
        _textFont = [aCoder decodeObjectForKey:CPTextFontKey];
        _minDate = [aCoder decodeObjectForKey:CPMinDateKey] || [CPDate distantPast];
        _maxDate = [aCoder decodeObjectForKey:CPMaxDateKey] || [CPDate distantFuture];
        _timeInterval = [aCoder decodeDoubleForKey:CPIntervalKey];
        _datePickerMode = [aCoder decodeIntForKey:CPDatePickerModeKey];
        _datePickerElements = [aCoder decodeIntForKey:CPDatePickerElementsKey];
        [self setDatePickerStyle:[aCoder decodeIntForKey:CPDatePickerStyleKey]];
        _locale = [aCoder decodeObjectForKey:CPLocaleKey];
        _dateValue = [aCoder decodeObjectForKey:CPDateValueKey];
        _backgroundColor = [aCoder decodeObjectForKey:CPBackgroundColorKey];
        _drawsBackground = [aCoder decodeBoolForKey:CPDrawsBackgroundKey];
        _isBordered = [aCoder decodeBoolForKey:CPBorderedKey];

        [self _init];
    }

    return self
}

- (void)encodeWithCoder:(CPCoder)aCoder
{
    // FIXME Do we need to encode _datePickerTextfield and _datePickerCalendar? As subviews they'll be encoded, but when we decode we recreate them anyhow.
    [super encodeWithCoder:aCoder];

    [aCoder encodeDouble:_timeInterval forKey:CPIntervalKey];
    [aCoder encodeInt:_datePickerMode forKey:CPDatePickerModeKey];
    [aCoder encodeInt:_datePickerStyle forKey:CPDatePickerStyleKey];
    [aCoder encodeInt:_datePickerElements forKey:CPDatePickerElementsKey];
    [aCoder encodeObject:_minDate forKey:CPMinDateKey];
    [aCoder encodeObject:_maxDate forKey:CPMaxDateKey];
    [aCoder encodeObject:_dateValue forKey:CPDateValueKey];;
    [aCoder encodeObject:_textFont forKey:CPTextFontKey];
    [aCoder encodeObject:_locale forKey:CPLocaleKey];
    [aCoder encodeObject:_backgroundColor forKey:CPBackgroundColorKey];
    [aCoder encodeObject:_drawsBackground forKey:CPDrawsBackgroundKey];
    [aCoder encodeObject:_isBordered forKey:CPBorderedKey];

}

@end
@implementation _CPDatePickerValueBinder : CPBinder
{
    id __doxygen__;
}

@end

@implementation CPDate (CPDatePickerAdditions)

- (int)_daysInMonth
{
    return 32 - new Date(self.getFullYear(), self.getMonth(), 32).getDate();
}

- (void)_resetToMidnight
{
    self.setHours(0);
    self.setMinutes(0);
    self.setSeconds(0);
    self.setMilliseconds(0);
}

- (void)_resetToLastSeconds
{
    self.setHours(23);
    self.setMinutes(59);
    self.setSeconds(59);
    self.setMilliseconds(99);
}

@end

@implementation CPDatePicker (CPSynthesizedAccessors)

- (BOOL)isBordered
{
    return _isBordered;
}

- (void)setBordered:(BOOL)aValue
{
    _isBordered = aValue;
}

- (BOOL)isBezeled
{
    return _isBezeled;
}

- (void)setBezeled:(BOOL)aValue
{
    _isBezeled = aValue;
}

- (BOOL)drawsBackground
{
    return _drawsBackground;
}

- (void)setDrawsBackground:(BOOL)aValue
{
    _drawsBackground = aValue;
}

- (CPDate)dateValue
{
    return _dateValue;
}

- (void)setDateValue:(CPDate)aValue
{
    _dateValue = aValue;
}

- (CPDate)minDate
{
    return _minDate;
}

- (void)setMinDate:(CPDate)aValue
{
    _minDate = aValue;
}

- (CPDate)maxDate
{
    return _maxDate;
}

- (void)setMaxDate:(CPDate)aValue
{
    _maxDate = aValue;
}

- (CPFont)textFont
{
    return _textFont;
}

- (void)setTextFont:(CPFont)aValue
{
    _textFont = aValue;
}

- (CPLocale)locale
{
    return _locale;
}

- (void)setLocale:(CPLocale)aValue
{
    _locale = aValue;
}

- (CPCalendar)calendar
{
    return _calendar;
}

- (void)setCalendar:(CPCalendar)aValue
{
    _calendar = aValue;
}

- (CPTimeZone)timeZone
{
    return _timeZone;
}

- (void)setTimeZone:(CPTimeZone)aValue
{
    _timeZone = aValue;
}

- (id)delegate
{
    return _delegate;
}

- (void)setDelegate:(id)aValue
{
    _delegate = aValue;
}

- (CPInteger)datePickerElements
{
    return _datePickerElements;
}

- (void)setDatePickerElements:(CPInteger)aValue
{
    _datePickerElements = aValue;
}

- (CPInteger)datePickerMode
{
    return _datePickerMode;
}

- (void)setDatePickerMode:(CPInteger)aValue
{
    _datePickerMode = aValue;
}

- (CPInteger)datePickerStyle
{
    return _datePickerStyle;
}

- (void)setDatePickerStyle:(CPInteger)aValue
{
    _datePickerStyle = aValue;
}

- (CPInteger)timeInterval
{
    return _timeInterval;
}

- (void)setTimeInterval:(CPInteger)aValue
{
    _timeInterval = aValue;
}

@end