showPreserved
* property.
*/
private function isActive(mod:CollectionModification):Boolean
{
// might eventually have more individual item processing here
// if we're showing removed, we have to include this modificatoin
// if we're showing added, we have to *exclude* it
return _showPreserved;
}
/**
* @private
*
* Removes a particular CollectionModification from the
* deltas array.
*/
private function removeModification(mod:CollectionModification):Boolean
{
for (var i:int = 0; i < deltas.length; i++)
{
if (deltas[i] == mod)
{
deltas.splice(i,1);
return true;
}
}
return false;
}
/**
* @private
*
* Does the work of modifying the object to handle a collectionEvent of
* collectionEventKind.REMOVE so that the removal can be ignored
*/
private function integrateRemovedElements(event:CollectionEvent, startItemIndex:int, endItemIndex:int):void
{
var i:int = 0;
var j:int = 0;
var ignoredElementCount:int = 0;
// var inserted:Boolean = false;
var insertCount:int = event.items.length;
// offset must be used when looking at mod indexes
var offset:int = 0;
while (i < deltas.length && j < insertCount)
{
var mod:CollectionModification = CollectionModification(deltas[i]);
var newMod:CollectionModification = new CollectionModification(event.location, event.items[j],CollectionModification.REMOVE);
removedItems[getUniqueItemWrapper(event.items[j],newMod,0)] = newMod;
if (offset != 0)
mod.index += offset;
// we want to insert after all deletes at this location but
// before all adds
// Adds coinciding with the deleted elements just become deletes
// (actually, want this behavior to depend on removeItemAction)
if ((mod.isRemove && mod.index <= newMod.index) || (!mod.isRemove && mod.index < newMod.index))
{
i++;
continue;
}
// we are deleting a previously added element
// we want to mark it as deleted and remove
else if ((!mod.isRemove) && (mod.index == newMod.index))
{
deltas.splice(i+j,1);
}
else
{
// this is a deletion or marked added element at a point
// after where we are adding elements,
// so we'll just splice in our deleted item.
deltas.splice(i+j,0,newMod);
i++;
}
offset--;
j++;
}
// when we get to this point, either we've inserted all the mods
// OR we're at the end of the list. So only one of the following
// two loops will be executed
while (i < deltas.length)
{
mod = CollectionModification(deltas[i++]);
mod.index += offset;
}
while (j < insertCount)
{
deltas.push(newMod = new CollectionModification(event.location, event.items[j],CollectionModification.REMOVE));
removedItems[getUniqueItemWrapper(event.items[j],newMod,0)] = newMod;
j++;
}
deltaLength += event.items.length - ignoredElementCount;
}
/**
* @private
*
* Does the work of modifying the object to handle a collectionEvent of
* collectionEventKind.ADD so that the addition can be ignored
*/
private function integrateAddedElements(event:CollectionEvent, startItemIndex:int, endItemIndex:int):void
{
var i:int = 0;
var j:int = 0;
var inserted:Boolean = false;
var insertCount:int = event.items.length;
// offset must be used when looking at mod indexes
var offset:int = 0;
// adding is easier than deleting...we just find the
// right place in our delta array, splice all the modifications,
// and update the indices of subsequent modifications
while (i < deltas.length && j < insertCount)
{
var mod:CollectionModification = CollectionModification(deltas[i]);
var newMod:CollectionModification = new CollectionModification(event.location + j, null,CollectionModification.ADD);
addedItems[getUniqueItemWrapper(event.items[j],newMod,0)] = newMod;
// we want to insert after all deletes at this location but
// before all adds
// Adds coinciding with the deleted elements just become deletes
// (actually, want this behavior to depend on removeItemAction)
if ((mod.isRemove && mod.index <= newMod.index) || (!mod.isRemove && mod.index < newMod.index))
{
i++;
continue;
}
// this is a deletion or marked added element at a point
// after where we are adding elements,
// so we'll just splice in our deleted item.
deltas.splice(i+j,0,newMod);
offset++;
j++;
i++;
}
// when we get to this point, either we've inserted all the mods
// OR we're at the end of the list. So only one of the following
// two loops will be executed
while (i < deltas.length)
{
mod = CollectionModification(deltas[i++]);
mod.index += offset;
}
while (j < insertCount)
{
deltas.push(newMod = new CollectionModification(event.location + j, null,CollectionModification.ADD));
addedItems[getUniqueItemWrapper(event.items[j],newMod,0)] = newMod;
j++;
}
deltaLength -= event.items.length;
}
/**
* @private
*
* Does the work of modifying the object to handle a collectionEvent of
* collectionEventKind.REPLACE so that the replacement can be ignored
*/
private function integrateReplacedElements(event:CollectionEvent, startItemIndex:int, endItemIndex:int):void
{
var i:int = 0;
var j:int = 0;
var inserted:Boolean = false;
var insertCount:int = event.items.length;
// offset must be used when looking at mod indexes
var offset:int = 0;
// adding is easier than deleting...we just find the
// right place in our delta array, splice all the modifications,
// and update the indices of subsequent modifications
while (i < deltas.length && j < insertCount)
{
var oldItem:Object = PropertyChangeEvent(event.items[j]).oldValue;
var newItem:Object = PropertyChangeEvent(event.items[j]).newValue;
var mod:CollectionModification = CollectionModification(deltas[i]);
var newMod:CollectionModification = new CollectionModification(event.location + j, oldItem,CollectionModification.REPLACE);
// we want to insert after all deletes at this location but
// before all adds
// Adds coinciding with the deleted elements just become deletes
// (actually, want this behavior to depend on removeItemAction)
if ((mod.isRemove && mod.index <= newMod.index) || (!mod.isRemove && mod.index < newMod.index))
{
i++;
continue;
}
if (((mod.modificationType == CollectionModification.ADD) || (mod.modificationType == CollectionModification.REPLACE))
&& (mod.index == newMod.index))
{
// we've founded an added element that is being replaced, or a replaced element that
// is being replaced again. We're just going to ignore this modification, so the existing effect
// if any should show the replacement element being added/replaced, rather than playing a new
// effect. (Not positive this will work.)
i++;
j++;
// might also need to do some cleanup here, if we're indexing our modifications
continue;
}
// this is a deletion or marked added element at a point
// after where we are adding elements,
// so we'll just splice in our replacement item.
deltas.splice(i+j,0,newMod);
replacedItems[getUniqueItemWrapper(oldItem,newMod,event.location + j)] = newMod;
replacementItems[getUniqueItemWrapper(newItem,newMod,event.location + j,true)] = newMod;
j++;
i++;
}
// when we get to this point, either we've inserted all the mods
// OR we're at the end of the list. So only one of the following
// two loops will be executed
while (j < insertCount)
{
oldItem = PropertyChangeEvent(event.items[j]).oldValue;
newItem = PropertyChangeEvent(event.items[j]).newValue;
deltas.push(newMod = new CollectionModification(event.location + j, oldItem,CollectionModification.REPLACE));
replacedItems[getUniqueItemWrapper(oldItem,newMod,event.location + j)] = newMod;
replacementItems[getUniqueItemWrapper(newItem,newMod,event.location + j,true)] = newMod;
j++;
}
}
private function getUniqueItemWrapper(item:Object,mod:CollectionModification, index:int, isReplacement:Boolean = false):Object
{
if (mod && (mod.isRemove || (mod.modificationType == CollectionModification.REPLACE && !isReplacement)))
{
if (!itemWrappersByCollectionMod[mod])
itemWrappersByCollectionMod[mod] = new ItemWrapper(item);
return itemWrappersByCollectionMod[mod];
}
// TODO (aharui): This is kind of a hack...clean up the code to simplify
if (mod && (mod.modificationType == CollectionModification.ADD))
index = mod.index;
if (!itemWrappersByIndex[index])
itemWrappersByIndex[index] = new ItemWrapper(item);
return itemWrappersByIndex[index];
}
}
}
import mx.collections.ModifiedCollectionView;
import mx.collections.CursorBookmark;
import flash.events.EventDispatcher;
import mx.collections.IViewCursor;
import mx.events.CollectionEvent;
import mx.collections.ICollectionView;
import mx.core.mx_internal;
import mx.collections.errors.CursorError;
import mx.collections.errors.CollectionViewError;
import mx.collections.errors.ItemPendingError;
import mx.resources.IResourceManager;
import mx.resources.ResourceManager;
import mx.events.CollectionEventKind;
import mx.events.FlexEvent;
import mx.collections.errors.CursorError;
import flash.display.InteractiveObject;
use namespace mx_internal;
/**
* Dispatched whenever the cursor position is updated.
*
* @eventType mx.events.FlexEvent.CURSOR_UPDATE
*
* @langversion 3.0
* @playerversion Flash 9
* @playerversion AIR 1.1
* @productversion Flex 3
*/
[Event(name="cursorUpdate", type="mx.events.FlexEvent")]
[ResourceBundle("collections")]
/**
* @private
* The internal implementation of cursor for the ModifiedCollectionView.
* This cursor wraps a cursor to the underlying collection, and maintains
* additional state.
*/
class ModifiedCollectionViewCursor extends EventDispatcher implements IViewCursor
{
//--------------------------------------------------------------------------
//
// Class constants
//
//--------------------------------------------------------------------------
/**
* @private
*/
private static const BEFORE_FIRST_INDEX:int = -1;
/**
* @private
*/
private static const AFTER_LAST_INDEX:int = -2;
//--------------------------------------------------------------------------
//
// Constructor
//
//--------------------------------------------------------------------------
/**
* Constructor.
*
* Creates the cursor for the view.
*
* @param view The ModifiedCollectionView for which this is a cursor.
*
* @param cursor A cursor into the underlying collection wrapped by the
* ModifiedCollectionView.
*
* @param current The item this cursor is currently pointing at.
*
* @langversion 3.0
* @playerversion Flash 9
* @playerversion AIR 1.1
* @productversion Flex 3
*/
public function ModifiedCollectionViewCursor(view:ModifiedCollectionView, cursor:IViewCursor, current:Object)
{
super();
_view = view;
internalCursor = cursor;
if (cursor.beforeFirst && !current)
internalIndex = BEFORE_FIRST_INDEX;
else if (cursor.afterLast && !current)
internalIndex = AFTER_LAST_INDEX;
else
internalIndex = 0;
// This probably makes sense...
// _view.addEventListener(CollectionEvent.COLLECTION_CHANGE, collectionEventHandler, false, 0, true);
currentIndex = view.length > 0 ? 0 : AFTER_LAST_INDEX;
if (currentIndex == 0)
{
try
{
setCurrent(current,false);
}
catch(e:ItemPendingError)
{
currentIndex = BEFORE_FIRST_INDEX;
setCurrent(null, false);
}
}
}
//--------------------------------------------------------------------------
//
// Variables
//
//--------------------------------------------------------------------------
/**
* @private
*/
private var _view:ModifiedCollectionView;
/**
* @private
* An cursor into the underlying collection wrapped by the Modified
* collection view.
*/
public var internalCursor:IViewCursor;
/**
* @private
* The current overall index into the ModifiedCollectionView.
*/
mx_internal var currentIndex:int;
/**
* @private
* The position of the internalCursor in its ICollectionView.
* This is not part of the IViewCursor interface, so we
* maintain it independently.
*/
public var internalIndex:int;
/**
* @private
*/
private var currentValue:Object;
/**
* @private
*/
private var invalid:Boolean;
/**
* @private
* Used for accessing localized Error messages.
*/
private var resourceManager:IResourceManager =
ResourceManager.getInstance();
//--------------------------------------------------------------------------
//
// Properties
//
//--------------------------------------------------------------------------
/**
* Get a reference to the view that this cursor is associated with.
* @return the associated ICollectionView
*
* @langversion 3.0
* @playerversion Flash 9
* @playerversion AIR 1.1
* @productversion Flex 3
*/
public function get view():ICollectionView
{
checkValid();
return _view;
}
[Bindable("cursorUpdate")]
/**
* Provides access the object at the current location referenced by
* this cursor within the source collection.
* If the cursor is beyond the ends of the collection (beforeFirst,
* afterLast) this will return null.
*
* @see mx.collections.IViewCursor#moveNext
* @see mx.collections.IViewCursor#movePrevious
* @see mx.collections.IViewCursor#seek
* @see mx.collections.IViewCursor#beforeFirst
* @see mx.collections.IViewCursor#afterLast
*
* @langversion 3.0
* @playerversion Flash 9
* @playerversion AIR 1.1
* @productversion Flex 3
*/
public function get current():Object
{
checkValid();
return currentValue;
}
[Bindable("cursorUpdate")]
/**
* Provides access to the bookmark of the item returned by the
* current property.
* The bookmark can be used to move the cursor to a previously visited
* item, or one relative to it (see the seek() method for
* more information).
*
* @see mx.collections.IViewCursor#current
* @see mx.collections.IViewCursor#seek
*
* @langversion 3.0
* @playerversion Flash 9
* @playerversion AIR 1.1
* @productversion Flex 3
*/
public function get bookmark():CursorBookmark
{
checkValid();
if (view.length == 0 || beforeFirst)
return CursorBookmark.FIRST;
else if (afterLast)
return CursorBookmark.LAST;
return ModifiedCollectionView(view).getBookmark(this);
}
[Bindable("cursorUpdate")]
/**
* true if the current is sitting before the first item in the view.
* If the ICollectionView is empty (length == 0) this will always
* be true.
*
* @langversion 3.0
* @playerversion Flash 9
* @playerversion AIR 1.1
* @productversion Flex 3
*/
public function get beforeFirst():Boolean
{
checkValid();
return currentIndex == BEFORE_FIRST_INDEX || view.length == 0;
}
[Bindable("cursorUpdate")]
/**
* true if the cursor is sitting after the last item in the view.
* If the ICollectionView is empty (length == 0) this will always
* be true.
*
* @langversion 3.0
* @playerversion Flash 9
* @playerversion AIR 1.1
* @productversion Flex 3
*/
public function get afterLast():Boolean
{
checkValid();
return currentIndex == AFTER_LAST_INDEX || view.length == 0;
}
/**
* Finds the item with the specified properties within the
* collection and positions the cursor on that item.
* If the item can not be found no change to the current location will be
* made.
* findAny() can only be called on sorted views, if the view
* isn't sorted a CursorError will be thrown.
*
* If the associated collection is remote, and not all of the items have
* been cached locally this method will begin an asynchronous fetch from the
* remote collection, or if one is already in progress wait for it to
* complete before making another fetch request.
* If multiple items can match the search criteria then the item found is
* non-deterministic.
* If it is important to find the first or last occurrence of an item in a
* non-unique index use the findFirst() or
* findLast().
* The values specified must be configured as name-value pairs, as in an
* associative array (or the actual object to search for).
* The values of the names specified must match those properties specified in
* the sort. for example
* If properties "x", "y", and "z" are the in the current index, the values
* specified should be {x:x-value, y:y-value,z:z-value}.
* When all of the data is local this method will return true if
* the item can be found and false otherwise.
* If the data is not local and an asynchronous operation must be performed,
* an ItemPendingError will be thrown.
*
* @see mx.collections.IViewCursor#findFirst
* @see mx.collections.IViewCursor#findLast
* @see mx.collections.errors.ItemPendingError
*
* @langversion 3.0
* @playerversion Flash 9
* @playerversion AIR 1.1
* @productversion Flex 3
*/
public function findAny(values:Object):Boolean
{
// not implemented
return false;
}
/**
* Finds the first item with the specified properties
* within the collection and positions the cursor on that item.
* If the item can not be found no change to the current location will be
* made.
* findFirst() can only be called on sorted views, if the view
* isn't sorted a CursorError will be thrown.
*
* If the associated collection is remote, and not all of the items have been
* cached locally this method will begin an asynchronous fetch from the
* remote collection, or if one is already in progress wait for it to
* complete before making another fetch request.
* If it is not important to find the first occurrence of an item in a
* non-unique index use findAny() as it may be a little faster.
* The values specified must be configured as name-value pairs, as in an
* associative array (or the actual object to search for).
* The values of the names specified must match those properties specified in
* the sort. for example If properties "x", "y", and "z" are the in the current
* index, the values specified should be {x:x-value, y:y-value,z:z-value}.
* When all of the data is local this method will
* return true if the item can be found and false otherwise.
* If the data is not local and an asynchronous operation must be performed,
* an ItemPendingError will be thrown.
*
* @see mx.collections.IViewCursor#findAny
* @see mx.collections.IViewCursor#findLast
* @see mx.collections.errors.ItemPendingError
*
* @langversion 3.0
* @playerversion Flash 9
* @playerversion AIR 1.1
* @productversion Flex 3
*/
public function findFirst(values:Object):Boolean
{
// not implemented
return false;
}
/**
* Finds the last item with the specified properties
* within the collection and positions the cursor on that item.
* If the item can not be found no change to the current location will be
* made.
* findLast() can only be called on sorted views, if the view
* isn't sorted a CursorError will be thrown.
*
* If the associated collection is remote, and not all of the items have been
* cached locally this method will begin an asynchronous fetch from the
* remote collection, or if one is already in progress wait for it to
* complete before making another fetch request.
* If it is not important to find the last occurrence of an item in a
* non-unique index use findAny() as it may be a little faster.
* The values specified must be configured as name-value pairs, as in an
* associative array (or the actual object to search for).
* The values of the names specified must match those properties specified in
* the sort. for example If properties "x", "y", and "z" are the in the current
* index, the values specified should be {x:x-value, y:y-value,z:z-value}.
* When all of the data is local this method will
* return true if the item can be found and false otherwise.
* If the data is not local and an asynchronous operation must be performed,
* an ItemPendingError will be thrown.
*
* @see mx.collections.IViewCursor#findAny
* @see mx.collections.IViewCursor#findFirst
* @see mx.collections.errors.ItemPendingError
*
* @langversion 3.0
* @playerversion Flash 9
* @playerversion AIR 1.1
* @productversion Flex 3
*/
public function findLast(values:Object):Boolean
{
// not implemented
return false;
}
/**
* Insert the specified item before the cursor's current position.
* If the cursor is afterLast the insertion
* will happen at the end of the View. If the cursor is
* beforeFirst on a non-empty view an error will be thrown.
*
* @langversion 3.0
* @playerversion Flash 9
* @playerversion AIR 1.1
* @productversion Flex 3
*/
public function insert(item:Object):void
{
// not implemented
}
/**
* Moves the cursor to the next item within the collection. On success
* the current property will be updated to reference the object at this
* new location. Returns true if current is valid, false if not (afterLast).
* If the data is not local and an asynchronous operation must be performed, an
* ItemPendingError will be thrown. See the ItemPendingError docs
* as well as the collections documentation for more information on using the
* ItemPendingError.
*
* @return true if still in the list, false if current is now afterLast
*
* @see mx.collections.IViewCursor#current
* @see mx.collections.IViewCursor#movePrevious
* @see mx.collections.errors.ItemPendingError
* @see mx.collections.events.ItemAvailableEvent
* @example
*
* var myArrayCollection:ICollectionView = new ArrayCollection(["Bobby", "Mark", "Trevor", "Jacey", "Tyler"]);
* var cursor:IViewCursor = myArrayCollection.createCursor();
* while (!cursor.afterLast)
* {
* trace(cursor.current);
* cursor.moveNext();
* }
*
*
* @langversion 3.0
* @playerversion Flash 9
* @playerversion AIR 1.1
* @productversion Flex 3
*/
public function moveNext():Boolean
{
//the afterLast getter checks validity and also checks length > 0
if (afterLast)
{
return false;
}
// we can't set the index until we know that we can move there first.
var tempIndex:int = beforeFirst ? 0 : currentIndex + 1;
if (tempIndex >= view.length)
{
tempIndex = AFTER_LAST_INDEX;
setCurrent(null);
}
else
{
//setCurrent(ModifiedCollectionView(view).getItemAt(tempIndex));
setCurrent(ModifiedCollectionView(view).getWrappedItemUsingCursor(this,tempIndex));
}
currentIndex = tempIndex;
return !afterLast;
}
/**
* Moves the cursor to the previous item within the collection. On success
* the current property will be updated to reference the object at this
* new location. Returns true if current is valid, false if not (beforeFirst).
* If the data is not local and an asynchronous operation must be performed, an
* ItemPendingError will be thrown. See the ItemPendingError docs
* as well as the collections documentation for more information on using the
* ItemPendingError.
*
* @return true if still in the list, false if current is now beforeFirst
*
* @see mx.collections.IViewCursor#current
* @see mx.collections.IViewCursor#moveNext
* @see mx.collections.errors.ItemPendingError
* @see mx.collections.events.ItemAvailableEvent
* @example
*
* var myArrayCollection:ICollectionView = new ArrayCollection(["Bobby", "Mark", "Trevor", "Jacey", "Tyler"]);
* var cursor:ICursor = myArrayCollection.createCursor();
* cursor.seek(CursorBookmark.last);
* while (!cursor.beforeFirst)
* {
* trace(current);
* cursor.movePrevious();
* }
*
*
* @langversion 3.0
* @playerversion Flash 9
* @playerversion AIR 1.1
* @productversion Flex 3
*/
public function movePrevious():Boolean
{
//the afterLast getter checks validity and also checks length > 0
if (beforeFirst)
{
return false;
}
// we can't set the index until we know that we can move there first
var tempIndex:int = afterLast ? view.length - 1 : currentIndex - 1;
if (tempIndex == -1)
{
tempIndex = BEFORE_FIRST_INDEX;
setCurrent(null);
}
else
{
//setCurrent(ModifiedCollectionView(view).getItemAt(tempIndex));
setCurrent(ModifiedCollectionView(view).getWrappedItemUsingCursor(this,tempIndex));
}
currentIndex = tempIndex;
return !beforeFirst;
}
/**
* Remove the current item and return it. If the cursor is
* beforeFirst or afterLast throw a
* CursorError.
*
* @langversion 3.0
* @playerversion Flash 9
* @playerversion AIR 1.1
* @productversion Flex 3
*/
public function remove():Object
{
// not implemented
return null;
}
/**
* Moves the cursor to a location at an offset from the specified
* bookmark.
* The offset can be negative in which case the cursor is positioned an
* offset number of items prior to the specified bookmark.
* If the associated collection is remote, and not all of the items have been
* cached locally this method will begin an asynchronous fetch from the
* remote collection.
*
* If the data is not local and an asynchronous operation must be performed, an
* ItemPendingError will be thrown. See the ItemPendingError docs
* as well as the collections documentation for more information on using the
* ItemPendingError.
*
*
* @param bookmark CursorBookmark reference to marker information that
* allows repositioning to a specific location.
* In addition to supplying a value returned from the bookmark
* property, there are three constant bookmark values that can be
* specified:
* CursorBookmark.FIRST - seek from
* the start (first element) of the collectionCursorBookmark.CURRENT - seek from
* the current position in the collectionCursorBookmark.LAST - seek from the
* end (last element) of the collection