CPRuleEditor.j

Go to the documentation of this file.

/*
 * CPRuleEditor.j
 * AppKit
 *
 * Created by cacaodev.
 * Copyright 2011, cacaodev.
 *
 * 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 CPDirectPredicateModifier
@global CPCaseInsensitivePredicateOption
@global CPOrPredicateType

@protocol CPRuleEditorDelegate <CPObject>

@required
- (id)ruleEditor:(CPRuleEditor)editor child:(CPInteger)index forCriterion:(id)criterion withRowType:(CPRuleEditorRowType)rowType;
- (id)ruleEditor:(CPRuleEditor)editor displayValueForCriterion:(id)criterion inRow:(CPInteger)row;
- (CPInteger)ruleEditor:(CPRuleEditor)editor numberOfChildrenForCriterion:(id)criterion withRowType:(CPRuleEditorRowType)rowType;

@optional
- (CPDictionary)ruleEditor:(CPRuleEditor)editor predicatePartsForCriterion:(id)criterion withDisplayValue:(id)value inRow:(CPInteger)row;
- (void)ruleEditorRowsDidChange:(CPNotification)notification;

@end

var CPRuleEditorDelegate_ruleEditor_predicatePartsForCriterion_withDisplayValue_inRow_   = 1 << 1;

var CPRuleEditorItemPBoardType  = @"CPRuleEditorItemPBoardType",
    itemsContext                = "items",
    valuesContext               = "values",
    subrowsContext              = "subrows_array",
    boundArrayContext           = "bound_array";

@implementation CPRuleEditor : CPControl
{
    BOOL                        _suppressKeyDownHandling;
    BOOL                        _allowsEmptyCompoundRows;
    BOOL                        _disallowEmpty;
    BOOL                        _delegateWantsValidation;
    BOOL                        _editable;
    BOOL                        _sendAction;

    Class                       _rowClass;

    CPIndexSet                  _draggingRows;
    CPInteger                   _subviewIndexOfDropLine;
    CPView                      _dropLineView;

    CPMutableArray              _rowCache;
    CPMutableArray              _slices;

    CPPredicate                 _predicate;

    CPString                    _itemsKeyPath;
    CPString                    _subrowsArrayKeyPath;
    CPString                    _typeKeyPath;
    CPString                    _valuesKeyPath;
    CPString                    _boundArrayKeyPath;

    CPView                      _slicesHolder;
    CPViewAnimation             _currentAnimation;

    CPInteger                   _lastRow;
    CPInteger                   _nestingMode;

    float                       _alignmentGridWidth;
    float                       _sliceHeight;

    id                          _ruleDataSource;
    id <CPRuleEditorDelegate>   _ruleDelegate;
    id                          _boundArrayOwner;
    unsigned                    _implementedDelegateMethods;

    CPString                    _stringsFilename;

    BOOL                        _isKeyDown;
    BOOL                        _nestingModeDidChange;

    _CPRuleEditorLocalizer      _standardLocalizer;
    CPDictionary                _itemsAndValuesToAddForRowType;
}

+ (CPString)defaultThemeClass
{
    return @"rule-editor";
}

+ (CPDictionary)themeAttributes
{
    return @{
            @"alternating-row-colors": [CPNull null],
            @"selected-color": [CPNull null],
            @"slice-top-border-color": [CPNull null],
            @"slice-bottom-border-color": [CPNull null],
            @"slice-last-bottom-border-color": [CPNull null],
            @"font": [CPFont systemFontOfSize:12],
            @"font-color": [CPNull null],
            @"add-image": [CPNull null],
            @"remove-image": [CPNull null],
            @"vertical-alignment": [CPNull null]
        };
}

- (id)initWithFrame:(CGRect)frame
{
    self = [super initWithFrame:frame];
    if (self !== nil)
    {
        _slices = [[CPMutableArray alloc] init];

        _sliceHeight = 26.0;
        _nestingMode = CPRuleEditorNestingModeSimple; // 10.5 default is CPRuleEditorNestingModeCompound
        _editable = YES;
        _allowsEmptyCompoundRows = NO;
        _disallowEmpty = NO;

        [self setFormattingStringsFilename:nil];
        [self setCriteriaKeyPath:@"criteria"];
        [self setSubrowsKeyPath:@"subrows"];
        [self setRowTypeKeyPath:@"rowType"];
        [self setDisplayValuesKeyPath:@"displayValues"];
        [self setBoundArrayKeyPath:@"boundArray"];

        _slicesHolder = [[_CPRuleEditorViewSliceHolder alloc] initWithFrame:[self bounds]];
        [self addSubview:_slicesHolder];

        _boundArrayOwner = [[_CPRuleEditorViewUnboundRowHolder alloc] init];

        [self _initRuleEditorShared];
    }

    return self;
}

- (void)_initRuleEditorShared
{
    _rowCache = [[CPMutableArray alloc] init];
    _rowClass = [_CPRuleEditorRowObject class];
    _isKeyDown = NO;
    _subviewIndexOfDropLine = CPNotFound;
    _lastRow = 0;
    _delegateWantsValidation = YES;
    _suppressKeyDownHandling = NO;
    _nestingModeDidChange = NO;
    _sendAction = YES;
    _itemsAndValuesToAddForRowType = {};
    var animation = [[CPViewAnimation alloc] initWithDuration:0.5 animationCurve:CPAnimationEaseInOut];
    [self setAnimation:animation];

    [_slicesHolder setAutoresizingMask:CPViewWidthSizable | CPViewHeightSizable];

    _dropLineView =  [self _createSliceDropSeparator];
    [_slicesHolder addSubview:_dropLineView];

    [self registerForDraggedTypes:[CPArray arrayWithObjects:CPRuleEditorItemPBoardType,nil]];
    [_boundArrayOwner addObserver:self forKeyPath:_boundArrayKeyPath options:CPKeyValueObservingOptionOld | CPKeyValueObservingOptionNew context:boundArrayContext];
}

- (id)delegate
{
     return _ruleDelegate;
}

- (void)setDelegate:(id <CPRuleEditorDelegate>)aDelegate
{
    if (_ruleDelegate === aDelegate)
        return;

    var nc = [CPNotificationCenter defaultCenter];

    if (_ruleDelegate)
        [nc removeObserver:_ruleDelegate name:nil object:self];

    _ruleDelegate = aDelegate;
    _implementedDelegateMethods = 0;

    if ([_ruleDelegate respondsToSelector:@selector(ruleEditorRowsDidChange:)])
        [nc addObserver:_ruleDelegate selector:@selector(ruleEditorRowsDidChange:) name:CPRuleEditorRowsDidChangeNotification object:nil];

    if ([_ruleDelegate respondsToSelector:@selector(ruleEditor:predicatePartsForCriterion:withDisplayValue:inRow:)])
        _implementedDelegateMethods |= CPRuleEditorDelegate_ruleEditor_predicatePartsForCriterion_withDisplayValue_inRow_;
}
- (BOOL)isEditable
{
    return _editable;
}

- (void)setEditable:(BOOL)editable
{
    if (editable === _editable)
        return;

    _editable = editable;

    if (!_editable)
        [self _deselectAll];

    [_slices makeObjectsPerformSelector:@selector(setEditable:) withObject:_editable];
}

- (CPRuleEditorNestingMode)nestingMode
{
     return _nestingMode;
}

- (void)setNestingMode:(CPRuleEditorNestingMode)mode
{
    if (mode !== _nestingMode)
    {
        _nestingMode = mode;
        if ([self numberOfRows] > 0)
            _nestingModeDidChange = YES;
    }
}

- (BOOL)canRemoveAllRows
{
    return !_disallowEmpty;
}

- (void)setCanRemoveAllRows:(BOOL)canRemove
{
    _disallowEmpty = !canRemove;
    [self _updateButtonVisibilities];
}

- (BOOL)allowsEmptyCompoundRows
{
    return _allowsEmptyCompoundRows;
}

- (void)setAllowsEmptyCompoundRows:(BOOL)allows
{
    _allowsEmptyCompoundRows = allows;
    [self _updateButtonVisibilities];
}

- (CPInteger)rowHeight
{
    return _sliceHeight;
}

- (void)setRowHeight:(float)height
{
    if (height === _sliceHeight)
        return;

    _sliceHeight = MAX([self _minimumFrameHeight], height);
    [self _reconfigureSubviewsAnimate:NO];
}

- (CPDictionary)formattingDictionary
{
    return [_standardLocalizer dictionary];
}

- (void)setFormattingDictionary:(CPDictionary)dictionary
{
    [_standardLocalizer setDictionary:dictionary];
    _stringsFilename = nil;
}

- (CPString)formattingStringsFilename
{
    return _stringsFilename;
}

- (void)setFormattingStringsFilename:(CPString)stringsFilename
{
    if (_standardLocalizer === nil)
        _standardLocalizer = [_CPRuleEditorLocalizer new];

    if (_stringsFilename !== stringsFilename)
    {
        // Convert an empty string to nil
        _stringsFilename = stringsFilename || nil;

        if (stringsFilename !== nil)
        {
            if (![stringsFilename hasSuffix:@".strings"])
                stringsFilename = stringsFilename + @".strings";

            var path = [[CPBundle mainBundle] pathForResource:stringsFilename];

            if (path !== nil)
                [_standardLocalizer loadContentOfURL:[CPURL URLWithString:path]];
        }
    }
}

- (void)reloadCriteria
{
    var current_rows = [_boundArrayOwner valueForKey:_boundArrayKeyPath];
    [self _stopObservingRowObjectsRecursively:current_rows];
    [_boundArrayOwner setValue:[CPArray arrayWithArray:current_rows] forKey:_boundArrayKeyPath];
}

- (void)setCriteria:(CPArray)criteria andDisplayValues:(CPArray)values forRowAtIndex:(int)rowIndex
{
    if (criteria === nil || values === nil)
        [CPException raise:CPInvalidArgumentException reason:_cmd + @". criteria and values parameters must not be nil."];

    if (rowIndex < 0 || rowIndex >= [self numberOfRows])
        [CPException raise:CPRangeException reason:_cmd + @". rowIndex is out of bounds."];

    var rowObject = [[self _rowCacheForIndex:rowIndex] rowObject];

    [rowObject setValue:criteria forKey:_itemsKeyPath];
    [rowObject setValue:values forKey:_valuesKeyPath];

    [self reloadCriteria];
}

- (id)criteriaForRow:(CPInteger)row
{
    var rowcache = [self _rowCacheForIndex:row];
    if (rowcache)
        return [[rowcache rowObject] valueForKey:_itemsKeyPath];

    return nil;
}

- (CPMutableArray)displayValuesForRow:(CPInteger)row
{
    var rowcache = [self _rowCacheForIndex:row];
    if (rowcache)
        return [[rowcache rowObject] valueForKey:_valuesKeyPath];

    return nil;
}

- (int)numberOfRows
{
     return [_slices count];
}

- (int)parentRowForRow:(CPInteger)rowIndex
{
    if (rowIndex < 0 || rowIndex >= [self numberOfRows])
        [CPException raise:CPRangeException reason:_cmd + @" row " + rowIndex + " is out of range"];

    var targetObject = [[self _rowCacheForIndex:rowIndex] rowObject];

    for (var current_index = 0; current_index < rowIndex; current_index++)
    {
        if ([self rowTypeForRow:current_index] === CPRuleEditorRowTypeCompound)
        {
            var candidate = [[self _rowCacheForIndex:current_index] rowObject],
                subObjects = [[self _subrowObjectsOfObject:candidate] _representedObject];

            if ([subObjects indexOfObjectIdenticalTo:targetObject] !== CPNotFound)
                return current_index;
        }
    }

    return -1;
}

/*
TODO: implement
    Returns the index of the row containing a given value.

    displayValue The display value (string, view, or menu item) of an item in the receiver. This value must not be nil.

    The index of the row containing displayValue, or CPNotFound.

    This method searches each row via objects equality for the given display value, which may be present as an alternative in a popup menu for that row.

- (CPInteger)rowForDisplayValue:(id)displayValue
*/

