Example #1
0
        private void BringToLife()
        {
            if (_dt == null && _hasImageLoaded)
            {
                _dt = new DispatcherTimer();
                OrganicInterval();
                _dt.Tick += OnTick;

                double d = Random.NextDouble();
                double delayInSeconds = 3 * d; // 0 to 9 seconds.
                delayInSeconds *= 2.1;         // multiply/space-out

#if DEBUG_LIVE_TILES
                Debug.WriteLine("__LIVE_TILE starting: " + ImageSource);
#endif

                IntervalDispatcher.BeginInvoke(
                    TimeSpan.FromSeconds(delayInSeconds),
                    () => {
                    var dt = _dt;
                    if (dt != null)
                    {
                        dt.Start();
                    }
                });
            }
        }
        protected override void OnContentPresenterLoaded(RoutedEventArgs e)
        {
            Debug("OnContentPresenterLoaded");

            base.OnContentPresenterLoaded(e);

            if (_state == LoadingState.StartingLoad || _state == LoadingState.ContentPresenterUnloaded)
            {
                // Check for the underlying ready state.
                UpdateState(LoadingState.ContentPresenterLoaded);

                // DIFFERENCE:
                // My original implementation had a minimum loading time.
                // If the time had not elapsed, this would invoke again.
                // The reason was probably to allow the DataContext and
                // visuals to all be realized enough to compute whether
                // it was a "smart" set of content or not.

                // CONSIDER:
                // Perhaps a DelayDispatchTimer here or similar.

                // TODO: Could make this configurable...

                IntervalDispatcher.BeginInvoke(TimeSpan.FromSeconds(.1), AnalyzeOrTransition);
            }
            else
            {
                var x = _state;
            }
        }
        private void UpdateState(LoadingState state)
        {
            Debug("New State: " + state.ToString());

            if (_state != state)
            {
                _state = state;
                switch (state)
                {
                case LoadingState.Constructed:
                    break;

                case LoadingState.StartingLoad:
                    if (!HasContentLoaded)
                    {
                        if (LoadingDisplayOffset.TotalSeconds == 0.0 && _state != LoadingState.Failed)
                        {
                            Debug("Offset seconds of 0, going to loading state");
                            UpdateCover(CoverState.Loading);
                        }
                        else
                        {
                            // UpdateCover(CoverState.Blank); // ? is this necessary ?
                            IntervalDispatcher.BeginInvoke(LoadingDisplayOffset, StartingLoadDelayExpired);
                        }
                    }
                    break;

                case LoadingState.TemplateApplied:
                    UpdateCover(CoverState.Blank);
                    System.Diagnostics.Debug.Assert(IsCovered == true);

                    break;

                case LoadingState.Unknown:
                    break;

                case LoadingState.ContentUncovered:
                    UpdateCover(CoverState.Blank);
                    break;

                case LoadingState.ContentPresenterLoaded:
                case LoadingState.ContentPresenterUnloaded:
                case LoadingState.Failed:
                case LoadingState.ReadyToUncover:
                    break;

                case LoadingState.TimedOut:
                    UpdateCover(CoverState.Timeout);
                    break;

                default:
//#if DEBUG
//                        throw new InvalidOperationException();
//#endif
                    break;
                }
            }
        }
