From fe52ce6011ae780ec362c296630fc3a31bb57ac4 Mon Sep 17 00:00:00 2001 From: natalieogle Date: Mon, 8 Feb 2016 18:58:05 -0800 Subject: [PATCH] Modify serialize functions and add function to move through the item stack in order of most recently used. --- spec/pane-spec.coffee | 26 +++++++++++++++++++++++ src/pane.coffee | 48 ++++++++++++++++++++++++++----------------- 2 files changed, 55 insertions(+), 19 deletions(-) diff --git a/spec/pane-spec.coffee b/spec/pane-spec.coffee index b4057fb4c..d3e8dc535 100644 --- a/spec/pane-spec.coffee +++ b/spec/pane-spec.coffee @@ -195,16 +195,42 @@ describe "Pane", -> pane.activateItem(item1) expect(pane.getActiveItem()).toBe item1 pane.activateMostRecentlyUsedItem() + pane.stopMovingThroughStackAndMoveItemToEndOfStack() expect(pane.getActiveItem()).toBe item3 pane.activateItem(item2) expect(pane.getActiveItem()).toBe item2 pane.activateMostRecentlyUsedItem() + pane.stopMovingThroughStackAndMoveItemToEndOfStack() expect(pane.getActiveItem()).toBe item3 expect(pane.itemStack[0]).toBe item1 pane.destroyItem(item3) pane.activateMostRecentlyUsedItem() + pane.stopMovingThroughStackAndMoveItemToEndOfStack() expect(pane.getActiveItem()).toBe item1 + describe "::activateNextRecentlyUsedItem()", -> + it "sets the active item to the next item in the itemStack", -> + pane = new Pane(paneParams(items: [new Item("A"), new Item("B"), new Item("C"), new Item("D"), new Item("E")])) + [item1, item2, item3, item4, item5] = pane.getItems() + pane.itemStack = [item3, item1, item2, item5, item4] + + pane.activateItem(item4) + expect(pane.getActiveItem()).toBe item4 + pane.activateMostRecentlyUsedItem() + expect(pane.getActiveItem()).toBe item5 + pane.activateNextRecentlyUsedItem() + expect(pane.getActiveItem()).toBe item2 + pane.activateNextRecentlyUsedItem() + expect(pane.getActiveItem()).toBe item1 + pane.activateNextRecentlyUsedItem() + expect(pane.getActiveItem()).toBe item3 + pane.activateNextRecentlyUsedItem() + expect(pane.getActiveItem()).toBe item4 + pane.activateNextRecentlyUsedItem() + expect(pane.getActiveItem()).toBe item5 + pane.stopMovingThroughStackAndMoveItemToEndOfStack() + expect(pane.itemStack[4]).toBe item5 + describe "::activateNextItem() and ::activatePreviousItem()", -> it "sets the active item to the next/previous item, looping around at either end", -> pane = new Pane(paneParams(items: [new Item("A"), new Item("B"), new Item("C")])) diff --git a/src/pane.coffee b/src/pane.coffee index 0aa1ed8fd..93f399cd0 100644 --- a/src/pane.coffee +++ b/src/pane.coffee @@ -20,7 +20,7 @@ class Pane extends Model focused: false @deserialize: (state, {deserializers, applicationDelegate, config, notifications}) -> - {items, itemStack, activeItemURI, activeItemUri} = state + {items, itemStackIndices, activeItemURI, activeItemUri} = state activeItemURI ?= activeItemUri state.items = compact(items.map (itemState) -> deserializers.deserialize(itemState)) state.activeItem = find state.items, (item) -> @@ -48,20 +48,21 @@ class Pane extends Model @addItems(compact(params?.items ? [])) @setActiveItem(@items[0]) unless @getActiveItem()? - @addItemsToStack(params?.itemStack ? []) + @addItemsToStack(params?.itemStackIndices ? []) @setFlexScale(params?.flexScale ? 1) serialize: -> if typeof @activeItem?.getURI is 'function' activeItemURI = @activeItem.getURI() - itemStack = [] - for item in @items - itemStack.push(@itemStack.indexOf(item)) if typeof item.serialize is 'function' + itemsToBeSerialized = compact(@items.map((item) -> item if typeof item.serialize is 'function')) + itemStackIndices = [] + for item in @itemStack + itemStackIndices.push(itemsToBeSerialized.indexOf(item)) if typeof item.serialize is 'function' deserializer: 'Pane' id: @id - items: compact(@items.map((item) -> item.serialize?())) - itemStack: itemStack + items: itemsToBeSerialized.map((item) -> item.serialize()) + itemStackIndices: itemStackIndices activeItemURI: activeItemURI focused: @focused flexScale: @flexScale @@ -289,20 +290,20 @@ class Pane extends Model # Returns a pane item. getActiveItem: -> @activeItem - setActiveItem: (activeItem) -> + setActiveItem: (activeItem, options) -> + {modifyStack} = options if options? unless activeItem is @activeItem - @addItemToStack(activeItem) + @addItemToStack(activeItem) unless modifyStack is false @activeItem = activeItem @emitter.emit 'did-change-active-item', @activeItem @activeItem # Build the itemStack after deserializing - addItemsToStack: (itemStack) -> - if itemStack.length is 0 or itemStack.length isnt @items.length or itemStack.indexOf(-1) >= 0 - itemStack = @items.map((item) => @items.indexOf(item)) - for item, i in itemStack - index = itemStack.indexOf(i) - @addItemToStack(@items[index]) unless index is -1 + addItemsToStack: (itemStackIndices) -> + if itemStackIndices.length is 0 or itemStackIndices.length isnt @items.length or itemStackIndices.indexOf(-1) >= 0 + itemStackIndices = (i for i in [0..@items.length-1]) + for itemIndex in itemStackIndices + @addItemToStack(@items[itemIndex]) # Add item (or move item) to the end of the itemStack addItemToStack: (newItem) -> @@ -325,10 +326,19 @@ class Pane extends Model # Makes the most recently used item active. activateMostRecentlyUsedItem: -> if @items.length > 1 - index = @itemStack.length - 2 - mostRecentlyUsedItem = @itemStack[index] - @itemStack.splice(index, 1) - @setActiveItem(mostRecentlyUsedItem) + @itemStackIndex = @itemStack.length - 1 + @activateNextRecentlyUsedItem() + + # Makes the next item in the itemStack active. + activateNextRecentlyUsedItem: -> + @itemStackIndex = @itemStackIndex - 1 + nextRecentlyUsedItem = @itemStack[@itemStackIndex] + @setActiveItem(nextRecentlyUsedItem, modifyStack: false) + @itemStackIndex = @itemStack.length if @itemStackIndex is 0 + + # Moves the active item to the end of the itemStack once the ctrl key is lifted + stopMovingThroughStackAndMoveItemToEndOfStack: -> + @addItemToStack(@activeItem) # Public: Makes the next item active. activateNextItem: ->