- (CPRuleEditorRowType)rowTypeForRow:(CPInteger)rowIndex
{
    if (rowIndex < 0 || rowIndex > [self numberOfRows])
        [CPException raise:CPRangeException reason:_cmd + @"row " + rowIndex + " is out of range"];

    var rowcache = [self _rowCacheForIndex:rowIndex];
    if (rowcache)
    {
        var rowobject = [rowcache rowObject];
        return [rowobject valueForKey:_typeKeyPath];
    }

    return CPNotFound;
}

- (CPIndexSet)subrowIndexesForRow:(CPInteger)rowIndex
{
    var object;

    if (rowIndex === -1)
        object = _boundArrayOwner;
    else
        object = [[self _rowCacheForIndex:rowIndex] rowObject];

    var subobjects = [self _subrowObjectsOfObject:object],
        objectsCount = [subobjects count],
        indexes = [CPMutableIndexSet indexSet],
        count = [self numberOfRows];

    for (var i = rowIndex + 1; i < count; i++)
    {
        var candidate = [[self _rowCacheForIndex:i] rowObject],
            indexInSubrows = [[subobjects _representedObject] indexOfObjectIdenticalTo:candidate];

        if (indexInSubrows !== CPNotFound)
        {
            [indexes addIndex:i];
            objectsCount--;

            if ([self rowTypeForRow:i] === CPRuleEditorRowTypeCompound)
                i += [[self subrowIndexesForRow:i] count];
        }

        if (objectsCount === 0)
            break;
    }

    return indexes;
}

- (CPIndexSet)selectedRowIndexes
{
    return [self _selectedSliceIndices];
}

- (void)selectRowIndexes:(CPIndexSet)indexes byExtendingSelection:(BOOL)extend
{
    var count = [_slices count],
        lastSelected = [indexes lastIndex];

    if (lastSelected >= [self numberOfRows])
        [CPException raise:CPRangeException reason:@"row indexes " + indexes + " are out of range"];

    if (!extend)
        [self _deselectAll];

    while (count--)
    {
        var slice = _slices[count],
            rowIndex = [slice rowIndex],
            contains = [indexes containsIndex:rowIndex],
            shouldSelect = (contains && !(extend && [slice _isSelected]));

        if (contains)
            [slice _setSelected:shouldSelect];
        [slice _setLastSelected:(rowIndex === lastSelected)];
        [slice setNeedsDisplay:YES];
    }
}

- (void)addRow:(id)sender
{
    var parentRowIndex = -1,
        rowtype,
        numberOfRows = [self numberOfRows],
        hasRows = (numberOfRows > 0),
        nestingMode = [self _applicableNestingMode];

    switch (nestingMode)
    {
        case CPRuleEditorNestingModeSimple:
            rowtype = hasRows ? CPRuleEditorRowTypeSimple : CPRuleEditorRowTypeCompound;
            if (hasRows)
                parentRowIndex = 0;
            break;
        case CPRuleEditorNestingModeSingle:
             if (hasRows)
                return;
        case CPRuleEditorNestingModeList:
            rowtype = CPRuleEditorRowTypeSimple;
            break;
        case CPRuleEditorNestingModeCompound:
            rowtype = CPRuleEditorRowTypeCompound;
            if (hasRows)
                parentRowIndex = 0;
            break;
        default:
            [CPException raise:CPInvalidArgumentException reason:@"Not supported CPRuleEditorNestingMode " + nestingMode];
        // Compound mode: parentRowIndex=(lastRowType === CPRuleEditorRowTypeCompound)?lastRow :[self parentRowForRow:lastRow]; break;
    }

    [self insertRowAtIndex:numberOfRows withType:rowtype asSubrowOfRow:parentRowIndex animate:YES];
}

- (void)insertRowAtIndex:(int)rowIndex withType:(unsigned int)rowType asSubrowOfRow:(CPInteger)parentRow animate:(BOOL)shouldAnimate
{
/*
    TODO: raise exceptions if parentRow is greater than or equal to rowIndex, or if rowIndex would fall amongst the children of some other parent, or if the nesting mode forbids this configuration.
*/
    var newObject = [self _insertNewRowAtIndex:rowIndex ofType:rowType withParentRow:parentRow];

    if (rowType === CPRuleEditorRowTypeCompound && !_allowsEmptyCompoundRows)
    {
        var subrow = [self _insertNewRowAtIndex:(rowIndex + 1) ofType:CPRuleEditorRowTypeSimple withParentRow:rowIndex];
    }
}

- (void)removeRowAtIndex:(int)rowIndex
{
    //  TO DO : Any subrows of the deleted row are adopted by the parent of the deleted row, or are made root rows.

    if (rowIndex < 0 || rowIndex >= [self numberOfRows])
        [CPException raise:CPRangeException reason:@"row " + rowIndex + " is out of range"];

    [self removeRowsAtIndexes:[CPIndexSet indexSetWithIndex:rowIndex] includeSubrows:NO];
}

- (void)removeRowsAtIndexes:(CPIndexSet)rowIndexes includeSubrows:(BOOL)includeSubrows
{
    if ([rowIndexes count] === 0)
        return;

    if ([rowIndexes lastIndex] >= [self numberOfRows])
        [CPException raise:CPRangeException reason:@"rows indexes " + rowIndexes + " are out of range"];

    var current_index = [rowIndexes firstIndex],
        parentRowIndex = [self parentRowForRow:current_index],
        childsIndexes = [CPMutableIndexSet indexSet],
        subrows;

    if (parentRowIndex === -1)
        subrows = [self _rootRowsArray];
    else
    {
        var parentRowObject = [[self _rowCacheForIndex:parentRowIndex] rowObject];
        subrows = [self _subrowObjectsOfObject:parentRowObject];
    }

    while (current_index !== CPNotFound)
    {
        var rowObject = [[self _rowCacheForIndex:current_index] rowObject],
            relativeChildIndex = [[subrows _representedObject] indexOfObjectIdenticalTo:rowObject];

        if (relativeChildIndex !== CPNotFound)
            [childsIndexes addIndex:relativeChildIndex];

        if (includeSubrows && [self rowTypeForRow:current_index] === CPRuleEditorRowTypeCompound)
        {
            var more_childs = [self subrowIndexesForRow:current_index];
            [self removeRowsAtIndexes:more_childs includeSubrows:includeSubrows];
        }

        current_index = [rowIndexes indexGreaterThanIndex:current_index];
    }

    [subrows removeObjectsAtIndexes:childsIndexes];
}

- (CPPredicate)predicate
{
    return _predicate;
}

- (void)reloadPredicate
{
    [self _updatePredicate];
}

