Esempio n. 1
0
        private void CheckProgressUnresponsive()
        {
            var now = EditorApplication.timeSinceStartup;

            if (now - m_LastUpdate < k_CheckUnresponsiveFrequencyInSecond)
            {
                return;
            }

            EditorApplication.tick -= CheckProgressUnresponsive;

            m_LastUpdate = now;
            if (Progress.running)
            {
                var unresponsiveItem = Progress.EnumerateItems().FirstOrDefault(item => !item.responding);
                if (unresponsiveItem != null)
                {
                    m_CurrentProgressNotResponding = true;
                    RefreshProgressBar(new[] { unresponsiveItem });
                }
                else
                {
                    m_CurrentProgressNotResponding = false;
                    ScheduleCheckProgressUnresponsive();
                }
            }
            else
            {
                m_CurrentProgressNotResponding = false;
            }
        }
Esempio n. 2
0
        private void RefreshProgressBar(Progress.Item[] progressItems)
        {
            var taskCount = Progress.GetRunningProgressCount();

            if (taskCount == 0)
            {
                m_LastProgressId  = -1;
                m_LastElapsedTime = 0f;
                m_CurrentProgressNotResponding  = false;
                m_ProgressStatus.text           = String.Empty;
                m_ProgressPercentageStatus.text = String.Empty;
            }
            else
            {
                var currentItem = progressItems[0];
                if (!String.IsNullOrEmpty(currentItem.description))
                {
                    m_ProgressStatus.tooltip = currentItem.name + "\r\n" + currentItem.description;
                }
                m_ProgressPercentageStatus.text = Progress.globalProgress.ToString("P", percentageFormat);

                var remainingTimeText = "";
                if (Progress.EnumerateItems().Any(item => item.timeDisplayMode == Progress.TimeDisplayMode.ShowRemainingTime) && Progress.EnumerateItems().All(item => !item.indefinite) && Progress.globalRemainingTime.TotalSeconds > 0)
                {
                    remainingTimeText = $" [{Progress.globalRemainingTime:g}]";
                }

                if (taskCount > 1)
                {
                    m_ProgressStatus.text = $"Multiple tasks ({taskCount}){remainingTimeText}";
                }
                else
                {
                    m_ProgressStatus.text = $"{currentItem.name}{remainingTimeText}";
                }


                m_LastProgressId = currentItem.id;
                m_CurrentProgressNotResponding = true;
                for (int i = 0; i < progressItems.Length; ++i)
                {
                    if (!progressItems[i].responding)
                    {
                        m_LastProgressId = progressItems[i].id;
                        continue;
                    }
                    m_CurrentProgressNotResponding = false;
                    break;
                }

                m_LastElapsedTime = Mathf.Max(m_LastElapsedTime, currentItem.elapsedTime);
                if (m_CurrentProgressNotResponding)
                {
                    m_LastElapsedTime = float.MaxValue;
                }
            }
            RepaintProgress(progressItems);
        }
Esempio n. 3
0
        internal static void ClearInactive()
        {
            var finishedItems = Progress.EnumerateItems().Where(item => item.finished);

            foreach (var item in finishedItems)
            {
                item.Remove();
            }
        }
        private void UpdateModel()
        {
            RemoveAllElements();

            foreach (var op in Progress.EnumerateItems())
            {
                AddElement(op);
            }

            UpdateNbTasks();
        }