Example #4
0
        private void UpdateItems()
        {
            if (!_templateApplied || DesignerProperties.IsInDesignTool)
            {
                return;
            }
            if (_height < 1)
            {
                Dispatcher.BeginInvoke(UpdateItems);
                return;
            }

            _itemsInFirstScreen = (_height / MinimumItemHeight) * 1.8;
            // VOODOO MAGIC.
            // Moved from 1.3 to 1.8 right before my 2.2 release.

            StopRenderingQueue();

            var oldGroupItems = new List <ItemGroup>(_groupItems);

            _groupItems.Clear();

            int totalItems = -1;

            if (ItemsSource != null)
            {
                var list = (IList)ItemsSource;

                if (IsFlatList)
                {
                    var alist = new List <IList>(1);
                    var blist = list;
                    alist.Add(blist);
                    list = alist;
                }

                int groupCount = list.Count;

                if (groupCount <= 0)
                {
                    ShowHideIsEmpty(false);
                }

                // For long lists of data...
                int actualItemCount = 0;
                for (int i = 0; i < list.Count; ++i)
                {
                    IList x = list[i] as IList;
                    if (x != null)
                    {
                        actualItemCount += x.Count;
                    }
                }

                double approximateVisualLoadPoint = actualItemCount * .45;
                // WAS PREVIOUSLY: .66; in my voodoo magic...
                if (approximateVisualLoadPoint > _itemsInFirstScreen)
                {
                    // Debug.WriteLine("Overriding the visual load point to be " + approximateVisualLoadPoint + " over " + _itemsInFirstScreen);
                    _itemsInFirstScreen = approximateVisualLoadPoint;
                }

                for (int i = 0; i < list.Count; ++i)
                {
                    //ItemGroup oldGroupAtIndex = null;
                    //if (oldGroupItems.Count > i)
                    //{
                    //oldGroupAtIndex = oldGroupItems[i];
                    //Debug.WriteLine("Was an old group, too.");
                    //}

                    var group = GetOrCreateGroup(list[i], i);
                    _groupItems.Add(group);

                    // if (oldGroupAtIndex != null &&
                    //     oldGroupAtIndex.Name != group.Name)

                    var groupItems = list[i] as IList;
#if DEBUG
                    if (groupItems == null)
                    {
                        throw new NotSupportedException("Must be an IList. " + list[i].ToString());
                    }
#endif

                    UpdateMappings(group, groupItems, ref totalItems);
#if DEBUG_GIC
                    Debug.WriteLine("totalItems is now: *** " + totalItems);
#endif
                }

                if (groupCount == 0 || totalItems < 0)
                // was: totalItems <= to 0, but since it started at -1,
                //      that meant 1 item was nothing.
                {
#if DEBUG_GIC
                    Debug.WriteLine("GC 0 and TC 0 so done loading now.");
#endif
                    ShowHideIsEmpty(false);
                    IsLoadComplete = true;

                    var isend = ItemsSource as ISendLoadComplete;
                    if (isend != null && !isend.IsLoadComplete)
                    {
#if DEBUG_GIC
                        Debug.WriteLine("It's an isend but not ready.");
#endif
                    }
                    else if (isend != null)
                    {
#if DEBUG_GIC
                        Debug.WriteLine("It's an isend and ready!");
#endif
                    }
                }
                else
                {
                    // Display! ...... //IsLoadComplete = true;

                    _haveItems = true;
                    ShowHideIsEmpty(true);
                    if (!_myPageLoading)
                    {
                        _myPageLoading = true;
                    }
                }
            }
            else
            {
                // Want to eliminate the flicker the first time this pops up.
                IntervalDispatcher.BeginInvoke(TimeSpan.FromSeconds(0.25), EvaluateWhetherNullStill);
#if DEBUG_GIC
                Debug.WriteLine("ItemsSource is now null.");
#endif
            }

            List <ItemGroup> groupsToRemove = new List <ItemGroup>();

            for (int gi = 0; gi < _groupItems.Count; ++gi)
            {
                var group = _groupItems[gi];
#if DEBUG_GIC
                Debug.WriteLine("*" + group.Name + " (" + group.Items.Count + ")");
#endif

                if (group.Items.Count == 0)
                {
                    // Hide the group! From a logic standpoint, this should have been detected above.
#if DEBUG_GIC
                    Debug.WriteLine("Hide the group! From a logic standpoint..." + group);
#endif
                    groupsToRemove.Add(group);
                }
            }
            foreach (var ii in oldGroupItems)
            {
                // SLOW.
                if (_groupItems.Contains(ii))
                {
                    continue;
                }
#if DEBUG_GIC
                Debug.WriteLine("Slow hide the group! " + ii);
#endif
                groupsToRemove.Add(ii);
            }
            foreach (var g in groupsToRemove)
            {
#if DEBUG_GIC
                Debug.WriteLine("Removing a group that was not in the new items source.");
#endif
                g.RemoveGroup(this);
                if (_groups.ContainsValue(g))
                {
                    foreach (var grp in _groups)
                    {
                        if (grp.Value == g)
                        {
                            var key = grp.Key;
                            _groups.Remove(key);
                            break;
                        }
                    }
                }
            }

            StartRenderingQueue();
        }