- (CPPredicate)predicateForRow:(CPInteger)aRow
{
    var predicateParts = @{},
        items = [self criteriaForRow:aRow],
        count = [items count],
        predicate,
        i;

    for (i = 0; i < count; i++)
    {
        var item = [items objectAtIndex:i],
        //var displayValue = [self _queryValueForItem:item inRow:aRow]; Ask the delegate or get cached value ?.
            displayValue = [[self displayValuesForRow:aRow] objectAtIndex:i],
            predpart = [self _sendDelegateRuleEditorPredicatePartsForCriterion:item withDisplayValue:displayValue inRow:aRow];

        if (predpart)
            [predicateParts addEntriesFromDictionary:predpart];
    }

    if ([self rowTypeForRow:aRow] === CPRuleEditorRowTypeCompound)
    {
        var compoundPredicate,
            subpredicates = [CPMutableArray array],
            subrowsIndexes = [self subrowIndexesForRow:aRow];

        if ([subrowsIndexes count] === 0)
            return nil;

        var current_index = [subrowsIndexes firstIndex];
        while (current_index !== CPNotFound)
        {
            var subpredicate = [self predicateForRow:current_index];
            if (subpredicate !== nil)
                [subpredicates addObject:subpredicate];

            current_index = [subrowsIndexes indexGreaterThanIndex:current_index];
        }

        var compoundType = [predicateParts objectForKey:CPRuleEditorPredicateCompoundType];

        if ([subpredicates count] === 0)
            return nil;
        else
        {
            try
            {
                compoundPredicate = [[CPCompoundPredicate alloc ] initWithType:compoundType subpredicates:subpredicates];
            }
            catch(error)
            {
                CPLogConsole(@"Compound predicate error: [%@]\npredicateType:%i", [error description], compoundType);
                compoundPredicate = nil;
            }
            finally
            {
                return compoundPredicate;
            }

        }
    }

    var lhs = [predicateParts objectForKey:CPRuleEditorPredicateLeftExpression],
        rhs = [predicateParts objectForKey:CPRuleEditorPredicateRightExpression],
        operator = [predicateParts objectForKey:CPRuleEditorPredicateOperatorType],
        options  = [predicateParts objectForKey:CPRuleEditorPredicateOptions],
        modifier = [predicateParts objectForKey:CPRuleEditorPredicateComparisonModifier],
        selector = CPSelectorFromString([predicateParts objectForKey:CPRuleEditorPredicateCustomSelector]);

    if (lhs === nil)
    {
        CPLogConsole(@"missing left expression in predicate parts dictionary");
        return NULL;
    }

    if (rhs === nil)
    {
        CPLogConsole(@"missing right expression in predicate parts dictionary");
        return NULL;
    }

    if (selector === nil && operator === nil)
    {
        CPLogConsole(@"missing operator and selector in predicate parts dictionary");
        return NULL;
    }

    if (modifier === nil)
        CPLogConsole(@"missing modifier in predicate parts dictionary. Setting default: CPDirectPredicateModifier");

    if (options === nil)
        CPLogConsole(@"missing options in predicate parts dictionary. Setting default: CPCaseInsensitivePredicateOption");

    try
    {
        if (selector !== nil)
            predicate = [CPComparisonPredicate predicateWithLeftExpression:lhs
                                                           rightExpression:rhs
                                                            customSelector:selector
                         ];
        else
            predicate = [CPComparisonPredicate predicateWithLeftExpression:lhs
                                                           rightExpression:rhs
                                                                  modifier:(modifier || CPDirectPredicateModifier)
                                                                      type:operator
                                                                   options:(options || CPCaseInsensitivePredicateOption)
                         ];
    }
    catch(error)
    {
        CPLogConsole(@"Row predicate error: [" + [error description] + "] for row " + aRow);
        predicate = nil;
    }
    finally
    {
        return predicate;
    }
}

- (Class)rowClass
{
    return _rowClass;
}

- (void)setRowClass:(Class)rowClass
{
    if (rowClass === [CPMutableDictionary class])
        rowClass = [_CPRuleEditorRowObject class];

    _rowClass = rowClass;
}

- (CPString)rowTypeKeyPath
{
    return _typeKeyPath;
}

- (void)setRowTypeKeyPath:(CPString)keyPath
{
    if (_typeKeyPath !== keyPath)
        _typeKeyPath = keyPath;
}

- (CPString)subrowsKeyPath
{
    return _subrowsArrayKeyPath;
}

- (void)setSubrowsKeyPath:(CPString)keyPath
{
    if (_subrowsArrayKeyPath !== keyPath)
        _subrowsArrayKeyPath = keyPath;
}

- (CPString)criteriaKeyPath
{
    return _itemsKeyPath;
}

- (void)setCriteriaKeyPath:(CPString)keyPath
{
    if (_itemsKeyPath !== keyPath)
        _itemsKeyPath = keyPath;
}

- (CPString)displayValuesKeyPath
{
    return _valuesKeyPath;
}

- (void)setDisplayValuesKeyPath:(CPString)keyPath
{
    if (_valuesKeyPath !== keyPath)
        _valuesKeyPath = keyPath;
}

- (id)animation
{
    return _currentAnimation;
}

- (void)setAnimation:(CPViewAnimation)animation
{
    _currentAnimation = animation;
    [_currentAnimation setDelegate:self];
}

- (BOOL)acceptsFirstResponder
{
    return YES;
}

- (void)keyDown:(CPEvent)event
{
    if (!_suppressKeyDownHandling && [self _applicableNestingMode] === CPRuleEditorNestingModeCompound && !_isKeyDown && ([event modifierFlags] & CPAlternateKeyMask))
    {
        [_slices makeObjectsPerformSelector:@selector(_configurePlusButtonByRowType:) withObject:CPRuleEditorRowTypeCompound];
    }

    _isKeyDown = YES;
}

- (void)keyUp:(CPEvent)event
{
    if (!_suppressKeyDownHandling)
    {
        [_slices makeObjectsPerformSelector:@selector(_configurePlusButtonByRowType:) withObject:CPRuleEditorRowTypeSimple];
    }

    _isKeyDown = NO;
}

- (_CPRuleEditorViewSliceDropSeparator)_createSliceDropSeparator
{
    var view = [[_CPRuleEditorViewSliceDropSeparator alloc] initWithFrame:CGRectMake(0, -10, [self frame].size.width, 2)];
    [view setAutoresizingMask:CPViewWidthSizable];
    return view;
}

- (BOOL)_suppressKeyDownHandling
{
    return _suppressKeyDownHandling;
}

- (BOOL)_wantsRowAnimations
{
    return (_currentAnimation !== nil);
}

- (void)_updateButtonVisibilities
{
    [_slices makeObjectsPerformSelector:@selector(_updateButtonVisibilities)];
}

- (float)_alignmentGridWidth
{
    return  _alignmentGridWidth;
}

- (float)_minimumFrameHeight
{
    return 26.;
}

- (CPRuleEditorNestingMode)_applicableNestingMode
{
    if (!_nestingModeDidChange)
        return _nestingMode;

    var a = (_nestingMode === CPRuleEditorNestingModeCompound || _nestingMode === CPRuleEditorNestingModeSimple),
        b = ([self rowTypeForRow:0] === CPRuleEditorRowTypeCompound);

    if (a === b)
        return _nestingMode;

    return a ? CPRuleEditorNestingModeList : CPRuleEditorNestingModeSimple;
}

- (BOOL)_shouldHideAddButtonForSlice:(id)slice
{
    return (!_editable || [self _applicableNestingMode] === CPRuleEditorNestingModeSingle);
}

- (BOOL)_shouldHideSubtractButtonForSlice:(id)slice
{
    if (!_editable)
        return YES;

    if (!_disallowEmpty)
        return NO;

    var shouldHide,
        rowIndex = [slice rowIndex],
        parentIndex = [self parentRowForRow:rowIndex],
        subrowsIndexes = [self subrowIndexesForRow:parentIndex],
        nestingMode = [self _applicableNestingMode];

    switch (nestingMode)
    {
        case CPRuleEditorNestingModeCompound:
        case CPRuleEditorNestingModeSimple: shouldHide = ([subrowsIndexes count] === 1 && !_allowsEmptyCompoundRows) || parentIndex === -1;
                break;
        case CPRuleEditorNestingModeList: shouldHide = ([self numberOfRows] === 1);
                break;
        case CPRuleEditorNestingModeSingle: shouldHide = YES;
                break;
        default: shouldHide = NO;
    }

    return shouldHide;
}

#pragma mark Rows management

- (id)_rowCacheForIndex:(int)index
{
    return [_rowCache objectAtIndex:index];
}

- (id)_searchCacheForRowObject:(id)rowObject
{
    var count = [_rowCache count],
        i;

    for (i = 0; i < count; i++)
    {
         var cache = _rowCache[i];
         if ([cache rowObject] === rowObject)
              return cache;
    }

    return nil;
}

- (int)_rowIndexForRowObject:(id)rowobject
{
    if (rowobject === _boundArrayOwner)
        return -1;

    return [[self _searchCacheForRowObject:rowobject] rowIndex]; // Pas bon car le rowIndex du row cache n'est pas synchro avec la position dans _rowCache.
}

- (CPMutableArray)_subrowObjectsOfObject:(id)object
{
    if (object === _boundArrayOwner)
        return [self _rootRowsArray];

    return [object mutableArrayValueForKey:_subrowsArrayKeyPath];
}

- (CPIndexSet)_childlessParentsIfSlicesWereDeletedAtIndexes:(id)indexes
{
    var childlessParents = [CPIndexSet indexSet],
        current_index = [indexes firstIndex];

    while (current_index !== CPNotFound)
    {
        var parentIndex = [self parentRowForRow:current_index],
            subrowsIndexes = [self subrowIndexesForRow:parentIndex];

        if ([subrowsIndexes count] === 1)
        {
            if (parentIndex !== -1)
                return [CPIndexSet indexSetWithIndex:0];

            var childlessGranPa = [self _childlessParentsIfSlicesWereDeletedAtIndexes:[CPIndexSet indexSetWithIndex:parentIndex]];
            [childlessParents addIndexes:childlessGranPa];
        }

        current_index = [indexes indexGreaterThanIndex:current_index];
    }

    return childlessParents;
    // (id)-[RuleEditor _includeSubslicesForSlicesAtIndexes:]
}