Esempio n. 5
0
        private void RefreshProgressBar(Progress.Item[] progressItems)
        {
            if (!this)
            {
                return;
            }

            if (!Progress.running)
            {
                // If we enter here, it means the last remaining progresses just finished or paused.
                ClearProgressStatus();
                RepaintProgress(progressItems);
                return;
            }

            var idleCount = Progress.EnumerateItems().Count(item => item.running && item.priority == (int)Progress.Priority.Idle);
            var taskCount = Progress.GetRunningProgressCount() - idleCount;

            if (taskCount == 0)
            {
                ClearProgressStatus();
            }
            else
            {
                var currentItem = progressItems.FirstOrDefault(item => item.priority != (int)Progress.Priority.Idle);
                if (currentItem != null && !String.IsNullOrEmpty(currentItem.description))
                {
                    m_ProgressStatus.tooltip = currentItem.name + "\r\n" + currentItem.description;
                }
                m_ProgressPercentageStatus.text = Progress.globalProgress.ToString("P", percentageFormat);

                var remainingTimeText = "";
                var runningProgresses = Progress.EnumerateItems().Where(item => item.running);
                if (Progress.globalRemainingTime.TotalSeconds > 0 && runningProgresses.Any(item => item.timeDisplayMode == Progress.TimeDisplayMode.ShowRemainingTime && item.priority != (int)Progress.Priority.Idle) &&
                    runningProgresses.All(item => !item.indefinite))
                {
                    remainingTimeText = $" [{Progress.globalRemainingTime:g}]";
                }

                if (taskCount > 1)
                {
                    m_ProgressStatus.text = $"Multiple tasks ({taskCount}){remainingTimeText}";
                }
                else
                {
                    m_ProgressStatus.text = $"{currentItem?.name}{remainingTimeText}";
                }

                ScheduleCheckProgressUnresponsive();
            }

            RepaintProgress(progressItems);
        }
Esempio n. 6
0
 private void CheckProgressUnresponsive()
 {
     if (Progress.running)
     {
         var unresponsiveItem = Progress.EnumerateItems().FirstOrDefault(item => !item.responding);
         if (unresponsiveItem != null)
         {
             m_CurrentProgressNotResponding = true;
             RefreshProgressBar(new[] { unresponsiveItem });
         }
         else
         {
             m_CurrentProgressNotResponding = false;
             DelayCheckProgressUnresponsive();
         }
     }
     else
     {
         m_CurrentProgressNotResponding = false;
     }
 }
Esempio n. 7
0
 void UpdateDismissAllButton()
 {
     m_DismissAllBtn.SetEnabled(Progress.EnumerateItems().Any(item => item.finished));
 }
Esempio n. 8
0
        void OnEnable()
        {
            s_Window     = this;
            titleContent = EditorGUIUtility.TrTextContent("Background Tasks");

            rootVisualElement.AddStyleSheetPath(ussPath);
            if (EditorGUIUtility.isProSkin)
            {
                rootVisualElement.AddStyleSheetPath(ussPathDark);
            }
            else
            {
                rootVisualElement.AddStyleSheetPath(ussPathLight);
            }

            var toolbar = new UIElements.Toolbar();

            m_DismissAllBtn = new ToolbarButton(ClearInactive)
            {
                name = "DismissAllBtn",
                text = L10n.Tr("Clear inactive"),
            };
            toolbar.Add(m_DismissAllBtn);

            // This is our friend the spacer
            toolbar.Add(new VisualElement()
            {
                style =
                {
                    flexGrow = 1
                }
            });

            rootVisualElement.Add(toolbar);
            s_VisualProgressItemTask = EditorGUIUtility.Load(k_UxmlProgressItemPath) as VisualTreeAsset;

            m_TreeView                 = new TreeView();
            m_TreeView.makeItem        = MakeTreeViewItem;
            m_TreeView.bindItem        = BindTreeViewItem;
            m_TreeView.unbindItem      = UnbindTreeViewItem;
            m_TreeView.destroyItem     = DestroyTreeViewItem;
            m_TreeView.fixedItemHeight = 50;
            m_TreeView.SetRootItems(new TreeViewItemData <Progress.Item>[] {});

            var scrollView = m_TreeView.Q <ScrollView>();

            if (scrollView != null)
            {
                scrollView.horizontalScrollerVisibility = ScrollerVisibility.Hidden;
            }

            rootVisualElement.Add(m_TreeView);
            m_TreeView.Rebuild();

            // Update the treeview with the existing items
            m_MissingParents        = new Dictionary <int, List <int> >();
            m_ContainedItems        = new HashSet <int>();
            m_ItemsNeedingExpansion = new HashSet <int>();
            OperationsAdded(Progress.EnumerateItems().ToArray());

            Progress.added   += OperationsAdded;
            Progress.removed += OperationsRemoved;
            Progress.updated += OperationsUpdated;
            UpdateDismissAllButton();
        }