CPSearchField.j

Go to the documentation of this file.

/*
 * CPSearchField.j
 * AppKit
 *
 * Created by cacaodev.
 * Copyright 2009.
 *
 * 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 CPApp

CPSearchFieldRecentsTitleMenuItemTag    = 1000;
CPSearchFieldRecentsMenuItemTag         = 1001;
CPSearchFieldClearRecentsMenuItemTag    = 1002;
CPSearchFieldNoRecentsMenuItemTag       = 1003;

var CPAutosavedRecentsChangedNotification = @"CPAutosavedRecentsChangedNotification";

@implementation CPSearchField : CPTextField
{
    CPButton    _searchButton;
    CPButton    _cancelButton;
    CPMenu      _searchMenuTemplate;
    CPMenu      _searchMenu;

    CPString    _recentsAutosaveName;
    CPArray     _recentSearches;

    int         _maximumRecents;
    BOOL        _sendsWholeSearchString;
    BOOL        _sendsSearchStringImmediately;
    BOOL        _canResignFirstResponder;
    CPTimer     _partialStringTimer;
}

+ (CPString)defaultThemeClass
{
    return @"searchfield"
}

+ (CPDictionary)themeAttributes
{
    return @{
            @"image-search": [CPNull null],
            @"image-find": [CPNull null],
            @"image-cancel": [CPNull null],
            @"image-cancel-pressed": [CPNull null],
            @"image-search-inset" : CGInsetMake(0, 0, 0, 5),
            @"image-cancel-inset" : CGInsetMake(0, 5, 0, 0),
            @"search-menu-offset": CGPointMake(10, -4),
            @"search-right-margin": 2
        };
}

+ (Class)_binderClassForBinding:(CPString)aBinding
{
    if (aBinding === CPPredicateBinding)
        return [_CPSearchFieldPredicateBinder class];

    return [super _binderClassForBinding:aBinding];
}

- (id)initWithFrame:(CGRect)frame
{
    if (self = [super initWithFrame:frame])
    {
        _maximumRecents = 10;
        _sendsWholeSearchString = NO;
        _sendsSearchStringImmediately = NO;
        _recentsAutosaveName = nil;

        [self _init];
    }

    return self;
}

- (void)_init
{
    _recentSearches = [CPArray array];

    [self setBezeled:YES];
    [self setBezelStyle:CPTextFieldRoundedBezel];
    [self setBordered:YES];
    [self setEditable:YES];
    [self setContinuous:YES];

    var bounds = [self bounds],
        cancelButton = [[CPButton alloc] initWithFrame:[self cancelButtonRectForBounds:bounds]],
        searchButton = [[CPButton alloc] initWithFrame:[self searchButtonRectForBounds:bounds]];

    [self setCancelButton:cancelButton];
    [self resetCancelButton];

    [self setSearchButton:searchButton];
    [self resetSearchButton];

    _canResignFirstResponder = YES;
}


#pragma mark -
#pragma mark Override observers

- (void)_removeObservers
{
    if (!_isObserving)
        return;

    [super _removeObservers];

    [[CPNotificationCenter defaultCenter] removeObserver:self name:CPControlTextDidChangeNotification object:self];
}

- (void)_addObservers
{
    if (_isObserving)
        return;

    [super _addObservers];

    [[CPNotificationCenter defaultCenter] addObserver:self selector:@selector(_searchFieldTextDidChange:) name:CPControlTextDidChangeNotification object:self];
}

// Managing Buttons
- (void)setSearchButton:(CPButton)button
{
    if (button != _searchButton)
    {
        [_searchButton removeFromSuperview];
        _searchButton = button;

        [_searchButton setFrame:[self searchButtonRectForBounds:[self bounds]]];
        [_searchButton setAutoresizingMask:CPViewMaxXMargin];
        [self addSubview:_searchButton];
    }
}

- (CPButton)searchButton
{
    return _searchButton;
}

- (void)resetSearchButton
{
    var button = [self searchButton],
        searchButtonImage = (_searchMenuTemplate === nil) ? [self currentValueForThemeAttribute:@"image-search"] : [self currentValueForThemeAttribute:@"image-find"];

    [button setBordered:NO];
    [button setImageScaling:CPImageScaleAxesIndependently];
    [button setImage:searchButtonImage];
    [button setAutoresizingMask:CPViewMaxXMargin];
}

- (void)setCancelButton:(CPButton)button
{
    if (button != _cancelButton)
    {
        [_cancelButton removeFromSuperview];
        _cancelButton = button;

        [_cancelButton setFrame:[self cancelButtonRectForBounds:[self bounds]]];
        [_cancelButton setAutoresizingMask:CPViewMinXMargin];
        [_cancelButton setTarget:self];
        [_cancelButton setAction:@selector(cancelOperation:)];
        [_cancelButton setButtonType:CPMomentaryChangeButton];
        [self _updateCancelButtonVisibility];
        [self addSubview:_cancelButton];
    }
}

- (CPButton)cancelButton
{
    return _cancelButton;
}

- (void)resetCancelButton
{
    var button = [self cancelButton];
    [button setBordered:NO];
    [button setImageScaling:CPImageScaleAxesIndependently];
    [button setImage:[self valueForThemeAttribute:@"image-cancel"]];
    [button setAlternateImage:[self valueForThemeAttribute:@"image-cancel-pressed"]];
    [button setAutoresizingMask:CPViewMinXMargin];
    [button setTarget:self];
    [button setAction:@selector(cancelOperation:)];
}

// Custom Layout
- (CGRect)searchTextRectForBounds:(CGRect)rect
{
    var leftOffset = 0,
        width = CGRectGetWidth(rect),
        bounds = [self bounds];

    if (_searchButton)
    {
        var searchBounds = [self searchButtonRectForBounds:bounds],
            rightMargin  = [self currentValueForThemeAttribute:@"search-right-margin"];
        leftOffset = CGRectGetMaxX(searchBounds) + rightMargin;
    }

    if (_cancelButton)
    {
        var cancelRect = [self cancelButtonRectForBounds:bounds];
        width = CGRectGetMinX(cancelRect) - leftOffset;
    }

    return CGRectMake(leftOffset, CGRectGetMinY(rect), width, CGRectGetHeight(rect));
}

- (CGRect)searchButtonRectForBounds:(CGRect)rect
{
    var size = [[self currentValueForThemeAttribute:@"image-search"] size] || CGSizeMakeZero(),
        inset = [self currentValueForThemeAttribute:@"image-search-inset"];

    return CGRectMake(inset.left - inset.right, inset.top - inset.bottom + (CGRectGetHeight(rect) - size.height) / 2, size.width, size.height);
}

- (CGRect)cancelButtonRectForBounds:(CGRect)rect
{
    var size = [[self currentValueForThemeAttribute:@"image-cancel"] size] || CGSizeMakeZero(),
        inset = [self currentValueForThemeAttribute:@"image-cancel-inset"];

    return CGRectMake(CGRectGetWidth(rect) - size.width + inset.left - inset.right, inset.top - inset.bottom + (CGRectGetHeight(rect) - size.width) / 2, size.height, size.height);
}

// Managing Menu Templates
- (CPMenu)searchMenuTemplate
{
    return _searchMenuTemplate;
}

- (void)setSearchMenuTemplate:(CPMenu)aMenu
{
    _searchMenuTemplate = aMenu;

    [self resetSearchButton];
    [self _loadRecentSearchList];
    [self _updateSearchMenu];
}

// Managing Search Modes
- (BOOL)sendsWholeSearchString
{
    return _sendsWholeSearchString;
}

- (void)setSendsWholeSearchString:(BOOL)flag
{
    _sendsWholeSearchString = flag;
}

- (BOOL)sendsSearchStringImmediately
{
    return _sendsSearchStringImmediately;
}

- (void)setSendsSearchStringImmediately:(BOOL)flag
{
    _sendsSearchStringImmediately = flag;
}

// Managing Recent Search Strings
- (int)maximumRecents
{
    return _maximumRecents;
}

- (void)setMaximumRecents:(int)max
{
    if (max > 254)
        max = 254;
    else if (max < 0)
        max = 10;

    _maximumRecents = max;
}

- (CPArray)recentSearches
{
    return _recentSearches;
}

- (void)setRecentSearches:(CPArray)searches
{
    var max = MIN([self maximumRecents], [searches count]);

    searches = [searches subarrayWithRange:CPMakeRange(0, max)];
    _recentSearches = searches;
    [self _autosaveRecentSearchList];
}

- (CPString)recentsAutosaveName
{
    return _recentsAutosaveName;
}

- (void)setRecentsAutosaveName:(CPString)name
{
    if (_recentsAutosaveName != nil)
        [self _deregisterForAutosaveNotification];

    _recentsAutosaveName = name;

    if (_recentsAutosaveName != nil)
      [self _registerForAutosaveNotification];
}

// Private methods and subclassing

- (CGRect)contentRectForBounds:(CGRect)bounds
{
    var superbounds = [super contentRectForBounds:bounds];
    return [self searchTextRectForBounds:superbounds];
}

+ (double)_keyboardDelayForPartialSearchString:(CPString)string
{
    return (6 - MIN([string length], 4)) / 10;
}

- (CPMenu)menu
{
    return _searchMenu;
}

- (BOOL)isOpaque
{
  return [super isOpaque] && [_cancelButton isOpaque] && [_searchButton isOpaque];
}

- (void)_updateCancelButtonVisibility
{
    [_cancelButton setHidden:([[self stringValue] length] === 0)];
}

- (void)_searchFieldTextDidChange:(CPNotification)aNotification
{
    if (![self sendsWholeSearchString])
    {
        if ([self sendsSearchStringImmediately])
            [self _sendPartialString];
        else
        {
            [_partialStringTimer invalidate];
            var timeInterval = [CPSearchField _keyboardDelayForPartialSearchString:[self stringValue]];

            _partialStringTimer = [CPTimer scheduledTimerWithTimeInterval:timeInterval
                                                                   target:self
                                                                 selector:@selector(_sendPartialString)
                                                                 userInfo:nil
                                                                  repeats:NO];
        }
    }

    [self _updateCancelButtonVisibility];
}

- (void)_sendAction:(id)sender
{
    [self sendAction:[self action] to:[self target]];
}

- (BOOL)sendAction:(SEL)anAction to:(id)anObject
{
    [super sendAction:anAction to:anObject];

    [_partialStringTimer invalidate];

    [self _addStringToRecentSearches:[self stringValue]];
    [self _updateCancelButtonVisibility];
}

- (void)_addStringToRecentSearches:(CPString)string
{
    if (string === nil || string === @"" || [_recentSearches containsObject:string])
        return;

    var searches = [CPMutableArray arrayWithArray:_recentSearches];
    [searches addObject:string];
    [self setRecentSearches:searches];
    [self _updateSearchMenu];
}

- (CPView)hitTest:(CGPoint)aPoint
{
    // Make sure a hit anywhere within the search field returns the search field itself
    if (CGRectContainsPoint([self frame], aPoint))
        return self;
    else
        return nil;
}

- (BOOL)resignFirstResponder
{
    return _canResignFirstResponder && [super resignFirstResponder];
}

- (void)mouseDown:(CPEvent)anEvent
{
    var location = [anEvent locationInWindow],
        point = [self convertPoint:location fromView:nil];

    if (CGRectContainsPoint([self searchButtonRectForBounds:[self bounds]], point))
    {
        if (_searchMenuTemplate == nil)
        {
            if ([_searchButton target] && [_searchButton action])
                [_searchButton mouseDown:anEvent];
            else
                [self _sendAction:self];
        }
        else
           [self _showMenu];
    }
    else if (CGRectContainsPoint([self cancelButtonRectForBounds:[self bounds]], point))
        [_cancelButton mouseDown:anEvent];
    else
        [super mouseDown:anEvent];
}

- (CPMenu)defaultSearchMenuTemplate
{
    var template = [[CPMenu alloc] init],
        item;

    item = [[CPMenuItem alloc] initWithTitle:@"Clear"
                                      action:@selector(_searchFieldClearRecents:)
                               keyEquivalent:@""];
    [item setTag:CPSearchFieldClearRecentsMenuItemTag];
    [item setTarget:self];
    [template addItem:item];

    item = [[CPMenuItem alloc] initWithTitle:@"Recent Searches"
                                      action:nil
                               keyEquivalent:@""];
    [item setTag:CPSearchFieldRecentsTitleMenuItemTag];
    [item setEnabled:NO];
    [template addItem:item];

    item = [[CPMenuItem alloc] initWithTitle:@"Recent search item"
                                      action:@selector(_searchFieldSearch:)
                               keyEquivalent:@""];
    [item setTag:CPSearchFieldRecentsMenuItemTag];
    [item setTarget:self];
    [template addItem:item];

    return template;
}

- (void)_updateSearchMenu
{
    if (_searchMenuTemplate === nil)
        return;

    var menu = [[CPMenu alloc] init],
        countOfRecents = [_recentSearches count],
        numberOfItems = [_searchMenuTemplate numberOfItems];

    [menu setAutoenablesItems:NO];

    for (var i = 0; i < numberOfItems; i++)
    {
        var item = [[_searchMenuTemplate itemAtIndex:i] copy];

        switch ([item tag])
        {
            case CPSearchFieldRecentsTitleMenuItemTag:
                if (countOfRecents === 0)
                    continue;

                if ([menu numberOfItems] > 0)
                    [self _addSeparatorToMenu:menu];
                break;

            case CPSearchFieldRecentsMenuItemTag:
            {
                var itemAction = @selector(_searchFieldSearch:);

                for (var recentIndex = 0; recentIndex < countOfRecents; ++recentIndex)
                {
                    var recentItem = [[CPMenuItem alloc] initWithTitle:[_recentSearches objectAtIndex:recentIndex]
                                                                 action:itemAction
                                                          keyEquivalent:[item keyEquivalent]];
                    [item setTarget:self];
                    [menu addItem:recentItem];
                }

                continue;
            }

            case CPSearchFieldClearRecentsMenuItemTag:
                if (countOfRecents === 0)
                    continue;

                if ([menu numberOfItems] > 0)
                    [self _addSeparatorToMenu:menu];

                [item setAction:@selector(_searchFieldClearRecents:)];
                [item setTarget:self];
                break;

            case CPSearchFieldNoRecentsMenuItemTag:
                if (countOfRecents !== 0)
                    continue;

                if ([menu numberOfItems] > 0)
                    [self _addSeparatorToMenu:menu];
                break;
            }

        [item setEnabled:([item isEnabled] && [item action] != nil && [item target] != nil)];
        [menu addItem:item];
    }

    [menu setDelegate:self];

    _searchMenu = menu;
}

- (void)_addSeparatorToMenu:(CPMenu)aMenu
{
    var separator = [CPMenuItem separatorItem];
    [separator setEnabled:NO];
    [aMenu addItem:separator];
}

- (void)menuWillOpen:(CPMenu)menu
{
    _canResignFirstResponder = NO;
}

- (void)menuDidClose:(CPMenu)menu
{
    _canResignFirstResponder = YES;

    [self becomeFirstResponder];
}

- (void)_showMenu
{
    if (_searchMenu === nil || [_searchMenu numberOfItems] === 0 || ![self isEnabled] || ([_recentSearches count] === 0))
        return;

    var aFrame = [[self superview] convertRect:[self frame] toView:nil],
        offset = [self currentValueForThemeAttribute:@"search-menu-offset"],
        location = CGPointMake(aFrame.origin.x + offset.x, aFrame.origin.y + aFrame.size.height + offset.y);

    var anEvent = [CPEvent mouseEventWithType:CPRightMouseDown location:location modifierFlags:0 timestamp:[[CPApp currentEvent] timestamp] windowNumber:[[self window] windowNumber] context:nil eventNumber:1 clickCount:1 pressure:0];

    [self selectAll:nil];
    [CPMenu popUpContextMenu:_searchMenu withEvent:anEvent forView:self];
}

- (void)_sendPartialString
{
    [super sendAction:[self action] to:[self target]];
    [_partialStringTimer invalidate];
}

- (void)cancelOperation:(id)sender
{
    [self setObjectValue:@""];
    [self textDidChange:[CPNotification notificationWithName:CPControlTextDidChangeNotification object:self userInfo:nil]];

    [self _updateCancelButtonVisibility];
}

- (void)_searchFieldSearch:(id)sender
{
    var searchString = [sender title];

    if ([sender tag] != CPSearchFieldRecentsMenuItemTag)
        [self _addStringToRecentSearches:searchString];

    [self setObjectValue:searchString];
    [self _sendPartialString];
    [self selectAll:nil];

    [self _updateCancelButtonVisibility];
}

- (void)_searchFieldClearRecents:(id)sender
{
    [self setRecentSearches:[CPArray array]];
    [self _updateSearchMenu];
    [self setStringValue:@""];
    [self _updateCancelButtonVisibility];
 }

- (void)_registerForAutosaveNotification
{
    [[CPNotificationCenter defaultCenter] addObserver:self selector:@selector(_updateAutosavedRecents:) name:CPAutosavedRecentsChangedNotification object:_recentsAutosaveName];
}

- (void)_deregisterForAutosaveNotification
{
    [[CPNotificationCenter defaultCenter] removeObserver:self name:CPAutosavedRecentsChangedNotification object:_recentsAutosaveName];
}

- (void)_autosaveRecentSearchList
{
    if (_recentsAutosaveName != nil)
        [[CPNotificationCenter defaultCenter] postNotificationName:CPAutosavedRecentsChangedNotification object:_recentsAutosaveName];
}

- (void)_updateAutosavedRecents:(id)notification
{
    var name = [notification object];
    [[CPUserDefaults standardUserDefaults] setObject:_recentSearches forKey:name];
}

- (void)_loadRecentSearchList
{
    var name = [self recentsAutosaveName];
    if (name === nil)
        return;

    var list = [[CPUserDefaults standardUserDefaults] objectForKey:name];

    if (list !== nil)
        _recentSearches = list;
}

- (void)unbind:(CPString)aBinding
{
    [super unbind:aBinding];

    // our CPPredicateBinding binder adds a binding to the value.
    // this private binding has to be also removed
    if (aBinding === CPPredicateBinding)
        [[[self class] _binderClassForBinding:aBinding] unbind:CPValueBinding forObject:self];
}

@end

#pragma mark -

@implementation CPSearchField (CPTrackingArea)
{
    CPTrackingArea      _searchButtonTrackingArea;
    CPTrackingArea      _cancelButtonTrackingArea;
}

- (void)updateTrackingAreas
{
    if (_searchButtonTrackingArea)
    {
        [self removeTrackingArea:_searchButtonTrackingArea];
        _searchButtonTrackingArea = nil;
    }

    if (_cancelButtonTrackingArea)
    {
        [self removeTrackingArea:_cancelButtonTrackingArea];
        _cancelButtonTrackingArea = nil;
    }

    if (_searchButton)
    {
        _searchButtonTrackingArea = [[CPTrackingArea alloc] initWithRect:[_searchButton frame]
                                                                 options:CPTrackingCursorUpdate | CPTrackingActiveInKeyWindow
                                                                   owner:self
                                                                userInfo:@{ @"isButton": YES }];

        [self addTrackingArea:_searchButtonTrackingArea];
    }

    if (_cancelButton)
    {
        _cancelButtonTrackingArea = [[CPTrackingArea alloc] initWithRect:[_cancelButton frame]
                                                                 options:CPTrackingCursorUpdate | CPTrackingActiveInKeyWindow
                                                                   owner:self
                                                                userInfo:@{ @"isButton": YES }];

        [self addTrackingArea:_cancelButtonTrackingArea];
    }

    [super updateTrackingAreas];
}

- (void)cursorUpdate:(CPEvent)anEvent
{
    if ([[[anEvent trackingArea] userInfo] objectForKey:@"isButton"])
        [[CPCursor arrowCursor] set];
    else
        [super cursorUpdate:anEvent];
}

@end

#pragma mark -

var CPRecentsAutosaveNameKey            = @"CPRecentsAutosaveNameKey",
    CPSendsWholeSearchStringKey         = @"CPSendsWholeSearchStringKey",
    CPSendsSearchStringImmediatelyKey   = @"CPSendsSearchStringImmediatelyKey",
    CPMaximumRecentsKey                 = @"CPMaximumRecentsKey",
    CPSearchMenuTemplateKey             = @"CPSearchMenuTemplateKey";

@implementation CPSearchField (CPCoding)

- (void)encodeWithCoder:(CPCoder)coder
{
    [_searchButton removeFromSuperview];
    [_cancelButton removeFromSuperview];

    [super encodeWithCoder:coder];

    if (_searchButton)
        [self addSubview:_searchButton];
    if (_cancelButton)
        [self addSubview:_cancelButton];

    [coder encodeBool:_sendsWholeSearchString forKey:CPSendsWholeSearchStringKey];
    [coder encodeBool:_sendsSearchStringImmediately forKey:CPSendsSearchStringImmediatelyKey];
    [coder encodeInt:_maximumRecents forKey:CPMaximumRecentsKey];

    if (_recentsAutosaveName)
        [coder encodeObject:_recentsAutosaveName forKey:CPRecentsAutosaveNameKey];

    if (_searchMenuTemplate)
        [coder encodeObject:_searchMenuTemplate forKey:CPSearchMenuTemplateKey];
}

- (id)initWithCoder:(CPCoder)coder
{
    if (self = [super initWithCoder:coder])
    {
        [self setRecentsAutosaveName:[coder decodeObjectForKey:CPRecentsAutosaveNameKey]];
        _sendsWholeSearchString   = [coder decodeBoolForKey:CPSendsWholeSearchStringKey];
        _sendsSearchStringImmediately = [coder decodeBoolForKey:CPSendsSearchStringImmediatelyKey];
        _maximumRecents           = [coder decodeIntForKey:CPMaximumRecentsKey];

        var template              = [coder decodeObjectForKey:CPSearchMenuTemplateKey];

        if (template)
            [self setSearchMenuTemplate:template];

        [self _init];
    }

    return self;
}

@end

@implementation _CPSearchFieldPredicateBinder : CPBinder
{
    CPArrayController  _controller;
    CPString           _predicateFormat;
}

- (void)setValue:(id)aValue forBinding:(CPString)aBinding
{
    if (aBinding === CPPredicateBinding)
    {
        var options = [_info objectForKey:CPOptionsKey];

        _controller = [_info objectForKey:CPObservedObjectKey];
        _predicateFormat = [options objectForKey:"CPPredicateFormat"];
        [_source bind:CPValueBinding toObject:self withKeyPath:"searchFieldValue" options:nil];
    }
}

- (void)setSearchFieldValue:(CPString)aValue
{
    var destination = [_info objectForKey:CPObservedObjectKey],
        keyPath     = [_info objectForKey:CPObservedKeyPathKey];

    var formatString = _predicateFormat.replace(/\$value/g, "%@");
    [self suppressSpecificNotificationFromObject:destination keyPath:keyPath];

    if (aValue)
        [_controller setFilterPredicate:[CPPredicate predicateWithFormat:formatString, aValue]];
    else
        [_controller setFilterPredicate:nil];

    [self unsuppressSpecificNotificationFromObject:destination keyPath:keyPath];
}
- (CPString)searchFieldValue
{
    return [_source stringValue];
}

@end