- (CPIndexSet)_includeSubslicesForSlicesAtIndexes:(CPIndexSet)indexes
{
    var subindexes = [indexes copy],
        current_index = [indexes firstIndex];

    while (current_index !== CPNotFound)
    {
        var sub = [self subrowIndexesForRow:current_index];
        [subindexes addIndexes:[self _includeSubslicesForSlicesAtIndexes:sub]];
        current_index = [indexes indexGreaterThanIndex:current_index];
    }

    return subindexes;
}

- (void)_deleteSlice:(id)slice
{
    var rowindexes = [CPIndexSet indexSetWithIndex:[slice rowIndex]];

    if (!_allowsEmptyCompoundRows)
    {
        var childlessIndexes = [self _childlessParentsIfSlicesWereDeletedAtIndexes:rowindexes];
        if ([childlessIndexes count] > 0)
            rowindexes = childlessIndexes;
    }

    [self removeRowsAtIndexes:rowindexes includeSubrows:YES];

    [self _updatePredicate];
    [self _sendRuleAction];
    [self _postRuleOptionChangedNotification];
    [self _postRowCountChangedNotificationOfType:CPRuleEditorRowsDidChangeNotification indexes:rowindexes];
}

- (CPArray)_rootRowsArray
{
    return [_boundArrayOwner mutableArrayValueForKey:_boundArrayKeyPath];
}

- (BOOL)_nextUnusedItems:(CPArray)items andValues:(CPArray)values forRow:(CPInteger)rowIndex forRowType:(unsigned int)type
{
    var parentItem = [items lastObject], // if empty items array, this is NULL aka the root item;
        childrenCount = [self _queryNumberOfChildrenOfItem:parentItem withRowType:type],
        foundIndex = CPNotFound;

    if (childrenCount === 0)
        return NO;

    var current_criterions = [CPMutableArray array],
        count = [self numberOfRows],
        row;

    for (row = 0; row < count; row++) // num of rows should be num of siblings of parentItem
    {
        var aCriteria = [self criteriaForRow:row],
            itemIndex = [items count];

        if ([self rowTypeForRow:row] === type && itemIndex < [aCriteria count])
        {
            var crit = [aCriteria objectAtIndex:itemIndex];
            [current_criterions addObject:crit];
        }
    }

    while (foundIndex === CPNotFound)
    {
        var buffer = [CPMutableArray arrayWithArray:current_criterions],
            i;
        for (i = 0; i < childrenCount; i++)
        {
            var child =  [self _queryChild:i ofItem:parentItem withRowType:type];
            if ([current_criterions indexOfObject:child] === CPNotFound)
            {
                foundIndex = i;
                break;
            }
        }

        if (foundIndex === CPNotFound)
        {
            for (var k = 0; k < childrenCount; k++)
            {
                var anobject = [self _queryChild:k ofItem:parentItem withRowType:type],
                    index = [buffer indexOfObject:anobject];
                if (index !== CPNotFound)
                    [buffer removeObjectAtIndex:index];
            }

            current_criterions = buffer;
        }
    }

    var foundItem = [self _queryChild:foundIndex ofItem:parentItem withRowType:type],
        foundValue = [self _queryValueForItem:foundItem inRow:rowIndex];

    [items addObject:foundItem];
    [values addObject:foundValue];

    return YES;
}

- (CPMutableArray)_getItemsAndValuesToAddForRow:(CPInteger)rowIndex ofType:(CPRuleEditorRowType)type
{
    //var cachedItemsAndValues = _itemsAndValuesToAddForRowType[type];
    //if (cachedItemsAndValues)
    //    return cachedItemsAndValues;

    var itemsAndValues = [CPMutableArray array],
        items = [CPMutableArray array],
        values = [CPMutableArray array],
        unusedItems = YES;

    while (unusedItems)
        unusedItems = [self _nextUnusedItems:items andValues:values forRow:rowIndex forRowType:type];

    var count = [items count];

    for (var i = 0; i < count; i++)
    {
        var item = [items objectAtIndex:i],
            value = [values objectAtIndex:i],
            itemAndValue = @{
                    "item": item,
                    "value": value,
                };

        [itemsAndValues addObject:itemAndValue];
    }

    return itemsAndValues;
}

- (void)_addOptionFromSlice:(id)slice ofRowType:(unsigned int)type
{
    // for CPRuleEditorNestingModeSimple only

    var rowIndexEvent = [slice rowIndex],
        rowTypeEvent = [self rowTypeForRow:rowIndexEvent],
        insertIndex = rowIndexEvent + 1,
        parentRowIndex = (rowTypeEvent === CPRuleEditorRowTypeCompound) ? rowIndexEvent:[self parentRowForRow:rowIndexEvent];

    [self insertRowAtIndex:insertIndex withType:type asSubrowOfRow:parentRowIndex animate:YES];
}

- (id)_insertNewRowAtIndex:(int)insertIndex ofType:(CPRuleEditorRowType)rowtype withParentRow:(CPInteger)parentRowIndex
{
    var row = [[[self rowClass] alloc] init],
        itemsandvalues = [self _getItemsAndValuesToAddForRow:insertIndex ofType:rowtype],
        newitems = [itemsandvalues valueForKey:@"item"],
        newvalues = [itemsandvalues valueForKey:@"value"];

    [row setValue:newitems forKey:_itemsKeyPath];
    [row setValue:newvalues forKey:_valuesKeyPath];
    [row setValue:rowtype forKey:_typeKeyPath];
    [row setValue:[CPMutableArray array] forKey:_subrowsArrayKeyPath];

    var subrowsObjects;
    if (parentRowIndex === -1 || [self _applicableNestingMode] === CPRuleEditorNestingModeList)
        subrowsObjects = [self _rootRowsArray];
    else
    {
        var parentRowObject = [[self _rowCacheForIndex:parentRowIndex] rowObject];
        subrowsObjects = [self _subrowObjectsOfObject:parentRowObject];
    }

    var relInsertIndex = insertIndex - parentRowIndex - 1;
    [subrowsObjects insertObject:row atIndex:relInsertIndex];

    [self _updatePredicate];
    [self _sendRuleAction];
    [self _postRuleOptionChangedNotification];
    [self _postRowCountChangedNotificationOfType:CPRuleEditorRowsDidChangeNotification indexes:[CPIndexSet indexSetWithIndex:insertIndex]];

    return row;
}

#pragma mark Key value observing

- (void)_startObservingRowObjectsRecursively:(CPArray)rowObjects
{
    [_boundArrayOwner addObserver:self forKeyPath:_boundArrayKeyPath options:CPKeyValueObservingOptionOld | CPKeyValueObservingOptionNew context:boundArrayContext];

    var count = [rowObjects count];

    for (var i = 0; i < count; i++)
    {
        var rowObject = [rowObjects objectAtIndex:i];

        [rowObject addObserver:self forKeyPath:_itemsKeyPath options:CPKeyValueObservingOptionOld | CPKeyValueObservingOptionNew context:itemsContext];
        [rowObject addObserver:self forKeyPath:_valuesKeyPath options:CPKeyValueObservingOptionOld | CPKeyValueObservingOptionNew context:valuesContext];
        [rowObject addObserver:self forKeyPath:_subrowsArrayKeyPath options:CPKeyValueObservingOptionOld | CPKeyValueObservingOptionNew context:subrowsContext];

        var subrows = [self _subrowObjectsOfObject:rowObject];
        if ([subrows count] > 0)
            [self _startObservingRowObjectsRecursively:subrows];
    }
    // ORIG IMPL : calls +keyPathsForValuesAffectingValueForKey: for all keys
}

- (void)_stopObservingRowObjectsRecursively:(CPArray)rowObjects
{
    [_boundArrayOwner removeObserver:self forKeyPath:_boundArrayKeyPath];

    var count = [rowObjects count];

    for (var i = 0; i < count; i++)
    {
        var rowObject = [rowObjects objectAtIndex:i];
        [rowObject removeObserver:self forKeyPath:_itemsKeyPath];
        [rowObject removeObserver:self forKeyPath:_valuesKeyPath];
        [rowObject removeObserver:self forKeyPath:_subrowsArrayKeyPath];

        var subrows = [rowObject valueForKey:_subrowsArrayKeyPath];
        if ([subrows count] > 0)
            [self _stopObservingRowObjectsRecursively:subrows];
    }
}

- (void)observeValueForKeyPath:(CPString)keypath ofObject:(id)object change:(CPDictionary)change context:(void)context
{
    var changeKind = [change objectForKey:CPKeyValueChangeKindKey],
        changeNewValue = [change objectForKey:CPKeyValueChangeNewKey],
        changeOldValue = [change objectForKey:CPKeyValueChangeOldKey],
        newRows,
        oldRows;

    if (context === boundArrayContext || context === subrowsContext)
    {
        if (changeKind === CPKeyValueChangeSetting)
        {
            newRows = changeNewValue;
            oldRows = changeOldValue;

        }
        else if (changeKind === CPKeyValueChangeInsertion)
        {
            newRows = [self _subrowObjectsOfObject:object];
            oldRows = [CPArray arrayWithArray:newRows];
            [oldRows removeObjectsInArray:changeNewValue];
        }

        [self _changedRowArray:newRows withOldRowArray:oldRows forParent:object];
        [self _reconfigureSubviewsAnimate:[self _wantsRowAnimations]];
    }
}

