 				finishRepeat();
 		}
 	}
+
+    // Note that we implement seek() in the instance class for Sequence,
+    // but in the factory class for Parallel. This is because we can do
+    // it at the factory level for Parallel, but for Sequence we need
+    // extra functionality that is only available in the instance class.
+    /**
+     * @inheritDoc
+     * 
+     * In a Sequence effect, seek determines which child effect should be
+     * the active one and seeks to the appropriate time in that effect.
+     * Previous effects in the sequence will be ended (if playing) or 
+     * skipped (if not yet started but seekTime is past the time
+     * when they would have ended). Note that 'skipping' a child effect may
+     * entail playing it with zero duration to avoid side-effects that may
+     * occur from not playing the effect at all.
+     */
+    override public function seek(seekTime:Number):void
+    {
+        /**
+        * Behavior of this command depends on what state we're in:
+        * - if we're in a startDelay, then cut down the seekTime by
+        * the amount of time we have left to sleep
+        * - if the seekTime doesn't get us past the startDelay, then
+        * reduce the amount of startDelay appropriately and return
+        * - if the seekTime is greater than the current playheadTime
+        *   - if the seekTime puts the playheadTime into a different
+        *   child effect, end the currently playing child effects,
+        *   play intervening ones with no duration (or skip?),
+        *   and start the ones that should be active and seek to their
+        *   appropriate time
+        *   - if the seektime is still in the currently playing effects
+        *   just seek to the appropriate time
+        * - else the seekTime is less than the current time
+        *   - if the seektime is still in the currently playing effects
+        *   just seek to the appropriate time
+        *   - else end the currently playing effects and start over from
+        *   the beginning (playing effects with no duration or skipping,
+        *   then playing/seeking for the correct child effect
+        */
+        // TODO (chaase): handle startDelay     
+        
+        if (seekTime < playheadTime)
+        {
+            // TODO (chaase): Handle seeking back in time
+            // idea: Maybe once we get playing a sequence in reverse
+            // working perfectly, seeking back in time should seentially 
+            // 'play' (with zero duration) the child effects in reverse until
+            // we get to the proper effect for the seek time
+        }
+        else
+        {
+            // figure out if desired time is in currently playing effects
+            // if so, just seek them to the time
+            // else, end them, skip later effects, and play/seek the
+            // appropriate child effects
+            if (activeEffectQueue && activeEffectQueue.length > 0)
+            {
+                var cumulativeDuration:Number = 0;
+                for (var i:int = 0; i < activeEffectQueue.length; ++i)
+                {
+                    var instances:Array = childSets[i];
+                    var startTime:Number = cumulativeDuration;
+                    var endTime:Number = cumulativeDuration + 
+                        instances[0].actualDuration;
+                    if (seekTime < endTime)
+                    {
+                        // These are the effects that should be active
+                        // simply seek to the right time in the effect
+                        if (currentSetIndex != i)
+                        {
+                            currentSetIndex = i;
+                            playCurrentChildSet();
+                        }
+                        for (var k:int = 0; k < instances.length; k++)
+                            instances[k].seek(seekTime - startTime);
+                        break;
+                        // otherwise, skip to the next instance
+                    }
+                    else
+                    {
+                        // if we're seeking past the currently playing
+                        // instance, end it
+                        if (currentSetIndex == i)
+                        {
+                            for (var j:int = 0; j < instances.length; j++)
+                            {
+                                // setting endEffectCalled works around a side-effect
+                                // of the onEffectEnd() handler where it will
+                                // automatically launch the next child effect
+                                endEffectCalled = true;
+                                instances[j].end();
+                                endEffectCalled = false;
+                            }
+                            currentSetIndex = -1;
+                        }
+                        else
+                        {
+                            // Skip past effects by playing them with no duration
+                            for (var l:int = 0; l < instances.length; l++)
+                                instances[l].playWithNoDuration();
+                        }
+                    }
+                    cumulativeDuration = endTime;
+                }
+                
+            }
+        }
+        // Seek in the SequenceInstance itself, which advances the
+        // Tween timer running on the effect
+        super.seek(seekTime);
+    }
+
 	//--------------------------------------------------------------------------
 	//
 	//  Methods
 	//
 	//--------------------------------------------------------------------------
 
+    private function playCurrentChildSet():void
+    {
+        var childEffect:EffectInstance;
+        var instances:Array = activeEffectQueue[currentSetIndex];
+        
+        currentSet = [];
+        
+        for (var i:int = 0; i < instances.length; i++)
+        {
+            childEffect = instances[i];
+            
+            /*
+            if (childEffect is TweenEffectInstance)
+            {
+                var offset:Number =
+                    Tween.intervalTime - startTime - currentInstanceDuration;
+                offset = isNaN(offset) ? 0 : offset;
+                TweenEffectInstance(childEffect).seek(offset);
+            }
+            */
+            
+            currentSet.push(childEffect);
+            childEffect.playReversed = playReversed;
+            // Block all layout, responses from web services, and other
+            // background processing until the effect finishes executing.
+            if (childEffect.suspendBackgroundProcessing)
+                UIComponent.suspendBackgroundProcessing();  
+            childEffect.startEffect();
+        }
+        
+        currentInstanceDuration += childEffect.actualDuration;
+        
+    }
+    
 	/**
 	 *  @private
 	 */

	
import mx.core.UIComponent;
import mx.core.mx_internal;
import mx.effects.EffectInstance;
import mx.effects.IEffectInstance;
import mx.effects.Tween;

				return false;
		}
	
	    playCurrentChildSet();
	    
		/*
		while (activeEffectQueue[activeChildCount])
		{
