public void Render(string model)
        {
            _renderComplete.Reset();
            var r = new ReleaseUI($"Render ReleaseUI for {ViewModel.Model.File.Path}", true);

            ViewModel.RenderStarted();
            SuspendLayout();
            try
            {
                if (model == null)
                {
                    Log.WriteError("Model is NULL, this should not happen!", typeof(DocumentWindow).FullName, MethodBase.GetCurrentMethod().Name);
                    return;
                }


                if (InvokeRequired)
                {
                    Invoke(new Action <string>(Render), model);
                    return;
                }

                PerformanceService.StartEvent($"{PerformanceService.CONST_RenderDocument}{ViewModel.Model.File.Path}");
                OutputService.Log($"Document Render for {ViewModel.Model.File.Path}");
                Log.WriteEnter(typeof(DocumentWindow).FullName, MethodBase.GetCurrentMethod().Name);

                // Setting SelectionChangedDelayedEnabled for the first time
                if (!fctbDocument.SelectionChangedDelayedEnabled)
                {
                    fctbDocument.SelectionChangedDelayedEnabled = true;
                }
                scBase.Panel1Collapsed = !XmlDal.DataModel.Options.DocumentSourceInfo;
                PreCachePropertyLineData();
                r.DoEvents();
                sourceInfo.Render(ViewModel.Model.File);
                fctbDocument.ClearCache();
                r.DoEvents();
                fctbDocument.Text = model;
                r.DoEvents();
                ApplyFolding();
                // Force the control to paint itself now

                fctbDocument.Invalidate();
                StatusUpdate(StatusModel.Completed);
                Log.WriteTrace("Document Render Complete...", typeof(DocumentWindow).FullName, MethodBase.GetCurrentMethod().Name);
                PerformanceService.StopEvent($"Rebuild Active Document for {ViewModel.Model.File.Path}", true);
                PerformanceService.StopEvent($"{PerformanceService.CONST_RenderDocument}{ViewModel.Model.File.Path}", true);
                r.Stop();
            }
            finally
            {
                ResumeLayout();
                ViewModel.DocumentRenderComplete();
                _renderComplete.Set();
            }
        }
        private void RenderCallback(TreeNodeCollection nodes)
        {
            var r = new ReleaseUI("DocumentMap.RenderCallback", true);

            if (IsDisposed)
            {
                return;
            }

            if (InvokeRequired)
            {
                Invoke(new Action <TreeNodeCollection>(RenderCallback), nodes);
                return;
            }

            #region Clear
            // Note: We are on the MainUI Thread.  We want to limit our activity to 50ms or less before we call Application.DoEvents (r.DoEvents)
            r.DoEvents("starting");
            var n = 0;
            for (int i = tvMapEntries.Nodes.Count - 1; i >= 0; i--)
            {
                n++;
                tvMapEntries.Nodes.RemoveAt(i);
                if (n % @break == 0)
                {
                    r.DoEvents("RemoveAt break");
                }
            }
            r.DoEvents("RemoveAt done");
            #endregion

            #region Add
            n = 0;
            foreach (TreeNode node in nodes)
            {
                n++;
                tvMapEntries.Nodes.Add(node);
                if (n % @break == 0)
                {
                    r.DoEvents("Node.Add break");
                }
            }
            r.DoEvents("Node.Add done");
            #endregion

            tvMapEntriesSplit.Clone(tvMapEntries);
            _isRendering = false;
            r.DoEvents("Clone");
            StatusPanel.StatusUpdate(StatusModel.Completed);
            ViewModel.RenderComplete();
            PerformanceService.StopEvent($"{PerformanceService.CONST_RenderDocumentMap}{ViewModel.LastPath}");
            r.Stop();
        }
        public void Render(List <DocumentEntry> model)
        {
            var r = new ReleaseUI("DocumentMap.Render");

            PerformanceService.StartEvent($"{PerformanceService.CONST_RenderDocumentMap}{ViewModel.LastPath}");
            // Note: Invoke is handled through ViewModelbase - Sara
            if (_isRendering)
            {
                return;
            }

            if (!MainViewModel.StartupComplete)
            {
                StatusPanel.StatusUpdate(StatusModel.Completed);
                return;
            }

            if (model == null)
            {
                ShowWarning();
                StatusPanel.StatusUpdate(StatusModel.Completed);
                return;
            }

            _isRendering   = true;
            wpOpen.Visible = false;
            panel3.Visible = true;

            StatusPanel.StatusUpdate(StatusModel.StartStopWatch);
            StatusPanel.StatusUpdate(StatusModel.Update("Loading", ""));

            r.Stop();

            ThreadPool.QueueUserWorkItem(delegate
            {
                var sw = new Stopwatch("DocumentMap.Render.BuildTreeView");
                Thread.CurrentThread.Name = "Building.DocumentMap.TreeView";
                ViewModel.BuildTreeView(model, RenderCallback);
                sw.Stop(0);
            });
        }