- (void)_changedItem:(id)fromItem toItem:(id)toItem inRow:(CPInteger)aRow atCriteriaIndex:(int)fromItemIndex
{
    var criteria = [self criteriaForRow:aRow],
        displayValues = [self displayValuesForRow:aRow],
        rowType = [self rowTypeForRow:aRow],
        anItem = toItem,

        items = [criteria subarrayWithRange:CPMakeRange(0, fromItemIndex)],
        values = [displayValues subarrayWithRange:CPMakeRange(0, fromItemIndex)];

    _lastRow = aRow;

    while (YES)
    {
        [items addObject:anItem];
        var value = [self _queryValueForItem:anItem inRow:aRow];
        [values addObject:value];

        if (![self _queryNumberOfChildrenOfItem:anItem withRowType:rowType])
            break;

        anItem = [self _queryChild:0 ofItem:anItem withRowType:rowType];
    }

    var object = [[self _rowCacheForIndex:aRow] rowObject];
    [object setValue:items forKey:_itemsKeyPath];
    [object setValue:values forKey:_valuesKeyPath];

    var slice = [_slices objectAtIndex:aRow];
    [slice _reconfigureSubviews];

    [self _updatePredicate];
    [self _sendRuleAction];
    [self _postRuleOptionChangedNotification];
}

- (void)_changedRowArray:(CPArray)newRows withOldRowArray:(CPArray)oldRows forParent:(id)parentRowObject
{
    var newRowCount = [newRows count],
        oldRowCount = [oldRows count],
        deltaCount = newRowCount - oldRowCount,
        minusCount = MIN(newRowCount, oldRowCount),
        maxCount = MAX(newRowCount, oldRowCount),

        insertCacheIndexes = [CPIndexSet indexSet],
        newCaches = [CPArray array],

        parentCacheIndentation,
        parentCacheIndex = [self _rowIndexForRowObject:parentRowObject],

        newRowCacheIndex = 0,
        changeStartIndex = 0;

    [self _stopObservingRowObjectsRecursively:oldRows];
    [self _startObservingRowObjectsRecursively:newRows];

    //var gindexes = [self _globalIndexesForSubrowIndexes:[CPIndexSet indexSetWithIndexesInRange:CPMakeRange(0,oldRowCount)] ofParentObject:parentRowObject];

    if (parentCacheIndex === -1)
        parentCacheIndentation = -1;
    else
        parentCacheIndentation = [[self _rowCacheForIndex:parentCacheIndex] indentation];

    for (; newRowCacheIndex < newRowCount; newRowCacheIndex++)
    {
        var newCacheGlobalIndex = (parentCacheIndex + 1) + newRowCacheIndex,
            obj = [newRows objectAtIndex:newRowCacheIndex],
            newRowType = [obj valueForKey:_typeKeyPath],
            cache = [[_CPRuleEditorCache alloc] init];

        [cache setRowObject:obj];
        [cache setRowIndex:newCacheGlobalIndex];
        [cache setIndentation:parentCacheIndentation + 1];

        [insertCacheIndexes addIndex:newCacheGlobalIndex];
        [newCaches addObject:cache];
    }

    //var lastCacheIndex = [self _rowIndexForRowObject:[oldRows lastObject]];
    [_rowCache removeObjectsInRange:CPMakeRange(parentCacheIndex + 1, [oldRows count])];
    [_rowCache insertObjects:newCaches atIndexes:insertCacheIndexes];

    for (; changeStartIndex < minusCount; changeStartIndex++)
    {
        var oldrow = [oldRows objectAtIndex:changeStartIndex],
            newrow = [newRows objectAtIndex:changeStartIndex];

        if (newrow !== oldrow)
            break;
    }

    var replaceCount = (deltaCount === 0) ? maxCount : maxCount - minusCount,
        startIndex = parentCacheIndex + changeStartIndex + 1;

    if (deltaCount <= 0)
    {
        var removeIndexes = [CPIndexSet indexSetWithIndexesInRange:CPMakeRange(startIndex, replaceCount)],
            removeSlices = [_slices objectsAtIndexes:removeIndexes];

        [removeSlices makeObjectsPerformSelector:@selector(removeFromSuperview)];
        [_slices removeObjectsAtIndexes:removeIndexes];
    }

    if (deltaCount >= 0)
    {
        var newIndentation = parentCacheIndentation + 1,
            newIndex = startIndex;

        for (; newIndex < startIndex + replaceCount; newIndex++)
        {
            var newslice = [self _newSlice],
                rowType = [self rowTypeForRow:newIndex];

            [newslice setRowIndex:newIndex];
            [newslice setIndentation:newIndentation];
            [newslice _setRowType:rowType];
            [newslice _configurePlusButtonByRowType:CPRuleEditorRowTypeSimple];

            [_slices insertObject:newslice atIndex:newIndex];
        }
    }

    var emptyArray = [CPArray array],
        count = [oldRows count],
        n;
    for (n = 0; n < count; n++)
    {
        var oldRow = [oldRows objectAtIndex:n],
            subOldRows = [self _subrowObjectsOfObject:oldRow];

        if ([subOldRows count] > 0)
            [self _changedRowArray:emptyArray withOldRowArray:subOldRows forParent:oldRow];
    }

    count = [newRows count];
    for (n = 0; n < count; n++)
    {
        var newRow = [newRows objectAtIndex:n],
            subnewRows = [self _subrowObjectsOfObject:newRow];

        if ([subnewRows count] > 0)
            [self _changedRowArray:subnewRows withOldRowArray:emptyArray forParent:newRow];
    }
}

- (void)bind:(CPString)aBinding toObject:(id)observableController withKeyPath:(CPString)aKeyPath options:(CPDictionary)options
{
  if ([aBinding isEqualToString:@"rows"])
  {
    [self unbind:aBinding];
    [self _setBoundDataSource:observableController withKeyPath:aKeyPath options:options];

    [_rowCache removeAllObjects];
    [_slices removeAllObjects];

    var newRows = [CPArray array],
        oldRows = [self _rootRowsArray];

    [self _changedRowArray:newRows withOldRowArray:oldRows forParent:_boundArrayOwner];
  }
  else
    [super bind:aBinding toObject:observableController withKeyPath:aKeyPath options:options];
}

- (void)unbind:(CPString)object
{
    _rowClass = [_CPRuleEditorRowObject class];
    [super unbind:object];
}

- (void)_setBoundDataSource:(id)datasource withKeyPath:(CPString)keyPath options:(CPDictionary)options
{
    if ([datasource respondsToSelector:@selector(objectClass)])
        _rowClass = [datasource objectClass];

    _boundArrayKeyPath = keyPath;
    _boundArrayOwner = datasource;

    //var boundRows = [_boundArrayOwner valueForKey:_boundArrayKeyPath];

    [_boundArrayOwner addObserver:self forKeyPath:_boundArrayKeyPath options:CPKeyValueObservingOptionOld | CPKeyValueObservingOptionNew context:boundArrayContext];

    //if ([boundRows isKindOfClass:[CPArray class]] && [boundRows count] > 0)
    //    [_boundArrayOwner setValue:boundRows forKey:_boundArrayKeyPath];
}

- (void)_setPredicate:(CPPredicate)predicate
{
    if (_predicate !== predicate)
        _predicate = predicate;
}

- (void)_updatePredicate
{
    if (_delegateWantsValidation)
    {
        if (![self _delegateRespondsToRuleEditorPredicatePartsForCriterionWithDisplayValueInRow])
            return;

        _delegateWantsValidation = NO;
    }

    var subpredicates = [CPMutableArray array],
        subindexes = [self subrowIndexesForRow:-1],
        current_index = [subindexes firstIndex];

    while (current_index !== CPNotFound)
    {
        var subpredicate = [self predicateForRow:current_index];

        if (subpredicate !== nil)
            [subpredicates addObject:subpredicate];

        current_index = [subindexes indexGreaterThanIndex:current_index];
    }

    var new_predicate = [[CPCompoundPredicate alloc] initWithType:CPOrPredicateType subpredicates:subpredicates];

    [self _setPredicate:new_predicate];
}

- (_CPRuleEditorViewSliceRow)_newSlice
{
    var sliceRect = CGRectMake(0, 0, CGRectGetWidth([self frame]), 0),
        slice = [self _createNewSliceWithFrame:sliceRect ruleEditorView:self];

    return slice;
}

- (_CPRuleEditorViewSliceRow)_createNewSliceWithFrame:(CGRect)frame ruleEditorView:(CPRuleEditor)editor
{
    return [[_CPRuleEditorViewSliceRow alloc] initWithFrame:frame ruleEditorView:editor];
}

- (void)_reconfigureSubviewsAnimate:(BOOL)animate
{
    var viewAnimations = [CPMutableArray array],
        added_slices = [CPMutableArray array],
        count = [_slices count];

    [self _updateSliceRows];

    if ([[self superview] isKindOfClass:[CPClipView class]])
        [self setFrameSize:CGSizeMake(CGRectGetWidth([self frame]), count * _sliceHeight)];

    for (var i = 0; i < count; i++)
    {
        var aslice = [_slices objectAtIndex:i],
            targetRect = [aslice _animationTargetRect],
            startRect = [aslice frame],
            startIndex = [aslice rowIndex] - 1;

        if ([aslice superview] === nil)
        {
            startRect = CGRectMake(0, startIndex * _sliceHeight, CGRectGetWidth(startRect), _sliceHeight);
            [aslice _reconfigureSubviews];
            [added_slices addObject:aslice];
        }

        if (animate)
        {
            var animation = @{};
            [animation setObject:aslice forKey:CPViewAnimationTargetKey];
            [animation setObject:startRect forKey:CPViewAnimationStartFrameKey];
            [animation setObject:targetRect forKey:CPViewAnimationEndFrameKey];

            [viewAnimations insertObject:animation atIndex:0];
        }
        else
            [aslice setFrame:targetRect];
    }

    var addcount = [added_slices count];
    for (var i = 0; i < addcount; i++)
        [_slicesHolder addSubview:added_slices[i] positioned:CPWindowBelow relativeTo:nil];

    if (animate)
    {
        [_currentAnimation setViewAnimations:viewAnimations];
        [_currentAnimation startAnimation];
    }

    _lastRow = [self numberOfRows] - 1;

    if (_lastRow === -1)
        _nestingModeDidChange = NO;

    [self setNeedsDisplay:YES];
    [_slices makeObjectsPerformSelector:@selector(_updateButtonVisibilities)];
}

- (void)animationDidEnd:(CPViewAnimation)animation
{
//  var nextSimple = [self _getItemsAndValuesToAddForRow:0 ofType:CPRuleEditorRowTypeSimple],
//      nextCompound = [self _getItemsAndValuesToAddForRow:0 ofType:CPRuleEditorRowTypeCompound];

//  _itemsAndValuesToAddForRowType = {CPRuleEditorRowTypeSimple:nextSimple, CPRuleEditorRowTypeCompound:nextCompound};
}

- (void)_updateSliceRows
{
    var width =  [self frame].size.width,
        count = [_slices count];

    for (var i = 0; i < count; i++)
    {
        var slice = [_slices objectAtIndex:i],
            targetRect = CGRectMake(0, i * _sliceHeight, width, _sliceHeight);

        [slice setRowIndex:i];
        [slice _setAnimationTargetRect:targetRect];
    }
}

- (CPArray)_backgroundColors
{
    return [self valueForThemeAttribute:@"alternating-row-colors"];
}

- (CPColor)_selectedRowColor
{
    return [self valueForThemeAttribute:@"selected-color"];
}

- (CPColor)_sliceTopBorderColor
{
    return [self valueForThemeAttribute:@"slice-top-border-color"];
}

- (CPColor)_sliceBottomBorderColor
{
    return [self valueForThemeAttribute:@"slice-bottom-border-color"];
}

- (CPColor)_sliceLastBottomBorderColor
{
    return [self valueForThemeAttribute:@"slice-last-bottom-border-color"];
}

- (CPFont)font
{
    return [self valueForThemeAttribute:@"font"];
}

- (CPColor)_fontColor
{
    return [self valueForThemeAttribute:@"font-color"];
}

- (CPImage)_imageAdd
{
    return [self valueForThemeAttribute:@"add-image" inState:CPThemeStateNormal];
}

- (CPImage)_imageAddHighlighted
{
    return [self valueForThemeAttribute:@"add-image" inState:CPThemeStateHighlighted];
}

- (CPImage)_imageRemove
{
    return [self valueForThemeAttribute:@"remove-image" inState:CPThemeStateNormal];
}

- (CPImage)_imageRemoveHighlighted
{
    return [self valueForThemeAttribute:@"remove-image" inState:CPThemeStateHighlighted];
}

- (CPVerticalTextAlignment)_verticalAlignment
{
    return [self valueForThemeAttribute:@"vertical-alignment"];
}

- (CPString)_toolTipForAddCompoundRowButton
{
    return [_standardLocalizer localizedStringForString:@"Add compound row"];
}

- (CPString)_toolTipForAddSimpleRowButton
{
    return [_standardLocalizer localizedStringForString:@"Add row"];
}

- (CPString)_toolTipForDeleteRowButton
{
    return [_standardLocalizer localizedStringForString:@"Delete row"];
}

- (void)_updateSliceIndentations
{
    [self _updateSliceIndentationAtIndex:0 toIndentation:0 withIndexSet:[self subrowIndexesForRow:0]];
}

- (void)_updateSliceIndentationAtIndex:(int)index toIndentation:(int)indentation withIndexSet:(id)indexes
{
    var current_index = [indexes firstIndex];

    while (current_index !== CPNotFound)
    {
        var subindexes = [self subrowIndexesForRow:index];
        [self _updateSliceIndentationAtIndex:current_index toIndentation:indentation + 1 withIndexSet:subindexes];
        current_index = [indexes indexGreaterThanIndex:current_index];
    }

    [[_slices objectAtIndex:index] setIndentation:indentation];
}

- (CPArray)_selectedSlices
{
    var _selectedSlices = [CPMutableArray array],
        count = [_slices count],
        i;

    for (i = 0; i < count; i++)
    {
        var slice = _slices[i];
        if ([slice _isSelected])
            [_selectedSlices addObject:slice];
    }

    return _selectedSlices;
}

- (int)_lastSelectedSliceIndex
{
    var lastIndex = -1,
        count = [_slices count],
        i;

    for (i = 0; i < count; i++)
    {
         var slice = _slices[i];
         if ([slice _isLastSelected])
            return [slice rowIndex];
    }

    return CPNotFound;
}

- (void)_mouseUpOnSlice:(id)slice withEvent:(CPEvent)event
{
    if ([slice _rowType] !== CPRuleEditorRowTypeSimple)
        return;

    var modifierFlags = [event modifierFlags],
        extend = (modifierFlags & CPCommandKeyMask) || (modifierFlags & CPShiftKeyMask),
        rowIndexes = [CPIndexSet indexSetWithIndex:[slice rowIndex]];

    [self selectRowIndexes:rowIndexes byExtendingSelection:extend];
}

- (void)_mouseDownOnSlice:(id)slice withEvent:(CPEvent)event
{
}

- (void)_rightMouseDownOnSlice:(_CPRuleEditorViewSlice)slice withEvent:(CPEvent)event
{
}

- (void)_performClickOnSlice:(id)slice withEvent:(CPEvent)event
{
}

- (void)_setSuppressKeyDownHandling:(BOOL)flag
{
    _suppressKeyDownHandling = flag;
}

- (void)selectAll:(id)sender
{
    var count = [_slices count];

    while (count--)
    {
        var slice = _slices[count];
        [slice _setSelected:YES];
        [slice setNeedsDisplay:YES];
    }
}

- (void)_deselectAll
{
    var count = [_slices count];

    while (count--)
    {
        var slice = _slices[count];
        [slice _setSelected:NO];
        [slice _setLastSelected:NO];
        [slice setNeedsDisplay:YES];
    }
}

- (int)_queryNumberOfChildrenOfItem:(id)item withRowType:(CPRuleEditorRowType)type
{
    return [_ruleDelegate ruleEditor:self numberOfChildrenForCriterion:item withRowType:type];
}

- (id)_queryChild:(int)childIndex ofItem:(id)item withRowType:(CPRuleEditorRowType)type
{
    return [_ruleDelegate ruleEditor:self child:childIndex forCriterion:item withRowType:type];
}

- (id)_queryValueForItem:(id)item inRow:(CPInteger)row
{
    return [_ruleDelegate ruleEditor:self displayValueForCriterion:item inRow:row];
}

- (int)_lastRow
{
    return _lastRow;
}

- (int)_countOfRowsStartingAtObject:(id)object
{
    var index = [self _rowIndexForRowObject:object];
    return ([self numberOfRows] - index);
}

- (void)_setAlignmentGridWidth:(float)width
{
    _alignmentGridWidth = width;
}

- (BOOL)_validateItem:(id)item value:(id)value inRow:(CPInteger)row
{
    return [self _queryCanSelectItem:item displayValue:value inRow:row];
}

- (BOOL)_queryCanSelectItem:(id)item displayValue:(id)value inRow:(CPInteger)row
{
    return YES;
}

- (void)_windowChangedKeyState
{
    [self setNeedsDisplay:YES];
}

- (void)setNeedsDisplay:(BOOL)flag
{
    [_slices makeObjectsPerformSelector:@selector(setNeedsDisplay:) withObject:flag];
    [super setNeedsDisplay:flag];
}

- (void)setFrameSize:(CGSize)size
{
    [self setNeedsDisplay:YES];

    if (CGRectGetWidth([self frame]) !== size.width)
        [_slices makeObjectsPerformSelector:@selector(setNeedsLayout)];

    [super setFrameSize:size];
}

- (CPIndexSet)_selectedSliceIndices
{
    var selectedIndices = [CPMutableIndexSet indexSet],
        count = [_slices count],
        i;

    for (i = 0; i < count; i++)
    {
        var slice = _slices[i];
        if ([slice _isSelected])
            [selectedIndices addIndex:[slice rowIndex]];
    }

    return selectedIndices;
}

- (void)mouseDragged:(CPEvent)event
{
    if (!_editable)
        return;

    var point = [self convertPoint:[event locationInWindow] fromView:nil],
        view = [_slices objectAtIndex:FLOOR(MAX(0, point.y) / _sliceHeight)];

    if ([self _dragShouldBeginFromMouseDown:view])
        [self _performDragForSlice:view withEvent:event];
}

- (BOOL)_dragShouldBeginFromMouseDown:(CPView)view
{
    return (([self nestingMode] === CPRuleEditorNestingModeList ||  [view rowIndex] !== 0) && _editable && [view isKindOfClass:[_CPRuleEditorViewSliceRow class]] && _draggingRows === nil);
}

- (BOOL)_performDragForSlice:(id)slice withEvent:(CPEvent)event
{
    var dragPoint,
        mainRowIndex = [slice rowIndex],
        draggingRows = [CPIndexSet indexSetWithIndex:mainRowIndex],
        selected_indices = [self _selectedSliceIndices],
        pasteboard = [CPPasteboard pasteboardWithName:CPDragPboard];

    [pasteboard declareTypes:[CPArray arrayWithObjects:CPRuleEditorItemPBoardType, nil] owner: self];

    if ([selected_indices containsIndex:mainRowIndex])
        [draggingRows addIndexes:selected_indices];
    _draggingRows = [self _includeSubslicesForSlicesAtIndexes:draggingRows];

    var firstIndex = [_draggingRows firstIndex],
        firstSlice = [_slices objectAtIndex:firstIndex],
        dragview = [[CPView alloc] initWithFrame:[firstSlice frame]];

#if PLATFORM(DOM)
    var html = firstSlice._DOMElement.innerHTML;
    dragview._DOMElement.innerHTML = [html copy];
#endif
    [dragview setBackgroundColor:[firstSlice backgroundColor]];
    [dragview setAlphaValue:0.7];

    dragPoint = CGPointMake(0, firstIndex * _sliceHeight);

    [self dragView:dragview
                at:dragPoint
            offset:CGSizeMake(0, _sliceHeight)
             event:event
        pasteboard:pasteboard
            source:self
         slideBack:YES];

    return YES;
}

- (CPDragOperation)draggingEntered:(id /*< CPDraggingInfo >*/)sender
{
    if ([sender draggingSource] === self)
    {
        [self _clearDropLine];
        return CPDragOperationMove;
    }

    return CPDragOperationNone;
}

- (void)draggingExited:(id)sender
{
    [self _clearDropLine];
    [self setNeedsDisplay:YES];
}

- (void)_clearDropLine
{
    [_dropLineView setAlphaValue:0];

    if (_subviewIndexOfDropLine !== CPNotFound && _subviewIndexOfDropLine < _lastRow)
    {
        var previousBelowSlice = [_slices objectAtIndex:_subviewIndexOfDropLine];
        [previousBelowSlice setFrameOrigin:CGPointMake(0, [previousBelowSlice rowIndex] * _sliceHeight)];
    }

    _subviewIndexOfDropLine = CPNotFound;
}

- (CPDragOperation)draggingUpdated:(id /*<CPDraggingInfo>*/)sender
{
    var point = [self convertPoint:[sender draggingLocation] fromView:nil],
        y = point.y + _sliceHeight / 2,
        indexOfDropLine =  FLOOR(y / _sliceHeight),
        numberOfRows = [self numberOfRows];

    if (indexOfDropLine <= 0 || indexOfDropLine > numberOfRows || (indexOfDropLine >= [_draggingRows firstIndex] && indexOfDropLine <= [_draggingRows lastIndex] + 1))
    {
        if (_subviewIndexOfDropLine !== CPNotFound && indexOfDropLine !== _subviewIndexOfDropLine)
            [self _clearDropLine];
        return CPDragOperationNone;
    }

    if (_subviewIndexOfDropLine !== indexOfDropLine)
    {
        if (_subviewIndexOfDropLine !== CPNotFound && _subviewIndexOfDropLine < numberOfRows)
        {
            var previousBelowSlice = [_slices objectAtIndex:_subviewIndexOfDropLine];
            [previousBelowSlice setFrameOrigin:CGPointMake(0, [previousBelowSlice rowIndex] * _sliceHeight)];
        }

        if (indexOfDropLine <= _lastRow && indexOfDropLine < numberOfRows)
        {
            var belowSlice = [_slices objectAtIndex:indexOfDropLine];
            [belowSlice setFrameOrigin:CGPointMake(0, [belowSlice rowIndex] * _sliceHeight + 2)];
        }

        [_dropLineView setAlphaValue:1];
        [_dropLineView setFrameOrigin:CGPointMake(CGRectGetMinX([_dropLineView frame]), indexOfDropLine * _sliceHeight)];

        _subviewIndexOfDropLine = indexOfDropLine;
    }

    return CPDragOperationMove;
}

- (BOOL)prepareForDragOperation:(id /*< CPDraggingInfo >*/)sender
{
    return (_subviewIndexOfDropLine !== CPNotFound);
}

- (BOOL)performDragOperation:(id /*< CPDraggingInfo >*/)info
{
    var aboveInsertIndexCount = 0,
        object,
        removeIndex;

    var rowObjects = [_rowCache valueForKey:@"rowObject"],
        index = [_draggingRows lastIndex];

    var parentRowIndex = [self parentRowForRow:index], // first index of draggingrows
        parentRowObject = (parentRowIndex === -1) ? _boundArrayOwner : [[self _rowCacheForIndex:parentRowIndex] rowObject],
        insertIndex = _subviewIndexOfDropLine;

    while (index !== CPNotFound)
    {
        if (index >= insertIndex)
        {
            removeIndex = index + aboveInsertIndexCount;
            aboveInsertIndexCount += 1;
        }
        else
        {
            removeIndex = index;
            insertIndex -= 1;
        }

        object = [rowObjects objectAtIndex:removeIndex];
        [self removeRowAtIndex:removeIndex];
        [[self _subrowObjectsOfObject:parentRowObject] insertObject:object atIndex:insertIndex - parentRowIndex - 1];

        index = [_draggingRows indexLessThanIndex:index];
    }

    [self _clearDropLine];
    _draggingRows = nil;
    return YES;
}

- (CPIndexSet)_draggingTypes
{
    return [CPIndexSet indexSetWithIndex:CPDragOperationMove];
}

- (void)draggedView:(CPView)dragView endedAt:(CGPoint)aPoint operation:(CPDragOperation)operation
{
    _draggingRows = nil;

    [self _updatePredicate];
    [self _sendRuleAction];
    [self _postRuleOptionChangedNotification];
    [self _postRowCountChangedNotificationOfType:CPRuleEditorRowsDidChangeNotification indexes:nil]; // FIXME
}

- (BOOL)wantsPeriodicDraggingUpdates
{
    return NO;
}

- (void)pasteboard:(CPPasteboard)pasteboard provideDataForType:(int)type
{
}

- (void)_setWindow:(CPWindow)window
{
    [super _setWindow:window];
}

- (void)_windowUpdate:(id)sender
{
    [super _windowUpdate:sender];
}

- (void)_postRuleOptionChangedNotification
{
    [[CPNotificationCenter defaultCenter] postNotificationName:CPRuleEditorRulesDidChangeNotification object:self];
}

- (void)_postRowCountChangedNotificationOfType:(CPString)notificationName indexes:indexes
{
    var userInfo = indexes === nil ? @{} : @{ "indexes": indexes };
    [[CPNotificationCenter defaultCenter] postNotificationName:notificationName object:self userInfo:userInfo];
}

- (CPIndexSet)_globalIndexesForSubrowIndexes:(CPIndexSet)indexes ofParentObject:(id)parentRowObject
{
    var _subrows = [self _subrowObjectsOfObject:parentRowObject],
        parentRowIndex = [self _rowIndexForRowObject:parentRowObject],

        globalIndexes = [CPMutableIndexSet indexSet],
        current_index = [indexes firstIndex],
        numberOfChildrenOfPreviousBrother = 0;

    while (current_index !== CPNotFound)
    {
        var globalChildIndex = current_index + parentRowIndex + 1 + numberOfChildrenOfPreviousBrother;
        [globalIndexes addIndex:globalChildIndex];

        if ([self rowTypeForRow:globalChildIndex] === CPRuleEditorRowTypeCompound)
        {
            var rowObject = [[self _rowCacheForIndex:current_index] rowObject],
                subrows = [self _subrowObjectsOfObject:rowObject],
                subIndexes = [self _globalIndexesForSubrowIndexes:[CPIndexSet indexSetWithIndexesInRange:CPMakeRange(0, [subrows count])] ofParentObject:rowObject];

            numberOfChildrenOfPreviousBrother = [subIndexes count];
        }

        current_index = [indexes indexGreaterThanIndex:current_index];
    }

    return globalIndexes;
}

- (void)_sendRuleAction
{
    var action = [self action],
        target = [self target];

    [self sendAction:action to:target];
}

- (BOOL)_sendsActionOnIncompleteTextChange
{
    return YES;
}

- (void)_getAllAvailableItems:(id)items values:(id)values asChildrenOfItem:(id)parentItem inRow:(CPInteger)aRow
{
    var type,
        indexofCriterion,
        numOfChildren;

    var availItems = [CPMutableArray array],
        availValues = [CPMutableArray array];

    var criterion = nil,
        value = nil;

    _lastRow = aRow;
    type = [self rowTypeForRow:aRow];
    numOfChildren = [self _queryNumberOfChildrenOfItem:parentItem withRowType:type];

    var criteria = [self criteriaForRow:aRow];
    indexofCriterion = [criteria indexOfObject:criterion];

    if (parentItem !== nil
        && indexofCriterion !== CPNotFound
        && indexofCriterion < [criteria count] - 1)
    {
        var next = indexofCriterion + 1;

        criterion = [criteria objectAtIndex:next];
        var values = [self displayValuesForRow:aRow];
        value = [values objectAtIndex:next];
    }

    for (var i = 0; i < numOfChildren; ++i)
    {
        var aChild = [self _queryChild:i ofItem:parentItem withRowType:type],
            availChild = aChild,
            availValue = value;

        if (criterion !== aChild)
            availValue = [self _queryValueForItem:aChild inRow:aRow];

        if (!availValue)
            availValue = [self _queryValueForItem:availChild inRow:aRow];

        [availItems addObject:availChild];
        [availValues addObject:availValue];
    }

    [items addObjectsFromArray:availItems];
    [values addObjectsFromArray:availValues];
}

@end


@implementation CPRuleEditor (CPRuleEditorDelegate)

- (BOOL)_delegateRespondsToRuleEditorPredicatePartsForCriterionWithDisplayValueInRow
{
    return _implementedDelegateMethods & CPRuleEditorDelegate_ruleEditor_predicatePartsForCriterion_withDisplayValue_inRow_;
}

- (CPDictionary)_sendDelegateRuleEditorPredicatePartsForCriterion:(id)criterion withDisplayValue:(id)value inRow:(CPInteger)row
{
    if (!(_implementedDelegateMethods & CPRuleEditorDelegate_ruleEditor_predicatePartsForCriterion_withDisplayValue_inRow_))
        return @{};

    return [_ruleDelegate ruleEditor:self predicatePartsForCriterion:criterion withDisplayValue:value inRow:row];
}

@end


var CPRuleEditorAlignmentGridWidthKey       = @"CPRuleEditorAlignmentGridWidth",
    CPRuleEditorSliceHeightKey              = @"CPRuleEditorSliceHeight",
    CPRuleEditorStringsFilenameKey          = @"CPRuleEditorStringsFilename",
    CPRuleEditorEditableKey                 = @"CPRuleEditorEditable",
    CPRuleEditorAllowsEmptyCompoundRowsKey  = @"CPRuleEditorAllowsEmptyCompoundRows",
    CPRuleEditorDisallowEmptyKey            = @"CPRuleEditorDisallowEmpty",
    CPRuleEditorNestingModeKey              = @"CPRuleEditorNestingMode",
    CPRuleEditorRowTypeKeyPathKey           = @"CPRuleEditorRowTypeKeyPath",
    CPRuleEditorItemsKeyPathKey             = @"CPRuleEditorItemsKeyPath",
    CPRuleEditorValuesKeyPathKey            = @"CPRuleEditorValuesKeyPath",
    CPRuleEditorSubrowsArrayKeyPathKey      = @"CPRuleEditorSubrowsArrayKeyPath",
    CPRuleEditorBoundArrayKeyPathKey        = @"CPRuleEditorBoundArrayKeyPath",
    CPRuleEditorRowClassKey                 = @"CPRuleEditorRowClass",
    CPRuleEditorSlicesHolderKey             = @"CPRuleEditorSlicesHolder",
    CPRuleEditorSlicesKey                   = @"CPRuleEditorSlices",
    CPRuleEditorDelegateKey                 = @"CPRuleEditorDelegate",
    CPRuleEditorBoundArrayOwnerKey          = @"CPRuleEditorBoundArrayOwner";

@implementation CPRuleEditor (CPCoding)

- (id)initWithCoder:(CPCoder)coder
{
    self = [super initWithCoder:coder];
    if (self !== nil)
    {
        [self setFormattingStringsFilename:[coder decodeObjectForKey:CPRuleEditorStringsFilenameKey]];
        _alignmentGridWidth      = [coder decodeFloatForKey:CPRuleEditorAlignmentGridWidthKey];
        _sliceHeight             = [coder decodeDoubleForKey:CPRuleEditorSliceHeightKey];
        _editable                = [coder decodeBoolForKey:CPRuleEditorEditableKey];
        _allowsEmptyCompoundRows = [coder decodeBoolForKey:CPRuleEditorAllowsEmptyCompoundRowsKey];
        _disallowEmpty           = [coder decodeBoolForKey:CPRuleEditorDisallowEmptyKey];
        _nestingMode             = [coder decodeIntForKey:CPRuleEditorNestingModeKey];
        _typeKeyPath             = [coder decodeObjectForKey:CPRuleEditorRowTypeKeyPathKey];
        _itemsKeyPath            = [coder decodeObjectForKey:CPRuleEditorItemsKeyPathKey];
        _valuesKeyPath           = [coder decodeObjectForKey:CPRuleEditorValuesKeyPathKey];
        _subrowsArrayKeyPath     = [coder decodeObjectForKey:CPRuleEditorSubrowsArrayKeyPathKey];
        _boundArrayKeyPath       = [coder decodeObjectForKey:CPRuleEditorBoundArrayKeyPathKey];

        _slicesHolder = [[self subviews] objectAtIndex:0];
        _boundArrayOwner = [coder decodeObjectForKey:CPRuleEditorBoundArrayOwnerKey];
        _slices = [coder decodeObjectForKey:CPRuleEditorSlicesKey];
        _ruleDelegate = [coder decodeObjectForKey:CPRuleEditorDelegateKey];

        [self _initRuleEditorShared];
    }

    return self;
}

- (void)encodeWithCoder:(CPCoder)coder
{
    [super encodeWithCoder:coder];

    [coder encodeBool:_editable forKey:CPRuleEditorEditableKey];
    [coder encodeBool:_allowsEmptyCompoundRows forKey:CPRuleEditorAllowsEmptyCompoundRowsKey];
    [coder encodeBool:_disallowEmpty forKey:CPRuleEditorDisallowEmptyKey];

    [coder encodeFloat:_alignmentGridWidth forKey:CPRuleEditorAlignmentGridWidthKey];
    [coder encodeDouble:_sliceHeight forKey:CPRuleEditorSliceHeightKey];
    [coder encodeInt:_nestingMode forKey:CPRuleEditorNestingModeKey];

    [coder encodeObject:_stringsFilename forKey:CPRuleEditorStringsFilenameKey];
    [coder encodeObject:_typeKeyPath forKey:CPRuleEditorRowTypeKeyPathKey];
    [coder encodeObject:_itemsKeyPath forKey:CPRuleEditorItemsKeyPathKey];
    [coder encodeObject:_valuesKeyPath forKey:CPRuleEditorValuesKeyPathKey];
    [coder encodeObject:_boundArrayKeyPath forKey:CPRuleEditorBoundArrayKeyPathKey];
    [coder encodeObject:_subrowsArrayKeyPath forKey:CPRuleEditorSubrowsArrayKeyPathKey];

    [coder encodeConditionalObject:_slicesHolder forKey:CPRuleEditorSlicesHolderKey];
    [coder encodeObject:_slices forKey:CPRuleEditorSlicesKey];
    [coder encodeObject:_boundArrayOwner forKey:CPRuleEditorBoundArrayOwnerKey];
}

@end

var CriteriaKey         = @"criteria",
    SubrowsKey          = @"subrows",
    DisplayValuesKey    = @"displayValues",
    RowTypeKey          = @"rowType";

@implementation _CPRuleEditorRowObject : CPObject
{
    CPArray     subrows;
    CPArray     criteria;
    CPArray     displayValues;
    CPInteger   rowType;
}

- (id)copy
{
    var copy = [[_CPRuleEditorRowObject alloc] init];
    [copy setSubrows:[[CPArray alloc] initWithArray:subrows copyItems:YES]];
    [copy setCriteria:[[CPArray alloc] initWithArray:criteria copyItems:YES]];
    [copy setDisplayValues:[[CPArray alloc] initWithArray:displayValues copyItems:YES]];
    [copy setRowType:rowType];

    return copy;
}

- (CPString)description
{
    return "<" + [self className] + ">\nsubrows = " + [subrows description] + "\ncriteria = " + [criteria description] + "\ndisplayValues = " + [displayValues description];
}

- (id)initWithCoder:(CPCoder)coder
{
    self = [super init];
    if (self !== nil)
    {
        subrows = [coder decodeObjectForKey:SubrowsKey];
        criteria = [coder decodeObjectForKey:CriteriaKey];
        displayValues = [coder decodeObjectForKey:DisplayValuesKey];
        rowType = [coder decodeIntForKey:RowTypeKey];
    }

    return self;
}

- (void)encodeWithCoder:(CPCoder)coder
{
    [coder encodeObject:subrows forKey:SubrowsKey];
    [coder encodeObject:criteria forKey:CriteriaKey];
    [coder encodeObject:displayValues forKey:DisplayValuesKey];
    [coder encodeInt:rowType forKey:RowTypeKey];
}

@end

@implementation _CPRuleEditorCache : CPObject
{
    CPDictionary    rowObject;
    CPInteger       rowIndex;
    CPInteger       indentation;
}

- (CPString)description
{
    return [CPString stringWithFormat:@"<%d object:%d rowIndex:%d indentation:%d>", [self hash], [rowObject hash], rowIndex, indentation];
}

@end

var CPBoundArrayKey = @"CPBoundArray";

@implementation _CPRuleEditorViewUnboundRowHolder : CPObject
{
    CPArray boundArray;
}

- (id)init
{
    if (self = [super init])
        boundArray = [[CPArray alloc] init];

    return self;
}

- (id)initWithCoder:(CPCoder)coder
{
    if (self = [super init])
        boundArray = [coder decodeObjectForKey:CPBoundArrayKey];

    return self;
}

- (void)encodeWithCoder:(CPCoder)coder
{
    [coder encodeObject:boundArray forKey:CPBoundArrayKey];
}

@end
@implementation _CPRuleEditorViewSliceHolder : CPView
{
    id __doxygen__;
}

- (void)addSubview:(CPView)subview
{
    [self setNeedsDisplay:YES];
    [super addSubview:subview];
}

@end

var dropSeparatorColor = [CPColor colorWithHexString:@"4886ca"];
@implementation _CPRuleEditorViewSliceDropSeparator : CPView
{
    id __doxygen__;
}

- (void)drawRect:(CGRect)rect
{
    var context = [[CPGraphicsContext currentContext] graphicsPort];
    CGContextSetFillColor(context, dropSeparatorColor);
    CGContextFillRect(context, [self bounds]);
}

@end

@implementation CPObject (CPRuleEditorSliceRow)

- (int)valueType
{
    var result = 0,
        isString = [self isKindOfClass:CPString];

    if (!isString)
    {
        var isView = [self isKindOfClass:CPView];
        result = 1;

        if (!isView)
        {
            var ismenuItem = [self isKindOfClass:CPMenuItem];
            result = 2;

            if (!ismenuItem)
            {
                [CPException raise:CPGenericException reason:@"Unknown type for " + self];
                result = -1;
            }
        }
    }

    return result;
}

@end
@implementation CPRuleEditor (CPSynthesizedAccessors)

- (CPString)boundArrayKeyPath
{
    return _boundArrayKeyPath;
}

- (void)setBoundArrayKeyPath:(CPString)aValue
{
    _boundArrayKeyPath = aValue;
}

- (_CPRuleEditorLocalizer)standardLocalizer
{
    return _standardLocalizer;
}

- (void)setStandardLocalizer:(_CPRuleEditorLocalizer)aValue
{
    _standardLocalizer = aValue;
}

@end