using System;
using System.Collections;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
using System.Diagnostics;
using System.IO;
using Beefy;
using Beefy.widgets;
using Beefy.theme;
using Beefy.gfx;
using Beefy.events;
using Beefy.theme.dark;
using Beefy.utils;
using Beefy.geom;
using IDE.Debugger;
using IDE.Compiler;
using System.Security.Cryptography;
using IDE.util;
using Beefy2D.utils;

namespace IDE.ui
{
    public enum SourceElementType
    {
        Normal,
        Keyword,
        Literal,
		Comment,
        Identifier,
		Local,
		Parameter,
		Member,
        Method,
		Type,
		PrimitiveType,
		Struct,
		GenericParam,
        RefType,
		Interface,
        Namespace,

        Disassembly_Text,
        Disassembly_FileName,

        Error,

		BuildError,
		BuildWarning,

		VisibleWhiteSpace
    }

    //[Flags]
    public enum SourceElementFlags
    {
        Error                   = 1,
        Warning                 = 2,
        IsAfter                 = 4,
        Skipped                 = 8,
        CompilerFlags_Mask      = 0x0F,

        SpellingError           = 0x10,
        Find_Matches            = 0x20,
		Find_CurrentSelection   = 0x40,
        SymbolReference         = 0x80,
        EditorFlags_Mask        = 0xF0,

        MASK = 0xFF
    }

    public class SourceEditWidget : DarkEditWidget
    {
        public TextPanel mPanel;

        public this(SourceViewPanel panel, SourceEditWidget refEditWidget = null)
            : base(new SourceEditWidgetContent((refEditWidget != null) ? refEditWidget.mEditWidgetContent : null))
        {
            mPanel = panel;
        }

        public this(SourceViewPanel panel, SourceEditWidgetContent content)
            : base(content)
        {
            mPanel = panel;
        }

        public override void DrawAll(Graphics g)
        {
            base.DrawAll(g);
        }

        public override void MouseDown(float x, float y, int32 btn, int32 btnCount)
        {
            base.MouseDown(x, y, btn, btnCount);
        }

		public override void MouseWheel(MouseEvent evt)
		{
			var sewc = mEditWidgetContent as SourceEditWidgetContent;
			if ((sewc.mSourceViewPanel != null) && (sewc.mSourceViewPanel.mEmbedParent != null))
			{
				if (mHasFocus)
				{
					if ((mVertScrollbar != null) && (mVertScrollbar.mAllowMouseWheel))
					{
						mVertScrollbar.MouseWheel(evt.mX, evt.mY, evt.mWheelDeltaX, evt.mWheelDeltaY);
						return;
					}
				}

				var target = sewc.mSourceViewPanel.mEmbedParent.mEditWidget.mEditWidgetContent;

				MouseEvent parentEvt = scope .();
				parentEvt.mWheelDeltaX = evt.mWheelDeltaX;
				parentEvt.mWheelDeltaY = evt.mWheelDeltaY;
				parentEvt.mSender = evt.mSender;

				// Keep passing it up until some is interested in using it...
				SelfToOtherTranslate(target, evt.mX, evt.mY, out parentEvt.mX, out parentEvt.mY);

				target.MouseWheel(evt);
				return;
			}

			base.MouseWheel(evt);
		}

        public override void GotFocus()
        {
			//Debug.WriteLine("SourceViewPanel.GotFocus {0}", this);

			if (var tabbedView = mParent.mParent as IDETabbedView)
			{
				if (tabbedView.mIsFillWidget)
					gApp.mActiveDocumentsTabbedView = tabbedView;
			}

			var sourceEditWidgetContent = (SourceEditWidgetContent)mEditWidgetContent;
			// Just got focus, flip this on until we get a KeyDown
			sourceEditWidgetContent.mIgnoreKeyChar = true;

            if (mPanel != null)
			{
				mPanel.mLastFocusTick = IDEApp.sApp.mUpdateCnt;
                mPanel.EditGotFocus();
			}

			var sewc = mEditWidgetContent as SourceEditWidgetContent;
			if ((sewc.mSourceViewPanel != null) && (sewc.mSourceViewPanel.mEmbedParent != null))
			{
				mVertScrollbar.mAllowMouseWheel = true;
				mHorzScrollbar.mAllowMouseWheel = true;
			}

			DeleteAndNullify!(gApp.mDeferredShowSource);

            base.GotFocus();
        }

        public override void LostFocus()
        {
            if (mPanel != null)
                mPanel.EditLostFocus();

			var sewc = mEditWidgetContent as SourceEditWidgetContent;
			if ((sewc.mSourceViewPanel != null) && (sewc.mSourceViewPanel.mEmbedParent != null))
			{
				mVertScrollbar.mAllowMouseWheel = false;
				mHorzScrollbar.mAllowMouseWheel = false;
			}

            base.LostFocus();
        }

		protected override bool WantsUnfocus()
		{
			if (mWidgetWindow != null)
			{
				if (mWidgetWindow.mOverWidget is PanelSplitter)
					return false;
				if (mWidgetWindow.mOverWidget is TabbedView.TabButton)
					return false;
				if (mWidgetWindow.mOverWidget is DarkTabbedView.DarkTabButtonClose)
					return false;
			}

			return base.WantsUnfocus();
		}
    }

    public class TrackedTextElementView
    {
        public TrackedTextElement mTrackedElement;
        public PersistentTextPosition mTextPosition;
        public int32 mLastBoundLine = -1;
		public int32 mLastMoveIdx; // Compare to mTrackedElement.mMoveIdx

		public this(TrackedTextElement trackedEntry)
		{
			mTrackedElement = trackedEntry;
			mTrackedElement.AddRef();
		}

		public ~this()
		{
			mTrackedElement.Deref();
		}
    }    

	public class HoverResolveTask
	{
		public int32 mCursorPos;
		public String mResult ~ delete _;
		public int32? mLine;
		public int32? mLineChar;

		public ~this()
		{
			
		}
	}

	public class SourceFindTask
	{
		public WaitEvent mDoneEvent = new WaitEvent() ~ delete _;
		public SourceViewPanel mSourceViewPanel;
		public bool mCancelling;
		public String mFilePath ~ delete _;
		public String mFileName ~ delete _;
		public String mBackupFileName ~ delete _; // Didn't match hash
		public String mFoundPath ~ delete _;
		public Dictionary<String, String> mRemapMap = new .() ~ DeleteDictionaryAndKeysAndValues!(_);
		
		public ~this()
		{
			Cancel();
			WaitFor();
		}

		public void Cancel()
		{
			mCancelling = true;
		}

		public bool WaitFor(int waitMS = -1)
		{
			return mDoneEvent.WaitFor(waitMS);
		}

		void CheckFile(String filePath)
		{
			bool hashMatches = true;
			if (!(mSourceViewPanel.mWantHash case .None))
			{
				SourceHash.Kind hashKind = mSourceViewPanel.mWantHash.GetKind();
				
				var buffer = scope String();
				SourceHash hash = ?;
				if (gApp.LoadTextFile(filePath, buffer, true, scope [&] () => { hash = SourceHash.Create(hashKind, buffer); }) case .Ok)
				{
					if (hash != mSourceViewPanel.mWantHash)
						hashMatches = false;
				}
			}

			if (!hashMatches)
			{
				if (mBackupFileName == null)
					mBackupFileName = new String(filePath);
			}
			else if (mFoundPath == null)
				mFoundPath = new String(filePath);
		}

		void SearchPath(String dirPath)
		{
			if (!dirPath.EndsWith('*'))
			{
				for (var file in Directory.EnumerateFiles(dirPath))
				{
					var fileName = scope String();
					file.GetFileName(fileName);
					if (fileName.Equals(mFileName, .OrdinalIgnoreCase))
					{
						if (mFoundPath == null)
						{
							var filePath = scope String();
							file.GetFilePath(filePath);
							CheckFile(filePath);
						}
					}
				}
			}

			String dirSearchStr = scope String();
			dirSearchStr.Append(dirPath);
			if (!dirSearchStr.EndsWith('*'))
				dirSearchStr.Append("/*");
			for (var dir in Directory.Enumerate(dirSearchStr, .Directories))
			{
				var subPath = scope String();
				dir.GetFilePath(subPath);
				SearchPath(subPath);
			}
		}

		public void Run()
		{
			let dir = scope String();
			Path.GetDirectoryPath(mFilePath, dir);
			IDEUtils.FixFilePath(dir);
			if (!Environment.IsFileSystemCaseSensitive)
				dir.ToUpper();

			// Check for files relative to manually-specified alias paths
			for (var (origDir, localDir) in mRemapMap)
			{
				if ((mFilePath.Length > origDir.Length) && (dir.StartsWith(origDir)) && (mFilePath[origDir.Length] == Path.DirectorySeparatorChar))
				{
					let localPath = scope String();
					localPath.Append(localDir);
					localPath.Append(mFilePath, origDir.Length);
					if (File.Exists(localPath))
						CheckFile(localPath);
				}
			}

			if (mFoundPath == null)
			{
				for (let searchPath in gApp.mSettings.mDebuggerSettings.mAutoFindPaths)
				{
					if (!searchPath.Contains('@'))
						SearchPath(searchPath);
				}
			}

			mDoneEvent.Set(true);
		}
	}

	class QueuedAutoComplete
	{
		public char32 mKeyChar;
		public SourceEditWidgetContent.AutoCompleteOptions mOptions;
	}

	struct LinePointerDrawData
	{
		public Image mImage;
		public int32 mLine;
		public int32 mUpdateCnt;
		public int32 mDebuggerContinueIdx;
	}

	class CollapseRegionView
	{
		public const uint32 cStartFlag = 0x8000'0000;
		public const uint32 cMidFlag = 0x4000'0000;
		public const uint32 cEndFlag = 0x2000'0000;
		public const uint32 cIdMask = 0x0FFF'FFFF;

		public List<uint32> mCollapseIndices = new .() ~ delete _;
		public int32 mLineStart;
		public int32 mCollapseRevision;
		public int32 mTextVersionId;

		public uint32 GetCollapseValue(int param)
		{
			if (param < mLineStart)
				return 0;
			if (param - mLineStart < mCollapseIndices.Count)
				return mCollapseIndices[param - mLineStart];
			return 0;
		}
	}

	class QueuedCollapseData
	{
		public String mData = new .() ~ delete _;
		public String mBuildData ~ delete _;
		public int32 mTextVersion;
		public IdSpan mCharIdSpan ~ _.Dispose();
		public ResolveType mResolveType;
	}

	class QueuedEmitShowData
	{
		public int32 mPrevCollapseParseRevision;
		public int32 mTypeId = -1;
		public String mTypeName ~ delete _;
		public int32 mLine;
		public int32 mColumn;
	}

    public class SourceViewPanel : TextPanel
    {
        enum SourceDisplayId
        {
            Cleared,
            AutoComplete,
            SpellCheck,
            FullClassify,
			SkipResult
        }

		struct ParsedState
		{
			public IdSpan mIdSpan;
			public int32 mTextVersion = -1;

			public void Dispose() mut
			{
				mIdSpan.Dispose();
			}
		}

		public bool mAsyncAutocomplete = true;

        public SourceEditWidget mEditWidget;        
        public ProjectSource mProjectSource;
		public FileEditData mEditData;
		public FileRecovery.Entry mFileRecoveryEntry ~ delete _;
        public List<TrackedTextElementView> mTrackedTextElementViewList ~ DeleteContainerAndItems!(_);
        public List<BfPassInstance.BfError> mErrorList = new List<BfPassInstance.BfError>() ~ DeleteContainerAndItems!(_);
		public List<ResolveParams> mDeferredResolveResults = new .() ~ DeleteContainerAndItems!(_);
        public bool mTrackedTextElementViewListDirty;
        public String mFilePath ~ delete _;
		public int32 mEmitRevision = -1;
		public SourceEmbedKind mEmbedKind;
		public SourceViewPanel mEmbedParent;
		public bool mIsBinary;
		public String mAliasFilePath ~ delete _;
#if IDE_C_SUPPORT
        public ProjectSource mClangSource; // For headers, an implementing .cpp file
#endif
        public int32 mLastMRUVersion;
        public int32 mLastTextVersionId;
        public int32 mAutocompleteTextVersionId;
        public int32 mClassifiedTextVersionId;
		public int32 mLastRecoveryTextVersionId;
		public bool mLoadFailed;
		String mOldVerLoadCmd ~ delete _;
		HTTPRequest mOldVerHTTPRequest ~ delete _;
		IDEApp.ExecutionInstance mOldVerLoadExecutionInstance ~ _?.Release();
		SourceFindTask mSourceFindTask ~ delete _;
		HoverResolveTask mHoverResolveTask ~ delete _;
		bool mWantsFastClassify;
        bool mWantsFullClassify; // This triggers a classify
        bool mWantsFullRefresh; // If mWantsFullClassify is set, mWantsFullRefresh makes the whole thing refresh
		bool mWantsCollapseRefresh;
		ParsedState mParsedState ~ _.Dispose(); // The current data the resolver is using from this file
		bool mRefireMouseOverAfterRefresh;
        bool mWantsBackgroundAutocomplete;
		bool mSkipFastClassify;
		QueuedAutoComplete mQueuedAutoComplete ~ delete _;
        public bool mWantsSpellCheck;
        int32 mTicksSinceTextChanged;
        int32 mErrorLookupTextIdx = -1;
		LinePointerDrawData mLinePointerDrawData;
		bool mIsDraggingLinePointer;
		Point? mMousePos;
	#if IDE_C_SUPPORT
        public String mClangHoverErrorData ~ delete mClangHoverErrorData;
#endif
		CollapseRegionView mCollapseRegionView = new .() ~ delete _;
		QueuedCollapseData mQueuedCollapseData ~ delete _;
		QueuedEmitShowData mQueuedEmitShowData ~ delete _;
		List<String> mExplicitEmitTypes = new .() ~ DeleteContainerAndItems!(_);

        public EditWidgetContent.CharData[] mProcessSpellCheckCharData ~ delete _;
        public IdSpan mProcessSpellCheckCharIdSpan ~ _.Dispose();
        //public int mBackgroundCursorIdx;
        
		String mQueuedLocation ~ delete _;
        bool mWantsClassifyAutocomplete;
		bool mWantsCurrentLocation;
        public bool mIsPerformingBackgroundClassify;
        public bool mClassifyPaused = false;        
        public bool mUseDebugKeyboard;
        //public int32 mLastFileTextVersion;
        public bool mHasChangedSinceLastCompile;
        public bool mIsSourceCode;
        public bool mIsBeefSource;
		public bool mIsClang;
#if IDE_C_SUPPORT
        public bool mClangSourceChanged;
        //public ClangCompiler mClangHelper;
        bool mDidClangSource;
#endif
        public bool mJustShown;
        public double mDesiredVertPos;
		public float mLockFlashPct;
        ResolveType mBackgroundResolveType;
        SourceViewPanel mOldVersionPanel;
		SourceViewPanel mCurrentVersionPanel;
		EditWidgetContent.LineAndColumn? mRequestedLineAndColumn;
		public SourceHash mWantHash;

		SourceViewPanel mSplitTopPanel; // This is only set if we are controlling a top panel
		PanelSplitter mSplitter;
		SourceViewPanel mSplitBottomPanel; // The primary owning panel is the bottom panel, this only set if we are the bottom panel
		
        int mHotFileIdx = -1;
        bool mIsOldCompiledVersion;
        static bool sPreviousVersionWarningShown;
        PanelHeader mPanelHeader;
        NavigationBar mNavigationBar;
        public SymbolReferenceHelper mRenameSymbolDialog;
        public int32 mBackgroundDelay = 0;
		public Monitor mMonitor = new Monitor() ~ delete _;
		bool mDidSpellCheck;
		int32 mSpellCheckJobCount;
		int32 mResolveJobCount;
		bool mWantsParserCleanup;
		bool mInPostRemoveUpdatePanels;
		bool mDeleteAfterPostRemoveUpdate;

		// For multi-view files...
		PersistentTextPosition mTrackCursorPos;
		PersistentTextPosition mTrackSelStart;
		PersistentTextPosition mTrackSelEnds;

		public override float TabWidthOffset
		{
			get
			{
				return 30;
			}
		}

		public bool NeedsPostRemoveUpdate
		{
			get
			{
				return !mDeferredResolveResults.IsEmpty || (mResolveJobCount > 0) || (mSpellCheckJobCount > 0);
			}
		}

        public override SourceEditWidget EditWidget
        {
            get
            {
                return mEditWidget;
            }
        }

        public CompilerBase ResolveCompiler
        {
            get
            {
#if IDE_C_SUPPORT
                if (mIsBeefSource)
                    return IDEApp.sApp.mBfResolveCompiler;
                return IDEApp.sApp.mResolveClang;
#else
				return IDEApp.sApp.mBfResolveCompiler;
#endif
            }
        }

        public BfCompiler BfResolveCompiler
        {
            get
            {
#if IDE_C_SUPPORT
                if (mIsBeefSource)
                    return IDEApp.sApp.mBfResolveCompiler;
                return null;
#else
				return IDEApp.sApp.mBfResolveCompiler;
#endif
            }
        }

#if IDE_C_SUPPORT
        public ClangCompiler ClangResolveCompiler
        {
            get
            {
                if (mIsClang)
                    return IDEApp.sApp.mResolveClang;
                return null;
            }
        }
#endif

        public BfSystem BfResolveSystem
        {
            get
            {
#if IDE_C_SUPPORT
                if (!mIsClang)
					return IDEApp.sApp.mBfResolveSystem;
				return null;
#else
				return IDEApp.sApp.mBfResolveSystem;
#endif
            }
        }

		public NavigationBar PrimaryNavigationBar
		{
			get
			{
				if (mSplitBottomPanel != null)
					return mSplitBottomPanel.mNavigationBar;
				return mNavigationBar;
			}
		}

		public bool IsReadOnly
		{
			get
			{
				if (gApp.mSettings.mEditorSettings.mLockEditing)
					return true;
				if ((mProjectSource != null) && (mProjectSource.mProject.mLocked))
					return true;

				if (gApp.mDebugger.mIsRunning)
				{
					switch (gApp.mSettings.mEditorSettings.mLockEditingWhenDebugging)
					{
					case .Always:
						return true;
					case .Never:
						break;
					case .WhenNotHotSwappable:
						if ((!mIsBeefSource) || (!gApp.mDebugger.mIsRunningCompiled))
						{
							return true;
						}
					}
				}

				return false;
			}
		}

		public ProjectSource FilteredProjectSource
		{
			get
			{
				if (mProjectSource == null)
					return null;
				if (mProjectSource.IsIgnored())
					return null;
				if (!gApp.IsProjectSourceEnabled(mProjectSource))
					return null;

				return mProjectSource;
			}
		}

		public bool IsActiveBeefSource => mIsBeefSource && (FilteredProjectSource != null);

        public this(SourceEmbedKind embedKind = .None)
        {
			mEmbedKind = embedKind;
            DebugManager debugManager = IDEApp.sApp.mDebugger;
            debugManager.mBreakpointsChangedDelegate.Add(new => BreakpointsChanged);

			if (mEmbedKind == .None)
			{
	            mNavigationBar = new NavigationBar(this);            
	            AddWidget(mNavigationBar); 
			}
			mAlwaysUpdateF = true;
        }
		public ~this()
		{
			if (mInPostRemoveUpdatePanels)
			{
				//Debug.WriteLine("Removing sourceViewPanel from mPostRemoveUpdatePanel {0} in ~this ", this);
				gApp.mPostRemoveUpdatePanels.Remove(this);
			}

            if (!mDisposed)
				Dispose();
			
			/*if (mOldVersionPanel != null)
			{
				Widget.RemoveAndDelete(mOldVersionPanel);
				mOldVersionPanel = null;
			}*/
		}

		SourceEditWidgetContent Content
		{
			get
			{
				return (SourceEditWidgetContent)mEditWidget.Content;
			}
		}

		void DoAutoComplete(char32 keyChar, SourceEditWidgetContent.AutoCompleteOptions options)
		{
			var editWidgetContent = (SourceEditWidgetContent)mEditWidget.Content;

			/*bool isValid = false;

			
			int cursorPos = editWidgetContent.mCursorTextPos;
			if (cursorPos > 0)
			{
				char8 c = editWidgetContent.mData.mText[cursorPos].mChar;
				if ((c.IsLetterOrDigit) || (c == '')
			}

			if (!isValid)
			{
				Debug.WriteLine("DoAutoComplete ignored");
				return;
			}*/

			if (ResolveCompiler == null)
				return;

			if (ResolveCompiler.mThreadWorkerHi.mThreadRunning)
			{
				ResolveCompiler.RequestFastFinish();

				//Debug.WriteLine("Deferred DoAutoComplete");
				DeleteAndNullify!(mQueuedAutoComplete);
				mQueuedAutoComplete = new .();
				mQueuedAutoComplete.mKeyChar = keyChar;
				mQueuedAutoComplete.mOptions = options;
				return;
			}

			//Debug.WriteLine("DoAutoComplete");

			if (editWidgetContent.mAutoComplete != null)
			{
				editWidgetContent.mAutoComplete.mInvokeOnly = options.HasFlag(.OnlyShowInvoke);
				//Debug.WriteLine("Setting invokeonly {0} {1}", editWidgetContent.mAutoComplete, editWidgetContent.mAutoComplete.mInvokeOnly);
			}

		    //Classify(options.HasFlag(.HighPriority) ? ResolveType.Autocomplete_HighPri : ResolveType.Autocomplete);

			ResolveParams resolveParams = new ResolveParams();
			if (gApp.mDbgTimeAutocomplete)
				resolveParams.mStopwatch = new .()..Start();
			if (gApp.mDbgPerfAutocomplete)
				resolveParams.mProfileInstance = Profiler.StartSampling("Autocomplete").GetValueOrDefault();
			resolveParams.mIsUserRequested = options.HasFlag(.UserRequested);
			resolveParams.mDoFuzzyAutoComplete = gApp.mSettings.mEditorSettings.mFuzzyAutoComplete;
			Classify(.Autocomplete, resolveParams);
			if (!resolveParams.mInDeferredList)
				delete resolveParams;

		    if (mIsClang)
		    {
		        // We classify afterwards so we can attempt to detect any bound functions
		        mWantsFullClassify = true;
		        mWantsClassifyAutocomplete = options.HasFlag(.UserRequested);
		    }
		}

		public void CancelResolve(ResolveType resolveType)
		{
			for (var resolveResults in mDeferredResolveResults)
			{
				if (resolveResults.mResolveType == resolveType)
				{
					resolveResults.mCancelled = true;
				}
			}
		}

		void CancelAutocomplete()
		{
			CancelResolve(.Autocomplete);
			DeleteAndNullify!(mQueuedAutoComplete);
		}

		public void CloseAutocomplete()
		{
			var editWidgetContent = (SourceEditWidgetContent)mEditWidget.Content;
			if (editWidgetContent.mAutoComplete != null)
				editWidgetContent.mAutoComplete.Close();
		}

        void SetupEditWidget()
        {
			if (mEditWidget.mParent == null)
            	AddWidget(mEditWidget);

            mEditWidget.mPanel = this;
            var editWidgetContent = (SourceEditWidgetContent)mEditWidget.Content;
			delete editWidgetContent.mOnGenerateAutocomplete;
            editWidgetContent.mOnGenerateAutocomplete = new => DoAutoComplete;
            editWidgetContent.mSourceViewPanel = this;
			
			delete editWidgetContent.mOnEscape;
            editWidgetContent.mOnEscape = new () => EscapeHandler();
			delete editWidgetContent.mOnFinishAsyncAutocomplete;
            editWidgetContent.mOnFinishAsyncAutocomplete = new () =>
	            {
					scope AutoBeefPerf("editWidgetContent.mOnFinishAsyncAutocomplete");

	                ProcessDeferredResolveResults(-1, true);
					if (mQueuedAutoComplete != null)
					{
						DoAutoComplete(mQueuedAutoComplete.mKeyChar, mQueuedAutoComplete.mOptions);
						DeleteAndNullify!(mQueuedAutoComplete);
						ProcessDeferredResolveResults(-1, true);
					}
	            };
			delete editWidgetContent.mOnCancelAsyncAutocomplete;
            editWidgetContent.mOnCancelAsyncAutocomplete = new () =>
	            {
					CancelAutocomplete();
	            };
        }

        AutoComplete GetAutoComplete()
        {
            return ((SourceEditWidgetContent)mEditWidget.Content).mAutoComplete;
        }

        public override void Serialize(StructuredData data)
        {
            base.Serialize(data);
			if (mFilePath == null)
				return;

            data.Add("Type", "SourceViewPanel");
			String relPath = scope String();
			gApp.mWorkspace.GetWorkspaceRelativePath(mFilePath, relPath);
            data.Add("FilePath", relPath);
			if (mAliasFilePath != null)
			{
				String relAliasPath = scope .();
				gApp.mWorkspace.GetWorkspaceRelativePath(mAliasFilePath, relAliasPath);
				data.Add("AliasFilePath", relAliasPath);
			}
            data.ConditionalAdd("CursorPos", mEditWidget.Content.CursorTextPos, 0);
            data.ConditionalAdd("VertPos", mEditWidget.mVertScrollbar.mContentPos, 0);
            if (mProjectSource != null)
                data.Add("ProjectName", mProjectSource.mProject.mProjectName);
        }

        public override bool Deserialize(StructuredData data)
        {
            base.Deserialize(data);

            String relFilePath = scope String();
            data.GetString("FilePath", relFilePath);
			String absFilePath = scope String();
			gApp.mWorkspace.GetWorkspaceAbsPath(relFilePath, absFilePath);

            String projectName = scope String();
            data.GetString("ProjectName", projectName);

			var relAliasFilePath = scope String();
			data.GetString("AliasFilePath", relAliasFilePath);
			if (!relAliasFilePath.IsEmpty)
			{
				mAliasFilePath = new String();
				gApp.mWorkspace.GetWorkspaceAbsPath(relAliasFilePath, mAliasFilePath);
			}
            
            bool foundProjectSource = false;
            if (projectName != null)
            {
                var project = IDEApp.sApp.FindProjectByName(projectName);
                if (project != null)
                {
                    String relPath = scope String();
                    project.GetProjectRelPath(absFilePath, relPath);
                    var projectItem = IDEApp.sApp.FindProjectItem(project.mRootFolder, relPath);
                    if (projectItem != null)
                    {
                        if (!Show(projectItem, true))
							return false;
                        foundProjectSource = true;
                    }
                }
            }

            if (!foundProjectSource)
            {
                if (!Show(absFilePath, true))
                    return false;
            }
            int32 cursorPos = data.GetInt("CursorPos");
            mEditWidget.Content.mCursorTextPos = Math.Min(cursorPos, mEditWidget.mEditWidgetContent.mData.mTextLength);
            mDesiredVertPos = data.GetFloat("VertPos");

            return true;
        }

        public void QueueFullRefresh(bool configMayHaveChanged)
        {
#if IDE_C_SUPPORT
            if ((mIsClang) && (configMayHaveChanged))
            {
                // Force file to be recreated with potentially new Clang settings
                using (mMonitor.Enter())
                {
                    var clangCompiler = ClangResolveCompiler;
                    clangCompiler.QueueFileRemoved(mFilePath);
                    if (mClangSource != null)
                        mClangSource = null;                    
                    mDidClangSource = false;
                }
            }
#endif

			if ((configMayHaveChanged) && (mSplitTopPanel != null))
				mSplitTopPanel.QueueFullRefresh(configMayHaveChanged);

            mWantsFullClassify = true;
            mWantsFullRefresh = true;

            // We do this every time we autocomplete, so we don't want to set mDidClangSource to false here.  Why did we have that?
            //if (mIsClang)
                //mDidClangSource = false;
        }

		public void QueueCollapseRefresh()
		{
			mWantsCollapseRefresh = true;
		}

        public override bool EscapeHandler()
        {
            if (IDEApp.sApp.mSymbolReferenceHelper != null)
            {
                IDEApp.sApp.mSymbolReferenceHelper.Cancel();
				// If we press F3 and find a symbol, we want esc to close both the symbol reference and the quickfind
				if (mQuickFind == null)
                	return true;
            }

            if (base.EscapeHandler())
                return true;

			if (HasFocus(true))
			{
				if ((mSplitTopPanel != null) && (mSplitTopPanel.EscapeHandler()))
					return true;
				if ((mSplitBottomPanel != null) && (mSplitBottomPanel.EscapeHandler()))
					return true;
			}

            // Remove F4-selection from output panels
            IDEApp.sApp.mOutputPanel.EscapeHandler();
            IDEApp.sApp.mFindResultsPanel.EscapeHandler();

            return false;
        }
		
		public bool IsControllingEditData()
		{	
			// We are controlling if we have focus or, if none have focus, if we're the most recently added
			var users = Content.mData.mUsers;
			for (var user in users)
			{
				if (user.mEditWidget.mHasFocus)
					return mEditWidget == user.mEditWidget;
			}
			return mEditWidget == users[users.Count - 1].mEditWidget;
		}

        public bool HasUnsavedChanges()
        {
            //return mLastFileTextVersion != mEditWidget.Content.mData.mCurTextVersionId;
			if (mFilePath == null)
				return true;
			if (mEditData == null)
				return false;
			if (mEditData.mFileDeleted)
				return true;
			return mEditData.mLastFileTextVersion != mEditWidget.Content.mData.mCurTextVersionId;
        }

		public bool IsLastViewOfData()
		{
			int32 expectCount = 1;
			if (mSplitTopPanel != null)
				expectCount = 2;
			return Content.Data.mUsers.Count == expectCount;
		}
                
        public bool HasTextChangedSinceCompile(int defLineStart, int defLineEnd, int compileInstanceIdx)
        {
			/*if ((mProjectSource != null) && (!mProjectSource.mHasChangedSinceLastSuccessfulCompile))
				return false;*/

            if ((compileInstanceIdx == -1) && (!mHasChangedSinceLastCompile))
                return false;

			let projectSource = FilteredProjectSource;
            if (projectSource == null)
                return false;
            
            int32 char8IdStart;
            int32 char8IdEnd;
            IdSpan char8IdData = IDEApp.sApp.mWorkspace.GetProjectSourceSelectionCharIds(projectSource, compileInstanceIdx, defLineStart, defLineEnd, out char8IdStart, out char8IdEnd);
            if (char8IdData.IsEmpty)
                return false;

			bool doDebug = false;
			if (doDebug)
			{
				char8IdData.Dump();
				mEditWidget.mEditWidgetContent.mData.mTextIdData.Dump();
			}


            return !char8IdData.IsRangeEqual(mEditWidget.mEditWidgetContent.mData.mTextIdData.GetPrepared(), char8IdStart, char8IdEnd);
        }

		public void CheckSavedContents()
		{
			if (((mEditData != null)) && (mEditData.mLastFileTextVersion == mEditWidget.Content.mData.mCurTextVersionId) && (mEditData.mRecoveryHash.IsZero) &&
				(gApp.mSettings.mEditorSettings.mEnableFileRecovery != .No) 
#if !CLI				
				&& (!gApp.mFileRecovery.mDisabled)
#endif				
				)
			{
				String text = scope .();
				mEditWidget.GetText(text);
				mEditData.mRecoveryHash = MD5.Hash(.((uint8*)text.Ptr, text.Length));
			}
		}

        public void FileSaved()
        {
			ClearLoadFailed();
#if IDE_C_SUPPORT
            mClangSourceChanged = false;
#endif
            //mLastFileTextVersion = mEditWidget.Content.mData.mCurTextVersionId;
            if (mEditData != null)
			{
                mEditData.mLastFileTextVersion = mEditWidget.Content.mData.mCurTextVersionId;
				mEditData.mHadRefusedFileChange = false;
				mEditData.mFileDeleted = false;
			
				var editText = scope String();
				mEditWidget.GetText(editText);
				using (gApp.mMonitor.Enter())
				{
					mEditData.SetSavedData(editText, mEditWidget.mEditWidgetContent.mData.mTextIdData.GetPrepared());
				}
            }

			gApp.FileChanged(mFilePath);
			DeleteAndNullify!(mFileRecoveryEntry);
			mLastRecoveryTextVersionId = mEditWidget.Content.mData.mCurTextVersionId;
			mEditData.mRecoveryHash = default;
        }

        void ClassifyThreadDone()
        {
            /*if (mProcessingPassInstance != null)
            {
                //Debug.WriteLine("Pass Instance {0} Done. Dispose? {1}", mProcessingPassInstance.mId, mWidgetWindow == null);

                // If we've closed the window by the time our pass instance is completed then just drop the results
                if (mWidgetWindow == null)
                {
                    delete mProcessingPassInstance;
                    mProcessingPassInstance = null;
                }
            }*/
            mIsPerformingBackgroundClassify = false;
			mResolveJobCount--;
        }

		void BackgroundResolve(ThreadStart threadStart)
		{
			
		}

        public bool Classify(ResolveType resolveType, ResolveParams resolveParams = null)
        {
            // Don't allow other classify calls interrupt a symbol rename
            if ((IDEApp.sApp.mSymbolReferenceHelper != null) && (IDEApp.sApp.mSymbolReferenceHelper.HasStarted) && (IDEApp.sApp.mSymbolReferenceHelper.mKind == SymbolReferenceHelper.Kind.Rename))
                return false;

			if (mEmbedKind != .None)
			{
				if ((mEmbedParent != null) &&
					((resolveType == .GoToDefinition) || (resolveType == .GetCurrentLocation)))
				{
					mEmbedParent.Classify(resolveType, resolveParams);
				}

				return true;
			}

			//Debug.WriteLine("Classify({0})", resolveType);

            if (!mIsSourceCode)
                return true;

			if (gApp.mDeterministic)
			{
				//return false;

				if (resolveType == .GetCurrentLocation)
					return false;
				if (resolveType == .GetSymbolInfo)
					return true;

				while ((BfResolveCompiler.mResolveAllWait != 0) ||
					(BfResolveCompiler.mThreadYieldCount != 0))
				{
					BfResolveCompiler.Update();
				}

				BfResolveCompiler.WaitForBackground();
			}

			if (resolveParams != null)
				resolveParams.mResolveType = resolveType;

			/*if (mWidgetWindow.IsKeyDown(.Control))
			{
				NOP!();
			}*/
			//Debug.WriteLine("Classify {0} {1}", this, resolveType);

			scope AutoBeefPerf("SourceViewPanel.Classify");

            /*if ((mIsClang) && (!mDidClangSource))
            {
                mDidClangSource = true;
                var clangCompiler = ClangResolveCompiler;
                if (mProjectSource != null)
                {
                    clangCompiler.QueueProjectSource(mProjectSource);
                    // Return because now we need to wait for this to finish
                    return false;
                }
            }*/

			var useResolveType = resolveType;
            var compiler = ResolveCompiler;
            var bfCompiler = BfResolveCompiler;
            BfSystem bfSystem = null;
            if (bfCompiler != null)
                bfSystem = IDEApp.sApp.mBfResolveSystem;
            /*if ((!mIsBeefSource) || (!bfSystem.HasParser(mFilePath)))
            {
                //DoFastClassify();
                //return;
            }*/

			if (compiler.IsPerformingBackgroundOperation())
			{
				compiler.RequestFastFinish();
			}

			if (bfSystem == null)
				return false;

            if (bfSystem != null)
                bfSystem.PerfZoneStart("Classify");

			let projectSource = FilteredProjectSource;

            //Debug.WriteLine("Classify {0}", doAutocomplete);
            //bfSystem.PerfZoneStart("CancelBackground");                            

            bool hasValidProjectSource = false;
            if (projectSource != null)
            {
                if (mIsBeefSource)
                {
                    var bfProject = bfSystem.GetBfProject(projectSource.mProject);
                    if (!bfProject.mDisabled)
                        hasValidProjectSource = true;
                }
                else
                    hasValidProjectSource = true;
            }

            mClassifyPaused = false;

            if (mIsClang)
            {
				if (resolveType == .Autocomplete)
					return true; // Don't do anything

                // Clang always just does a 'fast classify'
                DoFastClassify();
            }

            if (useResolveType == ResolveType.Autocomplete)
                mAutocompleteTextVersionId = mEditWidget.Content.mData.mCurTextVersionId;

            bool wasHighPri = false;
            if (useResolveType == ResolveType.Autocomplete_HighPri)
            {
                wasHighPri = true;
                if (mIsClang) 
                {
                    compiler.CancelBackground();
					//delete mQueuedAutocompleteInfo;
                    //mQueuedAutocompleteInfo = null;
                    mWantsBackgroundAutocomplete = false;
                }
                useResolveType = ResolveType.Autocomplete;                
            }            
           
            bool doBackground = (useResolveType == .Classify) || (useResolveType == .ClassifyFullRefresh);
			if (mAsyncAutocomplete)
			{
				if ((useResolveType == .Autocomplete) || (useResolveType == .GetCurrentLocation) || (useResolveType == .GetSymbolInfo) ||
					(useResolveType == .GetResultString) || (useResolveType == .GoToDefinition))
					doBackground = true;
			}

			// If there's a long-running const eval then cancel that first
			if (!mDeferredResolveResults.IsEmpty)
			{
				for (var result in mDeferredResolveResults)
				{
					if (result.mResolveType == .ClassifyFullRefresh)
					{
						bfCompiler.RequestCancelBackground();
					}
				}
			}

            if (mIsClang)
            {
#if !IDE_C_SUPPORT
				return true;
#else
				if (useResolveType == ResolveType.GetCurrentLocation)
					doBackground = (useResolveType == ResolveType.GetCurrentLocation);

                if (useResolveType == ResolveType.Autocomplete)
                {
                    mWantsClassifyAutocomplete = GetAutoComplete() != null;
                    var autocomplete = GetAutoComplete();
                    if (autocomplete != null)
                        autocomplete.UpdateAsyncInfo();

                    if ((compiler.IsPerformingBackgroundOperation()) || (mQueuedAutocompleteInfo != null))
                    {
                        if ((mBackgroundResolveType == ResolveType.Autocomplete) && (!mIgnorePendingAsyncAutocomplete))
                        {
                            // We already have a relevant pending autocomplete
                            return true;
                        }

                        Debug.Assert(!wasHighPri);
                        mWantsBackgroundAutocomplete = true;
                        return true;
                    }

                    mIgnorePendingAsyncAutocomplete = false;
                    doBackground = true;
                }
                else if (useResolveType == ResolveType.GetNavigationData)
				{
#if IDE_C_SUPPORT
                    DoClangClassify(useResolveType, resolveParams);
					doBackground = false;
#else
					return false;
#endif
				}
#endif
            }

			let ewc = (SourceEditWidgetContent)mEditWidget.mEditWidgetContent;

			void FindEmbeds(ResolveParams resolveParams)
			{
				if (gApp.mSettings.mEditorSettings.mEmitCompiler != .Resolve)
					return;

				HashSet<FileEditData> foundEditData = scope .();
				Dictionary<String, String> remappedTypeNames = scope .();

				for (var embed in ewc.mEmbeds.Values)
				{
					if (var emitEmbed = embed as SourceEditWidgetContent.EmitEmbed)
					{
						if (emitEmbed.mView != null)
						{
							var embedSourceViewPanel = emitEmbed.mView.mSourceViewPanel;
							bool embedHasFocus = embedSourceViewPanel.mEditWidget.mHasFocus;

							if (!embedHasFocus)
							{
								if ((useResolveType != .Classify) && (useResolveType != .ClassifyFullRefresh))
									continue;
							}

							if (foundEditData.Add(embedSourceViewPanel.mEditData))
							{
								ResolveParams.Embed embedSource = new .();

								String useTypeName = emitEmbed.mTypeName;
								if (!mExplicitEmitTypes.IsEmpty)
								{
									if (remappedTypeNames.TryAdd(useTypeName, var keyPtr, var valuePtr))
									{
										*valuePtr = useTypeName;
										for (var explicitTypeName in mExplicitEmitTypes)
										{
											if (IDEUtils.GenericEquals(useTypeName, explicitTypeName))
											{
												*valuePtr = explicitTypeName;
												break;
											}
										}
									}
									useTypeName = *valuePtr;
								}

								embedSource.mTypeName = new .(useTypeName);
								if (embedHasFocus)
									embedSource.mCursorIdx = (.)embedSourceViewPanel.mEditWidget.mEditWidgetContent.CursorTextPos;
								else
									embedSource.mCursorIdx = -1;
								resolveParams.mEmitEmbeds.Add(embedSource);

								//embedSource.mParser = bfSystem.FindParser(embedSourceViewPanel.mProjectSource);
							}
						}
					}
				}
			}

            if (doBackground)
            {
				ProcessDeferredResolveResults(0);

				var resolveParams;
				if (resolveParams == null)
				{
					resolveParams = new ResolveParams();
				}

				FindEmbeds(resolveParams);

				resolveParams.mResolveType = resolveType;
				resolveParams.mWaitEvent = new WaitEvent();
				resolveParams.mInDeferredList = true;
				mDeferredResolveResults.Add(resolveParams);

				var autoComplete = GetAutoComplete();
				if ((autoComplete != null) && (autoComplete.mIsDocumentationPass))
				{
					Debug.Assert(ewc.mAutoComplete != null);
					let selectedEntry = ewc.mAutoComplete.mAutoCompleteListWidget.mEntryList[ewc.mAutoComplete.mAutoCompleteListWidget.mSelectIdx];
					resolveParams.mDocumentationName = new String(selectedEntry.mEntryDisplay);
				}
				resolveParams.mTextVersion = Content.mData.mCurTextVersionId;

				compiler.CheckThreadDone(); // Process any pending thread done callbacks

				bool isHi = (resolveType != .ClassifyFullRefresh) && (resolveType != .Classify);
				if (isHi)
				{
					Debug.Assert(!bfCompiler.mThreadWorkerHi.mThreadRunning);
				}
				else
					Debug.Assert(!bfCompiler.mThreadWorker.mThreadRunning);

                if (bfSystem != null)
                    bfSystem.PerfZoneStart("DoBackground");
				//ProcessResolveData();

				bool hasFocus = mEditWidget.mHasFocus;

				//Debug.Assert(mProcessResolveCharData == null);
                DuplicateEditState(out resolveParams.mCharData, out resolveParams.mCharIdSpan);
				//Debug.WriteLine("Edit State: {0}", mProcessResolveCharData);

				if (hasFocus)
				{
	                if ((useResolveType == .Autocomplete) || (useResolveType == .GetSymbolInfo) || (mIsClang))
					{
						resolveParams.mOverrideCursorPos = (.)mEditWidget.Content.CursorTextPos;
						/*if (useResolveType == .Autocomplete)
							resolveParams.mOverrideCursorPos--;*/
					}
				}
                    
                //Debug.Assert(mCurParser == null);
                
                if ((mIsBeefSource) && (hasValidProjectSource) && (!isHi))
                    resolveParams.mParser = bfSystem.FindParser(projectSource);
                //if (mCurParser != null)
                {
					if (gApp.mWorkspace.mProjectLoadState != .Loaded)
					{
						resolveParams.mCancelled = true;
						resolveParams.mWaitEvent.Set(true);
						return true;
					}

					if (!isHi)
						Debug.Assert(!mIsPerformingBackgroundClassify);

                    mBackgroundResolveType = useResolveType;
                    mIsPerformingBackgroundClassify = true;
					mResolveJobCount++;
                    if (useResolveType == .Autocomplete)
                        compiler.DoBackgroundHi(new () => { DoClassify(.Autocomplete, resolveParams, true); }, new => ClassifyThreadDone);
						//BackgroundResolve(new () => { DoClassify(.Autocomplete, resolveParams); });
                    else if (useResolveType == .ClassifyFullRefresh)
					{
						if ((mProjectSource?.mLoadFailed == true) && (!mLoadFailed))
						{
							mProjectSource.mLoadFailed = false;
						}

						// To avoid "flashing" on proper colorization vs FastClassify, we wait a bit for the proper classifying to finish
						//  on initial show
						int maxWait = (mUpdateCnt <= 1) ? 50 : 0;
                        compiler.DoBackground(new () => { DoClassify(.ClassifyFullRefresh, resolveParams, false); },
							new () =>
							{
								ClassifyThreadDone();
							}, maxWait);
					}
                    else if (useResolveType == .GetCurrentLocation)
						compiler.DoBackgroundHi(new () => { DoClassify(.GetCurrentLocation, resolveParams, true); }, new => ClassifyThreadDone);
					else if (useResolveType == .GetSymbolInfo)
						compiler.DoBackgroundHi(new () => { DoClassify(.GetSymbolInfo, resolveParams, true); }, new => ClassifyThreadDone);
					else 
                        compiler.DoBackgroundHi(new () => { DoFullClassify(resolveParams); }, new => ClassifyThreadDone);
                }
                /*else
                {
                    // Not part of project
                    DoFastClassify();
                }*/

                if (bfSystem != null)
                    bfSystem.PerfZoneEnd();
            }
            else if ((mIsBeefSource) && (hasValidProjectSource))
            {
				var resolveParams;
				if (resolveParams == null)
					resolveParams = scope:: ResolveParams();

				FindEmbeds(resolveParams);

				/*if (useResolveType == ResolveType.Autocomplete)
				{
					Profiler.StartSampling();
					DoClassify(useResolveType, resolveParams);
					Profiler.StopSampling();
				}
				else*/
                	DoClassify(useResolveType, resolveParams, true);
				MarkDirty();
            }            

            if (bfSystem != null)
                bfSystem.PerfZoneEnd();
            return true;
        }

		public void DoParserCleanup()
		{
			var bfSystem = IDEApp.sApp.mBfResolveSystem;
			bfSystem.Lock(0);
			//bfSystem.RemoveDeletedParsers();
			bfSystem.RemoveOldData();
			bfSystem.Unlock();
		}

		public void DoRefreshCollapse(BfParser parser, int32 textVersion, IdSpan charIdSpan)
		{
			var bfCompiler = BfResolveCompiler;
			var bfSystem = BfResolveSystem;

			String explicitEmitTypeNames = scope .();
			for (var explicitType in mExplicitEmitTypes)
			{
				explicitEmitTypeNames.Append(explicitType);
				explicitEmitTypeNames.Append("\n");
			}

			var resolvePassData = parser.CreateResolvePassData(.None);
			defer delete resolvePassData;

			bfSystem.Lock(0);

			var collapseData = bfCompiler.GetCollapseRegions(parser, resolvePassData, explicitEmitTypeNames, .. scope .());

			String buildCollapseData = null;
			if ((gApp.mSettings.mEditorSettings.mEmitCompiler == .Build) && (!gApp.mBfBuildCompiler.IsPerformingBackgroundOperation()))
			{
				gApp.mBfBuildSystem.Lock(0);
				var buildParser = gApp.mBfBuildSystem.GetParser(mProjectSource);
				if (buildParser != null)
				{
					var buildResolvePassData = buildParser.CreateResolvePassData(.None);
					defer delete buildResolvePassData;
					buildCollapseData = gApp.mBfBuildCompiler.GetCollapseRegions(buildParser, buildResolvePassData, explicitEmitTypeNames, .. scope:: .());
				}
				else
				{
					buildCollapseData = "";
				}
				gApp.mBfBuildSystem.Unlock();
			}

			using (mMonitor.Enter())
			{
				DeleteAndNullify!(mQueuedCollapseData);
				mQueuedCollapseData = new .();
				mQueuedCollapseData.mData.Set(collapseData);
				if (buildCollapseData != null)
					mQueuedCollapseData.mBuildData = new String(buildCollapseData);
				mQueuedCollapseData.mTextVersion = textVersion;
				mQueuedCollapseData.mCharIdSpan = charIdSpan.Duplicate();

				//Debug.WriteLine($"DoRefreshCollapse finished TextVersion:{textVersion} IdSpan:{charIdSpan:D}");
			}
			bfSystem.Unlock();
		}

        public void DoFullClassify(ResolveParams resolveParams)
        {
            var bfCompiler = BfResolveCompiler;
            //var bfSystem = IDEApp.sApp.mBfResolveSystem;
            //bfCompiler.StartTiming();
			ResolveType resolveType = ResolveType.Classify;
			if (resolveParams != null)
				resolveType = resolveParams.mResolveType;
            DoClassify(resolveType, resolveParams);
            //bfCompiler.StopTiming();
            if (bfCompiler != null)
                bfCompiler.QueueDeferredResolveAll();
        }

        //[CallingConvention(.Stdcall), CLink]
        //static extern char8* BfDiff_DiffText(char8* text1, char8* text2);

        public void DoFastClassify()
        {
            if ((!mIsSourceCode) || (mSkipFastClassify))
                return;

			//Debug.WriteLine("DoFastClassify");

			scope AutoBeefPerf("SourceViewPanel.DoFastClassify");

			let projectSource = FilteredProjectSource;

            var bfSystem = IDEApp.sApp.mBfResolveSystem;
			if (bfSystem == null)
				return;
            //var compiler = ResolveCompiler;

            var charData = mEditWidget.Content.mData.mText;
            int charLen = Math.Min(charData.Count, mEditWidget.Content.mData.mTextLength);

            char8[] chars = new char8[charLen];
			defer delete chars;
            for (int32 i = 0; i < charLen; i++)
                chars[i] = (char8)charData[i].mChar;

            String text = scope String();
            text.Append(chars, 0, chars.Count);
            
            BfProject bfProject = null;
            if ((projectSource != null) && (mIsBeefSource))
            {
                bfProject = bfSystem.GetBfProject(projectSource.mProject);
            }
            var parser = bfSystem.CreateEmptyParser(bfProject);
			defer delete parser;
            var resolvePassData = parser.CreateResolvePassData();
			defer delete resolvePassData;
            var passInstance = bfSystem.CreatePassInstance("DoFastClassify");
			defer delete passInstance;
            parser.SetSource(text, mFilePath, -1);
            parser.SetIsClassifying();
            parser.Parse(passInstance, !mIsBeefSource);
            if (mIsBeefSource)
			{
				parser.SetEmbedKind(mEmbedKind);
                parser.Reduce(passInstance);
			}
            parser.ClassifySource(charData, !mIsBeefSource);
			mWantsParserCleanup = true;
        }

		public void DoFastClassify(int start, int length)
		{   
		    if (!mIsSourceCode)
		        return;
		    
		    var bfSystem = IDEApp.sApp.mBfResolveSystem;
			if (bfSystem == null)
				return;
		    //var compiler = ResolveCompiler;

		    //var char8Data =  mEditWidget.Content.mData.mText;

			let projectSource = FilteredProjectSource;

			int32 char8Len = mEditWidget.Content.mData.mTextLength;
			var char8Data = new EditWidgetContent.CharData[char8Len];
			defer delete char8Data;
			var curCharData = mEditWidget.Content.mData.mText;

		    char8[] chars = new char8[char8Len];
			defer delete chars;
		    for (int32 i = 0; i < char8Len; i++)
			{
				char8Data[i] = curCharData[i];
				chars[i] = (char8)char8Data[i].mChar;
			}

		    String text = scope String()..Append(StringView(chars, 0, chars.Count));
		    
		    BfProject bfProject = null;
		    if ((projectSource != null) && (mIsBeefSource))
		    {
		        bfProject = bfSystem.GetBfProject(projectSource.mProject);
		    }
		    var parser = bfSystem.CreateEmptyParser(bfProject);
			defer delete parser;
		    var resolvePassData = parser.CreateResolvePassData();
			defer delete resolvePassData;
		    var passInstance = bfSystem.CreatePassInstance("DoFastClassify");
			defer delete passInstance;
		    parser.SetSource(text, mFilePath, -1);
		    parser.SetIsClassifying();
		    parser.Parse(passInstance, !mIsBeefSource);
		    if (mIsBeefSource)
		        parser.Reduce(passInstance);
		    parser.ClassifySource(char8Data, !mIsBeefSource);
			mWantsParserCleanup = true;

			for (int i = start; i < start + length; i++)
			{
				curCharData[i] = char8Data[i];
			}
		}

        void HandleAutocompleteInfo(ResolveType resolveType, String autocompleteInfo, bool clearList, bool changedAfterInfo)
        {
            var editWidgetContent = (SourceEditWidgetContent)mEditWidget.Content;

			if (mWidgetWindow == null)
				return;

            bool wantOpen = (autocompleteInfo.Length > 0);
            if ((editWidgetContent.mAutoComplete != null) && (editWidgetContent.mAutoComplete.mIsAsync) &&
                (editWidgetContent.mAutoComplete.mInvokeWidget != null))
            {
                // Leave the existing invoke widget open
                wantOpen = true;
            }

            if (wantOpen)
            {
                if (editWidgetContent.mAutoComplete == null)
                {
                    editWidgetContent.mAutoComplete = new AutoComplete(mEditWidget);
                    //if (mIsClang)
                        //editWidgetContent.mAutoComplete.mIsAsync = true;
                    editWidgetContent.mAutoComplete.mOnAutoCompleteInserted.Add(new () => { Classify(resolveType); });
                    editWidgetContent.mAutoComplete.mOnClosed.Add(new () =>
                        {
                            //Debug.WriteLine("Autocomplete Closed");
                            if (editWidgetContent.mAutoComplete != null)
                            {
                                editWidgetContent.mAutoComplete = null;
                            }                            
                            // Any pending autocomplete is no longer valid
                            CancelAutocomplete();
                        });
                }
				if (editWidgetContent.mAutoComplete.mIsDocumentationPass)
					editWidgetContent.mAutoComplete.UpdateInfo(autocompleteInfo);
				else
                	editWidgetContent.mAutoComplete.SetInfo(autocompleteInfo, clearList, 0, changedAfterInfo);
            }
            else if ((editWidgetContent.mAutoComplete != null) && (!editWidgetContent.mAutoComplete.mIsDocumentationPass))
                editWidgetContent.mAutoComplete.Close();
        }

#if IDE_C_SUPPORT
        public void DoClangClassify(ResolveType resolveType, ResolveParams resolveParams = null)
        {
            var buildClang = IDEApp.sApp.mDepClang;
            var resolveClang = (ClangCompiler)ResolveCompiler;
            
			bool isBackground = (resolveType == ResolveType.Classify) || (resolveType == ResolveType.ClassifyFullRefresh) || (resolveType == ResolveType.Autocomplete) ||
                (resolveType == ResolveType.Autocomplete_HighPri) || (resolveType == ResolveType.GetCurrentLocation);

			if (!isBackground)
			{
				resolveClang.CancelBackground();
			}

			if (resolveType == ResolveType.GetCurrentLocation)
			{
				NOP!();
			}

			if (isBackground)
				Debug.Assert(mIsPerformingBackgroundClassify);

            var char8Data = (!isBackground) ? mEditWidget.Content.mData.mText : mProcessResolveCharData;
			Debug.Assert(char8Data != null);
            int char8Len = 0;
            if (char8Data != null)
                char8Len = (!isBackground) ? mEditWidget.Content.mData.mTextLength : mProcessResolveCharData.Length;
            mBackgroundCursorIdx = (int32)Math.Min(mBackgroundCursorIdx, char8Len);

            bool didClangSource = false;
        	using (mMonitor.Enter())
            {
                didClangSource = mDidClangSource;
                mDidClangSource = true;
            }

            //bool needsNewClangSource = IDEUtils.IsHeaderFile(mFilePath) && (mClangSource == null);

            //if ((!didClangSource) || (needsNewClangSource))
            if (!didClangSource)
            {
                bool handled = false;

                //if (needsNewClangSource)
                if (IDEUtils.IsHeaderFile(mFilePath))
                {
                    // Wait for buildClang to stop
                    buildClang.CancelBackground();
                    // Process the buildClang commands in this thread (if needed)
                    buildClang.ProcessQueue();

                    ProjectSource projectSource = null;

                    String findStr = scope String("/");
                    Path.GetFileNameWithoutExtension(mFilePath, findStr);
                    findStr.Append(".");

                    String findFilePath = scope String(mFilePath);
                    if (!Utils.IsFileSystemCaseSensitive)
                        findFilePath.ToUpper;

                    //foreach (var checkProjectSource in resolveClang.mSourceMRUList)
                    for (int mruIdx = resolveClang.mSourceMRUList.Count - 1; mruIdx >= 0; mruIdx--)
                    {
                        var checkProjectSource = resolveClang.mSourceMRUList[mruIdx];
                        ClangCompiler.FileEntry fileEntry = null;
                        buildClang.mProjectFileSet.TryGetValue(checkProjectSource, out fileEntry);
                        if (fileEntry != null)
                        {
                            if (fileEntry.mCDepFileRefs.Contains(findFilePath))
                            {
                                projectSource = checkProjectSource;
                                break;
                            }
                        }
                    }

                    // First try to find a file with the same base name, then try to
                    for (int32 pass = 0; pass < 2; pass++)
                    {
                        if (projectSource != null)
                            break;                        

                        for (var projectPair in buildClang.mProjectFileSet)
                        {
                            var checkProjectSource = projectPair.Key;
                            var fileData = projectPair.Value;
                            if ((fileData.mCDepFileRefs != null) &&
                                (((pass == 1) || (checkProjectSource.mPath.IndexOf(findStr, true) != -1))))
                            {
                                if (fileData.mCDepFileRefs.Contains(findFilePath))
                                    projectSource = checkProjectSource;
                            }
                            //projectPair.Value.mCDepFileRefs.Contains();
                        }
                    }

                    String headerPrefix = scope String();
                    if (projectSource != null)
                    {
                        mClangSource = projectSource;
                        IdSpan idSpan;
                        String fileContent = scope String();
                        IDEApp.sApp.FindProjectSourceContent(mClangSource, out idSpan, true, fileContent);
						idSpan.Dispose();

                        String clangArgs = scope String();
                        resolveClang.GetClangArgs(mClangSource, clangArgs);
						String fullImportPath = scope String();
						mClangSource.GetFullImportPath(fullImportPath);
                        int32 includePos = resolveClang.CDepGetIncludePosition(fullImportPath, fileContent, mFilePath, clangArgs);                        
                        if (includePos != -1)                        
                            fileContent.Substring(0, includePos, headerPrefix);
                        resolveClang.AddTranslationUnit(mFilePath, headerPrefix, clangArgs);
                    }
                    else
                    {
                        resolveClang.AddTranslationUnit(mFilePath, "", "");
                    }

                    handled = true;
                }

                if ((!handled) && (!didClangSource))
                {
					Debug.Assert(char8Data != null);
                    if (mProjectSource != null)
                    {
                        resolveClang.AddTranslationUnit(mProjectSource, null, char8Data, char8Len);
                    }
                }
            }

            if (resolveType == ResolveType.GetNavigationData)
            {
                resolveClang.CancelBackground();
                resolveParams.mNavigationData = new String();
                resolveClang.GetNavigationData(mFilePath, resolveParams.mNavigationData);
                return;
            }

			if (resolveType == ResolveType.GetCurrentLocation)
			{
				String result = new String();
				resolveClang.GetCurrentLocation(mFilePath, result, mBackgroundCursorIdx);
				delete mQueuedLocation;
				mQueuedLocation = result;
				return;
			}

            //string fileName;
            //string headerFileName = null;            
            if (resolveType == ResolveType.Autocomplete)
            {                
				Debug.Assert(mQueuedAutocompleteInfo == null);
                mQueuedAutocompleteInfo = new String();
                resolveClang.Autocomplete(mFilePath, char8Data, char8Len, mBackgroundCursorIdx, mQueuedAutocompleteInfo);
                if ((mBackgroundCursorIdx != -1) && (mQueuedAutocompleteInfo == null))
                    mQueuedAutocompleteInfo = "";
                if (mIgnorePendingAsyncAutocomplete)
				{
					delete mQueuedAutocompleteInfo;
                    mQueuedAutocompleteInfo = null;
				}
            }
            else
            {
                bool ignoreErrors = (mProjectSource == null) && (mClangSource == null);
                /*if (IDEUtils.IsHeaderFile(mFilePath))
                    ignoreErrors = mClangSource == null;
                else
                    ignoreErrors = mProjectSource == null;*/                

                String results = scope String();
                resolveClang.Classify(mFilePath, char8Data, char8Len, mBackgroundCursorIdx, mErrorLookupTextIdx, ignoreErrors, results);
                if (results != null)
                {
                    String autocompleteResult = scope String();					
                    for (var resultLine in String.StackSplit!(results, '\n'))
                    {
						var resultLineSplit = scope List<StringView>();
                        resultLine.Split(resultLineSplit, scope char8[] {'\t'}, 2);
                        if (scope String(resultLineSplit[0]) == "diag")
                        {
							delete mClangHoverErrorData;
                            mClangHoverErrorData = new String(resultLineSplit[1]);
                        }
                        else if (resultLine != "")
                        {							
                            autocompleteResult.Append(resultLine, "\n");
                        }
                    }
					if ((mWantsClassifyAutocomplete) && (autocompleteResult.Length > 0))
					{
						Debug.Assert(mQueuedClassifyInfo == null);						
					    mQueuedClassifyInfo = new String();
                        autocompleteResult.MoveTo(mQueuedClassifyInfo);
					}
                }
                
                mErrorLookupTextIdx = -1;                
            }            

            var bfSystem = IDEApp.sApp.mBfResolveSystem;
            bfSystem.RemoveDeletedParsers();

			if (isBackground)
				Debug.Assert(mIsPerformingBackgroundClassify);
        }
#endif

		void HandleResolveResult(ResolveType resolveType, String autocompleteInfo, ResolveParams resolveParams)
		{
			if (resolveType == ResolveType.GetSymbolInfo)
			{
				if (!resolveParams.mCancelled)
			    	gApp.mSymbolReferenceHelper?.SetSymbolInfo(autocompleteInfo);
			}
			else if (resolveType == ResolveType.GoToDefinition)
			{
				if (!resolveParams.mCancelled)
					gApp.mSymbolReferenceHelper?.SetSymbolInfo(autocompleteInfo);
			    /*var autocompleteLines = String.StackSplit!(autocompleteInfo, '\n');
			    for (var autocompleteLine in autocompleteLines)
			    {
			        var lineData = String.StackSplit!(autocompleteLine, '\t');
			        if (scope String(lineData[0]) == "defLoc")
			        {
			            resolveParams.mOutLine = int32.Parse(lineData[2]);
			            resolveParams.mOutLineChar = int32.Parse(lineData[3]);
			            resolveParams.mOutFileName = new String(lineData[1]);
			        }
			    }*/
			}
			else if (resolveType == ResolveType.GetNavigationData)
			{
			    resolveParams.mNavigationData = new String(autocompleteInfo);
			}
			else if (resolveType == ResolveType.GetResultString)
			{
				if ((mHoverResolveTask != null) && (mHoverResolveTask.mCursorPos == resolveParams.mOverrideCursorPos))
				{
					mHoverResolveTask.mResult = new String(autocompleteInfo ?? "");
				}

				resolveParams.mResultString = new String(autocompleteInfo ?? "");
			}
			else if (resolveType == ResolveType.GetCurrentLocation)
			{
				PrimaryNavigationBar.SetLocation(autocompleteInfo ?? "");
			}
			else if ((resolveType == .Autocomplete) || (resolveType == .GetFixits))
			{
				if ((resolveParams != null) && (resolveType == .GetFixits))
				{
					resolveParams.mNavigationData = new String(autocompleteInfo);
				}
				else if ((resolveParams == null) || (!resolveParams.mCancelled))
				{
					bool changedAfterInfo = (resolveParams != null) && (resolveParams.mTextVersion != Content.mData.mCurTextVersionId);

					var autoComplete = GetAutoComplete();
					if ((autoComplete != null) && (resolveParams != null))
						autoComplete.mIsDocumentationPass = resolveParams.mDocumentationName != null;
				    HandleAutocompleteInfo(resolveType, autocompleteInfo, true, changedAfterInfo);
					autoComplete = GetAutoComplete();
					if (autoComplete != null)
					{
						autoComplete.mIsDocumentationPass = false;
						if (resolveParams != null)
							autoComplete.mIsUserRequested = resolveParams.mIsUserRequested;
						if (resolveType == .GetFixits)
							autoComplete.mIsUserRequested = true;
					}
				}
			}
		}

        // fullRefresh means we rebuild types even if the hashes haven't changed - this is required for
        //  a classifier pass on a newly-opened file
        public void DoClassify(ResolveType resolveType, ResolveParams resolveParams = null, bool isInterrupt = false)
        {
			scope AutoBeefPerf("SourceViewPanel.DoClassify");

			if (gApp.mDbgDelayedAutocomplete)
				Thread.Sleep(250);

			if ((resolveType == .Classify) || (resolveType == .ClassifyFullRefresh))
				gApp.mErrorsPanel.SetNeedsResolveAll();

			if ((resolveType.IsClassify) && (!resolveParams.mCharIdSpan.IsEmpty))
			{
				//Debug.WriteLine($"DoClassify {resolveType} TextVersion:{resolveParams.mTextVersion} IdSpan:{resolveParams.mCharIdSpan:D}");

				mParsedState.mIdSpan.DuplicateFrom(ref resolveParams.mCharIdSpan);
				mParsedState.mTextVersion = resolveParams.mTextVersion;
			}

			/*if (resolveType == .Autocomplete)
			{
				Thread.Sleep(250);
			}*/

#if IDE_C_SUPPORT
            if (mIsClang)
            {
                DoClangClassify(resolveType, resolveParams);
                return;
            }
#endif

            var bfSystem = IDEApp.sApp.mBfResolveSystem;
			if (bfSystem == null)
				return;
            var bfCompiler = BfResolveCompiler;
            //var compiler = ResolveCompiler;
            
            bool isBackground = (resolveType == .Classify) || (resolveType == .ClassifyFullRefresh) ||
				(resolveType == .GetResultString) || (resolveType == .GoToDefinition);
            bool fullRefresh = resolveType == ResolveType.ClassifyFullRefresh;

			if (!isBackground)
				Debug.Assert(isInterrupt);

			if (mAsyncAutocomplete)
			{
				if ((resolveType == .Autocomplete) || (resolveType == .GetCurrentLocation) || (resolveType == .GetSymbolInfo))
				{
					isBackground = true;
				}
			}

			/*if ((mFilePath.Contains("mainA.bf")) && (isBackground))
			{
				Thread.Sleep(1000);
			}*/

			// If we think we're not running in the background, make sure
			Debug.Assert((Thread.CurrentThread == gApp.mMainThread) == !isBackground);

            if (isInterrupt)
                bfSystem.NotifyWillRequestLock(1);

            bool isFastClassify = false;
			BfParser parser;

			ProjectSource projectSource = FilteredProjectSource;

			int cursorPos = mEditWidget.mEditWidgetContent.CursorTextPos;

			if ((resolveParams != null) && (resolveParams.mOverrideCursorPos != -1))
				cursorPos = resolveParams.mOverrideCursorPos;

			bool emitHasCursor = false;
			if (resolveParams != null)
			{
				for (var embed in resolveParams.mEmitEmbeds)
				{
					if (embed.mCursorIdx != -1)
					{
						emitHasCursor = true;
						cursorPos = -1;
					}
				}
			}

            if ((!isBackground) && (projectSource != null))
			{
			    bfSystem.PerfZoneStart("CreateParser");
			    parser = bfSystem.CreateParser(projectSource, false);
			    bfSystem.PerfZoneEnd();
			}
			else if ((resolveParams != null) && (resolveParams.mParser != null))
			{
			    parser = bfSystem.CreateNewParserRevision(resolveParams.mParser);
			}
			else if (projectSource != null)
			{
				bfSystem.PerfZoneStart("CreateParser");
				parser = bfSystem.CreateParser(projectSource, false);
				bfSystem.PerfZoneEnd();
			}
			else
			{
			    // This only happens when we're editing source that isn't in our project
			    isFastClassify = true;
			    parser = bfSystem.CreateEmptyParser((BfProject)null);
			}

			EditWidgetContent.CharData[] charData = null;
			int charLen = 0;
			if ((resolveParams != null) && (resolveParams.mCharData != null))
			{
				charData = resolveParams.mCharData;
				charLen = resolveParams.mCharData.Count;
			}
			if (charData == null)
			{
				Debug.Assert(!isBackground);
				charData = mEditWidget.Content.mData.mText;
				charLen = mEditWidget.Content.mData.mTextLength;
			}

            /*var char8Data = (!isBackground) ? mEditWidget.Content.mData.mText : mProcessResolveCharData;
            int char8Len = Math.Min(char8Data.Count, mEditWidget.Content.mData.mTextLength);*/

            if (!isBackground)
                bfSystem.PerfZoneStart("DoClassify.CreateChars");

			
			//text.Append(chars, 0, chars.Count);

            char8* chars = new char8[charLen]* (?);
			defer delete chars;
            for (int32 i = 0; i < charLen; i++)
            {
                charData[i].mDisplayPassId = (int32)SourceDisplayId.Cleared;
                chars[i] = (char8)charData[i].mChar;
            }

			int textVersion = -1;
			if (resolveParams != null)
				textVersion = resolveParams.mTextVersion;

            if (!isBackground)
            {
                bfSystem.PerfZoneEnd();
                bfSystem.PerfZoneStart("SetSource");
            }
			parser.SetIsClassifying();
            parser.SetSource(.(chars, charLen), mFilePath, textVersion);
            if (!isBackground)
            {
                bfSystem.PerfZoneEnd();
                bfSystem.PerfZoneStart("DoClassify.DoWork");
            }

			//int cursorPos = mEditWidget.mEditWidgetContent.CursorTextPos;
			/*if (resolveType == ResolveType.Autocomplete)
				cursorPos--;*/
			/*if (resolveParams != null)
			{
				 if (resolveParams.mOverrideCursorPos != -1)
					cursorPos = resolveParams.mOverrideCursorPos;
			}*/

            if ((resolveType == ResolveType.GetNavigationData) || (resolveType == ResolveType.GetFixits))
                parser.SetAutocomplete(-1);
            else
			{
				bool setAutocomplete = ((!isBackground) && (resolveType != ResolveType.RenameSymbol));
				if ((resolveType == .Autocomplete) || (resolveType == .GetCurrentLocation) || (resolveType == .GetSymbolInfo) ||
					(resolveType == .GoToDefinition) || (resolveType == .GetResultString))
					setAutocomplete = true;
				if (setAutocomplete)
				{
					if (emitHasCursor)
						parser.SetAutocomplete(-2);
					else
                		parser.SetAutocomplete(Math.Max(emitHasCursor ? -1 : 0, cursorPos));
				}
			}
            /*else (!isFullClassify) -- do we ever need to do this?
                parser.SetCursorIdx(mEditWidget.mEditWidgetContent.CursorTextPos);*/

			String passInstanceName = scope String("DoClassify ");
			resolveType.ToString(passInstanceName);
			if (projectSource != null)
			    passInstanceName.Append(":", projectSource.mName);
			var passInstance = bfSystem.CreatePassInstance(passInstanceName);
			passInstance.SetClassifierPassId(!isBackground ? (uint8)SourceDisplayId.AutoComplete : (uint8)SourceDisplayId.FullClassify);
			if (isBackground)
			{
			    //Debug.Assert(mProcessingPassInstance == null);
			    //mProcessingPassInstance = passInstance;
				Debug.Assert(resolveParams.mPassInstance == null);
				resolveParams.mPassInstance = passInstance;
			}

			bool doFuzzyAutoComplete = resolveParams?.mDoFuzzyAutoComplete ?? false;

			var resolvePassData = parser.CreateResolvePassData(resolveType, doFuzzyAutoComplete);
			if (resolveParams != null)
			{
			    if (resolveParams.mLocalId != -1)
			        resolvePassData.SetLocalId(resolveParams.mLocalId);
			    if (resolveParams.mTypeDef != null)
			        resolvePassData.SetSymbolReferenceTypeDef(resolveParams.mTypeDef);
			    if (resolveParams.mFieldIdx != -1)
			        resolvePassData.SetSymbolReferenceFieldIdx(resolveParams.mFieldIdx);
			    if (resolveParams.mMethodIdx != -1)
			        resolvePassData.SetSymbolReferenceMethodIdx(resolveParams.mMethodIdx);
			    if (resolveParams.mPropertyIdx != -1)
			        resolvePassData.SetSymbolReferencePropertyIdx(resolveParams.mPropertyIdx);
			}

			if ((resolveParams != null) && (resolveParams.mDocumentationName != null))
				resolvePassData.SetDocumentationRequest(resolveParams.mDocumentationName);
			parser.Parse(passInstance, !mIsBeefSource);
			parser.Reduce(passInstance);

			if ((mIsBeefSource) &&
				((resolveType == .Classify) || (resolveType == .ClassifyFullRefresh)))
			{
				gApp.mErrorsPanel.ClearParserErrors(mFilePath);
				if (!isFastClassify)
					gApp.mErrorsPanel.ProcessPassInstance(passInstance, .Parse);
			}

			if (isInterrupt)
			{
			    bfSystem.PerfZoneEnd();
			    bfSystem.PerfZoneStart("Lock");
				var sw = scope Stopwatch(true);
				sw.Start();
			    bfSystem.Lock(1);
			    bfSystem.PerfZoneEnd();
			}
			else
			{
			    bfSystem.Lock(0);
			}

			if (!isFastClassify)
			    parser.BuildDefs(passInstance, resolvePassData, fullRefresh);

			// For Fixits we do want to parse the whole file but we need the cursorIdx bound still to
			//  locate the correct fixit info
			if (resolveType == ResolveType.GetFixits)
				parser.SetCursorIdx(Math.Max(0, cursorPos));

            if ((resolveType == ResolveType.ClassifyFullRefresh) && (mUseDebugKeyboard))
            {
                //Debug.WriteLine("Classify Paused...");
                mClassifyPaused = true;
                while (mClassifyPaused)
                    Thread.Sleep(20);
                //Debug.WriteLine("Classify Continuing."); 
            }

			//Debug.WriteLine($"Classify {resolveType}");

            /*if (resolveType == ResolveType.RenameLocalSymbol)
            {
                // We do want cursor info for replacing the symbol, we just didn't want it for reducing 
                //  and building defs
                parser.SetAutocomplete(Math.Max(0, mEditWidget.mEditWidgetContent.CursorTextPos - 1));
            }*/

			if ((!isFastClassify) && (bfCompiler != null))
            {
				parser.CreateClassifier(passInstance, resolvePassData, charData);

				if ((resolveParams != null) && (gApp.mSettings.mEditorSettings.mEmitCompiler == .Resolve))
				{
					for (var emitEmbedData in resolveParams.mEmitEmbeds)
					{
						resolvePassData.AddEmitEmbed(emitEmbedData.mTypeName, emitEmbedData.mCursorIdx);
					}
				}

                if (bfCompiler.ClassifySource(passInstance, resolvePassData))
				{
					if ((resolveType == .Classify) || (resolveType == .ClassifyFullRefresh))
					{
						String explicitEmitTypeNames = scope .();
						for (var explicitType in mExplicitEmitTypes)
						{
							explicitEmitTypeNames.Append(explicitType);
							explicitEmitTypeNames.Append("\n");
						}

						bool allowCollapseData = resolveType == .ClassifyFullRefresh;
						if (allowCollapseData)
						{
							var collapseData = bfCompiler.GetCollapseRegions(parser, resolvePassData, explicitEmitTypeNames, .. scope .());
							using (mMonitor.Enter())
							{
								DeleteAndNullify!(mQueuedCollapseData);
								mQueuedCollapseData = new .();
								mQueuedCollapseData.mData.Set(collapseData);
								mQueuedCollapseData.mTextVersion = resolveParams.mTextVersion;
								mQueuedCollapseData.mCharIdSpan = resolveParams.mCharIdSpan.Duplicate();
								mQueuedCollapseData.mResolveType = resolveType;
							}
						}
						else
						{
							QueueFullRefresh(false);
						}
					}

					if (resolveParams != null)
					{
						for (var emitEmbedData in resolveParams.mEmitEmbeds)
						{
							var data = resolvePassData.GetEmitEmbedData(emitEmbedData.mTypeName, var srcLength, var revision);
							if ((srcLength < 0) && (resolveType == .ClassifyFullRefresh))
								srcLength = 0;
							if (srcLength >= 0)
							{
								emitEmbedData.mCharData = new EditWidgetContent.CharData[srcLength+1] (?);
								emitEmbedData.mCharData[srcLength] = default;
								Internal.MemCpy(emitEmbedData.mCharData.Ptr, data, srcLength * strideof(EditWidgetContent.CharData));
							}
						}
					}
				}
				else
                {
					//DeleteAndNullify!(mProcessResolveCharData);
					//mProcessResolveCharIdSpan.Dispose();

					resolveParams.mCancelled = true;
                    if ((resolveType == ResolveType.Classify) || (resolveType == ResolveType.ClassifyFullRefresh))
					{
                        QueueFullRefresh(false);
					}
                    bfCompiler.QueueDeferredResolveAll();
                }

				parser.FinishClassifier(resolvePassData);
            }
            else
            {
                parser.ClassifySource(charData, !mIsBeefSource);
            }

            if (!isBackground)
            {
                String autocompleteInfo = scope String();
                bfCompiler.GetAutocompleteInfo(autocompleteInfo);
				HandleResolveResult(resolveType, autocompleteInfo, resolveParams);
            }
			else if (resolveParams != null)
			{
				resolveParams.mAutocompleteInfo = new String();
				bfCompiler.GetAutocompleteInfo(resolveParams.mAutocompleteInfo);
			}

            if (!isBackground)            
                bfSystem.PerfZoneStart("Cleanup");
            delete resolvePassData;

            if ((!isBackground) || (isFastClassify))
            {
                //bool isAutocomplete = (resolveType == ResolveType.Autocomplete) || (resolveType == ResolveType.Autocomplete_HighPri);
                //if (isAutocomplete)
                if ((!isFastClassify) && (!isBackground) && (resolveType == ResolveType.Autocomplete))
                    InjectErrors(passInstance, mEditWidget.mEditWidgetContent.mData.mText, mEditWidget.mEditWidgetContent.mData.mTextIdData.GetPrepared(), true, false);
                //IDEApp.sApp.ShowPassOutput(passInstance);
                
                delete passInstance;
				if ((resolveParams != null) && (resolveParams.mPassInstance == passInstance))
					resolveParams.mPassInstance = null;
            }
            else
            {
				if (!isInterrupt)
                	bfSystem.RemoveOldData();
            }

			if ((resolveParams == null) || (resolveParams.mParser == null))
			{
				delete parser;
				mWantsParserCleanup = true;
			}
            
            bfSystem.Unlock();

            if (!isBackground)
                bfSystem.PerfZoneEnd();

			if ((resolveParams != null) && (resolveParams.mWaitEvent != null))
				resolveParams.mWaitEvent.Set(true);

            //Debug.WriteLine("Classify Done {0}", !isBackground);

            /*for (int i = 0; i < text.Length; i++)
                mEditWidget.Content.mText[i].mTypeNum = (ushort)elementTypeArray[i];            */            
        }

        int32 GetBraceNum(EditWidgetContent.CharData c)
        {
            if (c.mDisplayTypeId != 0)
                return 0;
            switch ((char8)c.mChar)
            {
                case '{':
                    return 1;
                case '[':
                    return 2;
                case '(':
                    return 3;
                case '<':
                    return 4;
                case '}':
                    return -1;
                case ']':
                    return -2;
                case ')':
                    return -3;
                case '>':
                    return -4;
            }
            return 0;
        }

        public void MatchBrace()
        {
            var textData = mEditWidget.Content.mData.mText;
            int32[] braceCounts = scope int32[4];

            int cursorIdx = mEditWidget.Content.CursorTextPos;
            int braceIdx = cursorIdx;
            int braceNum = GetBraceNum(textData[braceIdx]);
            if ((braceNum == 0) && (braceIdx > 0))
            {
                braceIdx--;
                cursorIdx--;
                braceNum = GetBraceNum(textData[braceIdx]);
            }
            if (braceNum != 0)
            {
                int bracePairNum = -braceNum;
                int searchIdx = braceIdx;
                int searchDir = braceNum / Math.Abs(braceNum);
                int braceDepth = 0;

                while ((searchIdx >= 0) && (searchIdx < textData.Count))
                {
                    int32 checkBraceNum = GetBraceNum(textData[searchIdx]);
                    if ((checkBraceNum != 0) && ((braceNum == 4) || (braceNum == -4)))
                    {
                        if (checkBraceNum > 0)
                            braceCounts[checkBraceNum - 1]++;
                        else if (checkBraceNum < 0)
                        {
                            int32 decBraceNum = -checkBraceNum - 1;
                            braceCounts[decBraceNum]--;
                            if ((decBraceNum != 3) && (braceNum != checkBraceNum) && (braceCounts[decBraceNum] < 0))
                                return;
                        }
                    }

                    if (textData[searchIdx].mDisplayTypeId != 0)
                        checkBraceNum = 0;
                    if ((checkBraceNum == braceNum) || (checkBraceNum == bracePairNum))
                    {
                        braceDepth += checkBraceNum;
                        if (braceDepth == 0)
                        {
                            if (searchDir > 0)
                                searchIdx++; // Put cursor after close

                            if ((braceNum == 4) || (braceNum == -4))
                            {
                                // If we're matching <>'s then make sure the ) and } counts are zero
                                if ((braceCounts[0] != 0) || (braceCounts[1] != 0) || (braceCounts[2] != 0))
                                    break;
                            }

                            int cursorStartPos = cursorIdx;
                            if (searchDir < 0)
                                cursorStartPos++;
                            mEditWidget.Content.CursorTextPos = searchIdx;
                            if (mWidgetWindow.IsKeyDown(KeyCode.Shift))
                            {
                                mEditWidget.Content.mSelection = EditSelection(cursorStartPos, mEditWidget.Content.CursorTextPos);
                            }
                            else
                                mEditWidget.Content.mSelection = null;
                            mEditWidget.Content.CursorMoved();
                            mEditWidget.Content.EnsureCursorVisible();
                            break;
                        }
                    }

                    searchIdx += searchDir;
                }
            }
        }

        public bool FileNameMatches(String fileName)
        {
			if (mFilePath == null)
				return false;
			if ((mAliasFilePath != null) && (Path.Equals(fileName, mAliasFilePath)))
				return true;
            return Path.Equals(fileName, mFilePath);
        }

        public void HilitePosition(LocatorType hilitePosition, int32 prevLine = -1)
        {
            if (hilitePosition == LocatorType.None)
                return;

            if ((hilitePosition == LocatorType.Smart) && (prevLine != -1) && (!mJustShown))
            {
                int32 newLine = mEditWidget.Content.CursorLineAndColumn.mLine;
                if (Math.Abs(prevLine - newLine) < 16)
                    return;
            }

            float x;
            float y;
            mEditWidget.Content.GetTextCoordAtCursor(out x, out y);

            var sourceEditWidgetContent = (SourceEditWidgetContent)mEditWidget.Content;

            LocatorAnim.Show(hilitePosition, mEditWidget.Content, x, y + sourceEditWidgetContent.mFont.GetLineSpacing() / 2);
        }

        public void ShowFileLocation(int cursorIdx, LocatorType hilitePosition)
        {   
         	var activePanel = GetActivePanel();

			if (activePanel != this)
			{
				activePanel.ShowFileLocation(cursorIdx, hilitePosition);
				return;
			}

			if (mEditWidget == null)
				return;

            int32 prevLine = mEditWidget.Content.CursorLineAndColumn.mLine;
			
            mEditWidget.Content.mSelection = null;

			int wantCursorPos = Math.Min(mEditWidget.Content.mData.mTextLength - 1, cursorIdx);
			if (wantCursorPos >= 0)
            	mEditWidget.Content.CursorTextPos = wantCursorPos;
            mEditWidget.Content.CursorMoved();
            mEditWidget.Content.EnsureCursorVisible(true, true);
			mEditWidget.Content.mCursorImplicitlyMoved = true;
            if (mJustShown) // Jump to whatever position we're scrolling to
            {
                mEditWidget.mVertPos.mPct = 1.0f;
                mEditWidget.UpdateContentPosition();
            }
            
            HilitePosition(hilitePosition, prevLine);
        }

        public void ShowFileLocation(int refHotIdx, int line, int column, LocatorType hilitePosition)
        {
			mRequestedLineAndColumn = EditWidgetContent.LineAndColumn(line, column);
                     
            //int prevLine = mEditWidget.Content.CursorLineAndColumn.mLine;
            var content = mEditWidget.Content;
			var useLine = line;

			ProjectSource projectSource = FilteredProjectSource;

            if (projectSource != null)
            {
                bool allowThrough = false;
                bool worked = false;
                if (refHotIdx == -1)
                {
                    int char8Idx = content.GetTextIdx(useLine, column);
                    ShowFileLocation(char8Idx, hilitePosition);
                    worked = true;
                }
                else
                {                    
                    int32 char8Id = IDEApp.sApp.mWorkspace.GetProjectSourceCharId(projectSource, refHotIdx, useLine, column);
                    if (char8Id != 0)
                    {
                        int char8Idx = content.GetCharIdIdx(char8Id);
                        if (char8Idx != -1)
                        {
                            ShowFileLocation(char8Idx, hilitePosition);
                            worked = true;
                        }
                        else if (IDEApp.sApp.mWorkspace.GetProjectSourceCompileInstance(projectSource, refHotIdx) == null)
                        {
                            allowThrough = true;
                        }
                    }
                }

                if (mOldVersionPanel != null)
                {
                    float scrollTopDelta = mEditWidget.Content.GetCursorScreenRelY();
                    mOldVersionPanel.ShowFileLocation(refHotIdx, useLine, column, hilitePosition);
                    if (mOldVersionPanel.mJustShown)
                    {
                        mOldVersionPanel.mEditWidget.Content.SetCursorScreenRelY(scrollTopDelta - mOldVersionPanel.mPanelHeader.mHeight);
                        mOldVersionPanel.mEditWidget.Content.EnsureCursorVisible(true, true);
                    }
                    return;
                }

                if (!allowThrough)
                {
                    if (!worked)
                        IDEApp.Beep(IDEApp.MessageBeepType.Error);
                    return;
                }
            }
            
            useLine = Math.Min(useLine, content.GetLineCount() - 1);

            int cursorIdx = content.GetTextIdx(useLine, column);
            ShowFileLocation(cursorIdx, hilitePosition);

            /*content.MoveCursorTo(line, column, true);
            //content.EnsureCursorVisible(true, true);
            if (mJustShown) // Jump to whatever position we're scrolling to
            {
                mEditWidget.mVertPos.mPct = 1.0f;
                mEditWidget.UpdateContentPosition();
            }
            if (hilitePosition)
                HilitePosition(prevLine);*/
        }

		void RemoveEditWidget()
		{

		}

		public void AttachToProjectSource(ProjectSource projectSource)
		{
			mProjectSource = projectSource;
			if (mEditData != null)
			{
				if (mProjectSource.mEditData == null)
				{
					mEditData.Ref();
					mProjectSource.mEditData = mEditData;
					mEditData.mProjectSources.Add(mProjectSource);
					// Rehup mFileDeleted if necessary
					if (mEditData.mFileDeleted)
						mEditData.IsFileDeleted();
				}
			}
			QueueFullRefresh(true);
		}

		public void DetachFromProjectItem(bool fileDeleted)
		{
			if (mProjectSource == null)
				return;

			if (fileDeleted)
			{
				// We manually add this change record because it may not get caught since the watch dep may be gone
				// This will allow the "File Deleted" dialog to show.
				var changeRecord = new FileWatcher.ChangeRecord();
				changeRecord.mChangeType = .Deleted;
				changeRecord.mPath = new String(mFilePath);
				gApp.mFileWatcher.AddChangedFile(changeRecord);
			}

			ProcessDeferredResolveResults(-1);

			//Debug.Assert(mEditData != null);

			//gApp.mFileEditData.Add(mEditData);
            //mProjectSource.mEditData = null;
			mProjectSource = null;
			QueueFullRefresh(true);

			if (mOldVersionPanel != null)
				mOldVersionPanel.DetachFromProjectItem(false);
			if (mSplitTopPanel != null)
				mSplitTopPanel.DetachFromProjectItem(false);
		}

		public void CloseEdit()
		{
			var sewc = mEditWidget.mEditWidgetContent as SourceEditWidgetContent;
			for (var embed in sewc.mEmbeds.Values)
			{
				if (var emitEmbed = embed as SourceEditWidgetContent.EmitEmbed)
				{
					if (emitEmbed.mView != null)
					{
						emitEmbed.mView.RemoveSelf();
						DeleteAndNullify!(emitEmbed.mView);
						sewc.mCollapseNeedsUpdate = true;
					}
				}
			}

			mEditWidget.mPanel = null;

			var editWidgetContent = (SourceEditWidgetContent)mEditWidget.Content;
			if (editWidgetContent.mAutoComplete != null)
				editWidgetContent.mAutoComplete.Close();
			DeleteAndNullify!(editWidgetContent.mOnGenerateAutocomplete);
			DeleteAndNullify!(editWidgetContent.mOnEscape);
			DeleteAndNullify!(editWidgetContent.mOnFinishAsyncAutocomplete);
			DeleteAndNullify!(editWidgetContent.mOnCancelAsyncAutocomplete);
			editWidgetContent.mSourceViewPanel = null;
			mEditWidget.RemoveSelf();

			if ((mEditData != null) && (mEditData.mEditWidget == mEditWidget))
			{
				// if there's another view of this window open, remap the mEditData.mEditWidget to that one
				//  That allows us to delete our current edit widget
				for (var user in mEditData.mEditWidget.mEditWidgetContent.mData.mUsers)
				{
					if ((user != mEditWidget.mEditWidgetContent) && (var sourceEditWidget = user.mEditWidget as SourceEditWidget))
					{
						mEditData.mEditWidget = sourceEditWidget;
					}
				}
			}

			if ((mEditData != null) && (mEditData.mEditWidget == mEditWidget))
			{
				//Debug.WriteLine("Dispose mEditData.mEditWidget = {0}", mEditWidget);
				Debug.Assert(mEditWidget.mParent == null);
				mEditData.mOwnsEditWidget = true;
			}
			else
			{
				//Debug.WriteLine("Dispose deleting mEditWidget {0}", mEditWidget);
				delete mEditWidget;
			}
			mEditWidget = null;

			if ((mProjectSource == null) && (mEditData != null) && (mEditData.mOwnsEditWidget) && (mEditData.mEditWidget.mEditWidgetContent.mData.mUsers.Count == 1))
			{
				// This isn't needed anymore...
				gApp.DeleteEditData(mEditData);
			}
			mEditData = null;
		}

        public override void Dispose()
        {
			if (mDisposed)
				return;

			if (mProjectSource?.mEditData?.HasTextChanged() == true)
			{
				mProjectSource.ClearEditData();
			}

			ProcessDeferredResolveResults(-1);

			if (IDEApp.sApp.mLastActiveSourceViewPanel == this)
				IDEApp.sApp.mLastActiveSourceViewPanel = null;

			if (IDEApp.sApp.mLastActivePanel == this)
				IDEApp.sApp.mLastActivePanel = null;

			if (Content.Data.mCurQuickFind != null)
			{
				//Content.Data.mCurQuickFind.Close();
				Content.Data.mCurQuickFind = null;
			}

			if (mFilePath != null)            
				IDEApp.sApp.mFileWatcher.RemoveWatch(mFilePath);

            CloseEdit();

            /*if (mProjectSource != null)
                mProjectSource.ClearUnsavedData();*/

            if (mOldVersionPanel != null)
                mOldVersionPanel.Dispose();
			if (mSplitTopPanel != null)
				mSplitTopPanel.Dispose();

            DebugManager debugManager = IDEApp.sApp.mDebugger;
            debugManager.mBreakpointsChangedDelegate.Remove(scope => BreakpointsChanged, true);

#if IDE_C_SUPPORT
            if (mIsClang)
            {
                var clangCompiler = ClangResolveCompiler;
                clangCompiler.QueueFileRemoved(mFilePsath);                
            }
#endif

			if (IDEApp.sApp.mBfResolveHelper != null)
            	IDEApp.sApp.mBfResolveHelper.SourceViewPanelClosed(this);

            if (mResolveJobCount > 0)
            {
				//TODO: Make a way we can cancel only our specific job
                ResolveCompiler.CancelBackground();
                Debug.Assert(mResolveJobCount == 0);
            }

			if (mSpellCheckJobCount > 0)
			{
				IDEApp.sApp.mSpellChecker.CancelBackground();
				Debug.Assert(mSpellCheckJobCount == 0);
			}

            if (mRenameSymbolDialog != null)
                mRenameSymbolDialog.Close();

            base.Dispose();
        }

        public void Close()
        {

        }

		SourceViewPanel GetOldVersionPanel()
		{
			if (mSplitBottomPanel != null)
				return mSplitBottomPanel.mOldVersionPanel;
			return mOldVersionPanel;
		}

		public SourceViewPanel GetActivePanel()
		{
			if (mSplitTopPanel != null)
			{
				if (mSplitTopPanel.mLastFocusTick > mLastFocusTick)
				{					
					return mSplitTopPanel.GetActivePanel();
				}
			}

			if (mOldVersionPanel != null)
			{			    
			    return mOldVersionPanel.GetActivePanel();
			}

			return this;
		}

        public void FocusEdit()
        {
			if (mWidgetWindow == null)
				return;
			let activePanel = GetActivePanel();
            activePanel.mEditWidget?.SetFocus();

			if (!mWidgetWindow.mHasFocus)
				EditGotFocus();
        }

        public override void SetFocus()
        {			
            //mEditWidget.SetFocus();
			FocusEdit();
        }

		public bool HasFocus(bool selfOnly = false)
		{
			if (!selfOnly)
			{
				if ((mSplitTopPanel != null) && (mSplitTopPanel.mEditWidget.mHasFocus))
					return true;
				if ((mSplitBottomPanel != null) && (mSplitBottomPanel.mEditWidget.mHasFocus))
					return true;
				if ((mOldVersionPanel != null) && (mOldVersionPanel.mEditWidget.mHasFocus))
					return true;
			}
			if (mEditWidget.mHasFocus)
				return true;
			if (mQuickFind != null)
				return mQuickFind.HasFocus();
			return false;
		}

		public void SyncWithWorkspacePanel()
		{
			if (gApp.mProjectPanel.[Friend]mProjectToListViewMap.TryGet(mProjectSource, var matchKey, var projectListViewItem))
			{
				var checkLVItem = projectListViewItem.mParentItem;
				while (checkLVItem != null)
				{
					checkLVItem.Open(true);
					checkLVItem = (ProjectListViewItem)checkLVItem.mParentItem;
				}

				projectListViewItem.mListView.GetRoot().SelectItemExclusively(projectListViewItem);
				projectListViewItem.mListView.EnsureItemVisible(projectListViewItem, false);
			}
		}

        public override void EditGotFocus()
        {
			if ((mFilePath != null) && (mEmbedKind == .None))
				gApp.AddToRecentDisplayedFilesList(mFilePath);
			if (mLoadFailed)
				return;
#if IDE_C_SUPPORT
            if (mIsClang)
            {
                if (IDEUtils.IsHeaderFile(mFilePath))
                {
                    // If a different cpp file has gotten focus since we have last been here, then we want to
                    //  re-evaluate the mClangSource so we can potentially switch to using that
                    //if (mClangSource != null)
                    {
                        var resolveClang = IDEApp.sApp.mResolveClang;
                        using (resolveClang.mMonitor.Enter())
                        {                            
                            if (mLastMRUVersion != resolveClang.mProjectSourceVersion)
                            {
                                //mClangSource = null;
                                QueueFullRefresh(true);
                                mLastMRUVersion = resolveClang.mProjectSourceVersion;
                            }
                        }
                    }
                }
                else if (mProjectSource != null)
                    IDEApp.sApp.mResolveClang.UpdateMRU(mProjectSource);
            }
#endif
            var sourceEditWidgetContent = (SourceEditWidgetContent)mEditWidget.Content;
            sourceEditWidgetContent.mCursorStillTicks = 0;
			sourceEditWidgetContent.mCursorBlinkTicks = 0;

			if (mProjectSource != null)
			{
                var editData = gApp.GetEditData(mProjectSource, true);
				editData.mEditWidget = mEditWidget;
			}

			if (mEmbedKind == .None)
			{
				gApp.mLastActiveSourceViewPanel = this;
				gApp.mLastActivePanel = this;

				if ((gApp.mSettings.mEditorSettings.mSyncWithWorkspacePanel) && (mProjectSource != null))
				{
					SyncWithWorkspacePanel();
				}
			}
        }

        public override void EditLostFocus()
        {
#if IDE_C_SUPPORT
            if (mClangSourceChanged)
            {
                IDEApp.sApp.mDepClang.FileSaved(mFilePath);
                mClangSourceChanged = false;
            }
#endif
        }

		protected override void RemovedFromWindow()
		{
			if (mHoverWatch != null)
				mHoverWatch.Close();

			if (mRenameSymbolDialog != null)
				mRenameSymbolDialog.Cancel();

			if (mEditWidget != null)
			{
				var sourceEditWidgetContent = (SourceEditWidgetContent)mEditWidget.Content;
				if (sourceEditWidgetContent.mAutoComplete != null)
					sourceEditWidgetContent.mAutoComplete.Close();
			}

			base.RemovedFromWindow();
			CloseOldVersion();

			if ((NeedsPostRemoveUpdate) && (!mInPostRemoveUpdatePanels))
			{
				//Debug.WriteLine("Adding sourceViewPanel to mPostRemoveUpdatePanel {0}", this);
				mInPostRemoveUpdatePanels = true;
				gApp.mPostRemoveUpdatePanels.Add(this);
			}
		}

        public override void AddedToParent()
        {
            base.AddedToParent();
            mWantsFullClassify = true;
            mWantsFullRefresh = true;
            mJustShown = true;
            mWantsClassifyAutocomplete = false;
            
            if (mUpdateCnt == 0)
            {
                //DoFastClassify();
				mWantsFastClassify = true;
                mWantsFullClassify = true;
            }

            if (mDesiredVertPos != 0)
            {
                mEditWidget.Content.RecalcSize();
                mEditWidget.mVertPos.Set(mDesiredVertPos, true);                
                mEditWidget.UpdateContentPosition();
                mDesiredVertPos = 0;
            }
            //IDEApp.sApp.mInDisassemblyView = false;

            if ((mProjectSource != null) && (IDEApp.sApp.mWakaTime != null))
            {
                IDEApp.sApp.mWakaTime.QueueFile(mFilePath, mProjectSource.mProject.mProjectName, false);
            }

			IDEApp.sApp.mLastActiveSourceViewPanel = this;
			IDEApp.sApp.mLastActivePanel = this;
        }

        void CheckTrackedElementChanges()
        {
            if (mHotFileIdx != -1)
                return;

			bool hadBreakpointChanges = false;

            // Update tracked positions
            if (mTrackedTextElementViewList != null)
            {
                var editContent = (SourceEditWidgetContent)mEditWidget.Content;

                for (var trackedElementView in mTrackedTextElementViewList)
                {                    
                    int32 startContentIdx = -1;
					if (trackedElementView.mTrackedElement.mIsDead)
						continue;
                    var breakpoint = trackedElementView.mTrackedElement as Breakpoint;
                    var trackedElement = trackedElementView.mTrackedElement;

                    if (trackedElement.mSnapToLineStart)
                    {
                        int32 lineLeft = trackedElementView.mTextPosition.mIndex;
						if (lineLeft < editContent.mData.mTextLength)
						{
	                        repeat
	                        {
	                            if (!((char8)editContent.mData.mText[lineLeft].mChar).IsWhiteSpace)
	                                startContentIdx = lineLeft;                            
	                            lineLeft--;
	                        }
	                        while ((lineLeft > 0) && (editContent.mData.mText[lineLeft].mChar != '\n'));
						}

						if (startContentIdx == -1)
						{
							lineLeft = trackedElementView.mTextPosition.mIndex;

							repeat
							{
								if (lineLeft >= editContent.mData.mTextLength)
									break;

							    if (!((char8)editContent.mData.mText[lineLeft].mChar).IsWhiteSpace)
								{
							        startContentIdx = lineLeft;
									break;
								}
							    lineLeft++;
							}
							while ((lineLeft > 0) && (editContent.mData.mText[lineLeft].mChar != '\n'));
						}
                    }
                    else
                        startContentIdx = trackedElementView.mTextPosition.mIndex;

                    if ((startContentIdx == -1) || (trackedElementView.mTextPosition.mWasDeleted))
                    {
                        if (breakpoint != null)
                        {
							BfLog.LogDbg("Tracked element deleted. Deleting breakpoint\n");
                            IDEApp.sApp.mDebugger.DeleteBreakpoint(breakpoint);
                            continue;
                        }
                        else
                        {
                            trackedElementView.mTextPosition.mWasDeleted = false;
                            if (startContentIdx == -1)
                                startContentIdx = trackedElementView.mTextPosition.mIndex;
                        }
                    }

                    if (trackedElementView.mLastMoveIdx != trackedElement.mMoveIdx)
					{
						UpdateTrackedElementView(trackedElementView);
						continue;
					}

                    trackedElementView.mTextPosition.mIndex = startContentIdx;

                    int line;
                    int lineCharIdx;
                    mEditWidget.Content.GetLineCharAtIdx(trackedElementView.mTextPosition.mIndex, out line, out lineCharIdx);

					if ((breakpoint != null) && (breakpoint.mLineNum != line))
						hadBreakpointChanges = true;
                    //RemapActiveToCompiledLine(0, ref line, ref lineCharIdx);
                    trackedElementView.mTrackedElement.Move(line, lineCharIdx);
                }
            }

			if (hadBreakpointChanges)
				IDEApp.sApp.mDebugger.mBreakpointsChangedDelegate();
        }

        void UpdateTrackedElements()
        {
            if (mHotFileIdx != -1)
                return;
			if (!mIsBeefSource)
				return;

            for (var breakpointView in GetTrackedElementList())
            {
                var trackedElement = breakpointView.mTrackedElement;
                var breakpoint = trackedElement as Breakpoint;                
                //if ((breakpoint != null) && (breakpoint.mNativeBreakpoint != null))

				//TODO: we're only doing this for BOUND breakpoints.  Otherwise if we create a new method and set a
				// breakpoint on it but the new method hasn't actually been compile yet, then it causes the breakpoint
				// to go crazy
				if ((breakpoint != null) && (breakpoint.mNativeBreakpoint != null))
                {                                                            
                    int32 breakpointLineNum = breakpoint.GetLineNum();

                    if (breakpointLineNum != breakpointView.mLastBoundLine)
                    {
                        breakpointView.mLastBoundLine = breakpointLineNum;
                        UpdateTrackedElementView(breakpointView);

                        int compileIdx = IDEApp.sApp.mWorkspace.GetHighestCompileIdx();
                        if (compileIdx != -1)
                        {
                            int column = -1;
                            breakpoint.mLineNum = breakpointLineNum;
							int line = breakpoint.mLineNum;
                            RemapCompiledToActiveLine(compileIdx, ref line, ref column);
							breakpoint.mLineNum = (int32)line;
                        }
                    }                                                                    
                }
            }
        }

        void BreakpointsChanged()
        {
            mTrackedTextElementViewListDirty = true;
        }

		public void EnsureTrackedElementsValid()
		{
			if (mTrackedTextElementViewListDirty)
			{
			    // Update the old one and then clear it and then update the new one
				//TODO: The old one could contain deleted breakpoints and such...  Under what circumstances should be do this?
			    CheckTrackedElementChanges();
			    GetTrackedElementList();
			}
			CheckTrackedElementChanges();
		}

        public void ClearTrackedElements()
        {
            if (mTrackedTextElementViewList != null)
            {
                var editWidgetContent = (SourceEditWidgetContent)mEditWidget.Content;
                for (var breakpoint in mTrackedTextElementViewList)
				{
                    editWidgetContent.PersistentTextPositions.Remove(breakpoint.mTextPosition);
					delete breakpoint.mTextPosition;
				}
				DeleteContainerAndItems!(mTrackedTextElementViewList);
            }
            mTrackedTextElementViewList = null;
        }

        public void UpdateTrackedElementView(TrackedTextElementView trackedElementView)
        {            
            var editWidgetContent = (SourceEditWidgetContent)mEditWidget.Content;
            var trackedElement = trackedElementView.mTrackedElement;

            if (trackedElementView.mTextPosition != null)            
            {
                editWidgetContent.PersistentTextPositions.Remove(trackedElementView.mTextPosition);            
				delete trackedElementView.mTextPosition;
			}

            int lineStart;
            int lineEnd;
            mEditWidget.Content.GetLinePosition(trackedElement.mLineNum, out lineStart, out lineEnd);
            
            trackedElementView.mTextPosition = new PersistentTextPosition((int32)Math.Min(editWidgetContent.mData.mTextLength, lineStart + trackedElement.mColumn));
            editWidgetContent.PersistentTextPositions.Add(trackedElementView.mTextPosition);

			trackedElementView.mLastMoveIdx = trackedElement.mMoveIdx;
        }

        List<TrackedTextElementView> GetTrackedElementList()
        {
			if ((mEmbedKind != .None) && (mEditWidget.mEditWidgetContent.mData.mTextLength == 0))
			{
				if (mTrackedTextElementViewList == null)
					mTrackedTextElementViewList = new .();
				return mTrackedTextElementViewList;
			}

            if (mTrackedTextElementViewListDirty)
            {
                ClearTrackedElements();
                mTrackedTextElementViewListDirty = false;
            }

            DebugManager debugManager = IDEApp.sApp.mDebugger;
            if (mTrackedTextElementViewList == null)
            {
                String findFileName = mFilePath;
				String srcFileName = mAliasFilePath ?? mFilePath;
                
                mTrackedTextElementViewList = new List<TrackedTextElementView>();
				if (mFilePath == null)
					return mTrackedTextElementViewList;
				
				for (var folder in IDEApp.sApp.mBookmarkManager.mBookmarkFolders)
				{
				    for (var bookmark in folder.mBookmarkList)
				    {
				        if (Path.Equals(bookmark.mFileName, findFileName))
				        {
				            var bookmarkView = new TrackedTextElementView(bookmark);
				            UpdateTrackedElementView(bookmarkView);
				            mTrackedTextElementViewList.Add(bookmarkView);
				        }
				    }
				}

                for (var breakpoint in debugManager.mBreakpointList)
                {
                    if ((breakpoint.mFileName != null) && (Path.Equals(breakpoint.mFileName, srcFileName)))
                    {
                        var breakpointView = new TrackedTextElementView(breakpoint);
                        UpdateTrackedElementView(breakpointView);
                        mTrackedTextElementViewList.Add(breakpointView);
                    }
                }                

                //////
                for (var historyEntry in IDEApp.sApp.mHistoryManager.mHistoryList)
                {
                    if (Path.Equals(historyEntry.mFileName, findFileName))
                    {
                        var historyView = new TrackedTextElementView(historyEntry);
                        UpdateTrackedElementView(historyView);
                        mTrackedTextElementViewList.Add(historyView);
                    }
                }
            }

            return mTrackedTextElementViewList;
        }

		void CloseHeader()
		{
			if (mPanelHeader != null)
			{
				mPanelHeader.RemoveSelf();
				gApp.DeferDelete(mPanelHeader);
				mPanelHeader = null;
				ResizeComponents();
			}
		}

		void ClearLoadFailed()
		{
			if (mLoadFailed)
			{
				mLoadFailed = false;
				CloseHeader();
			}
		}

		public void CheckBinary()
		{
			mIsBinary = false;

			let data = mEditWidget.mEditWidgetContent.mData;
			for (int i < data.mTextLength)
			{
				if (data.mText[i].mChar <= '\x08')
				{
					data.mText[i].mChar = ' ';
					mIsBinary = true;
				}
			}

			if (mIsBinary)
			{
				for (int i < data.mTextLength)
				{
					if (data.mText[i].mChar >= '\x80')
					{
						data.mText[i].mChar = ' ';
						mIsBinary = true;
					}
				}
			}

			if (mIsBinary)
			{
				mEditWidget.mEditWidgetContent.mIsReadOnly = true;
			}
		}

        public bool Show(String filePath, bool silentFail = false, FileEditData fileEditData = null)
        {
			scope AutoBeefPerf("SourceViewPanel.Show");

			ClearLoadFailed();

			Debug.Assert(!mDisposed);

			String useFilePath = null;
			var useFileEditData = fileEditData;
			if (filePath != null)
			{
				Debug.Assert(!filePath.Contains("//"));

	            useFilePath = scope:: String(filePath);
	            IDEUtils.FixFilePath(useFilePath);

	            if (mProjectSource == null)
	            {
	                mProjectSource = IDEApp.sApp.FindProjectSourceItem(useFilePath);
	            }
			}

			if ((useFileEditData == null) && (useFilePath != null))
			{
	            if (mProjectSource != null)
				{
	                useFileEditData = IDEApp.sApp.GetEditData(mProjectSource, true);
				}
				else
				{
					useFileEditData = gApp.GetEditData(useFilePath, true, true);
				}
				if (useFileEditData.mEditWidget == null)
					useFileEditData = null;
			}

			mEditData = useFileEditData;
            if (useFileEditData != null)
            {
				if (useFileEditData.mEditWidget != null)
				{
					if (mEditWidget != null)
					{
						mEditWidget.RemoveSelf();
						delete mEditWidget;
						mEditWidget = null;
					}

					//Debug.Assert(projectSourceEditData.mOwnsEditWidget);
					if (useFileEditData.mOwnsEditWidget)
					{
		                mEditWidget = useFileEditData.mEditWidget;
						useFileEditData.mOwnsEditWidget = false;

						//Debug.WriteLine("Taking over EditWidget {0} Parent: {1}", mEditWidget, mEditWidget.mParent);
						Debug.Assert(mEditWidget.mParent == null);
					}
					else
					{
						mEditWidget = IDEApp.sApp.CreateSourceEditWidget(useFileEditData.mEditWidget);
						mEditWidget.Content.RecalcSize();

						//Debug.WriteLine("Creating new EditWidget {0}", mEditWidget);
					}
				}
                //mLastFileTextVersion = useFileEditData.mLastFileTextVersion;
            }

			if (mEditWidget == null)
            {
                mEditWidget = IDEApp.sApp.CreateSourceEditWidget();
            }
            SetupEditWidget();

			DeleteAndNullify!(mFilePath);
			if (useFilePath != null)
			{
	            mFilePath = new String(useFilePath);
	            IDEApp.sApp.mFileWatcher.WatchFile(mFilePath);
	            
	            var ext = scope String();
	            Path.GetExtension(useFilePath, ext);
				/*if (ext.Length == 0)
					return false;*/
	            ext.ToLower();
	            mIsSourceCode = IDEApp.IsSourceCode(useFilePath);
	            mIsBeefSource = IDEApp.IsBeefFile(useFilePath);
			}

            //TODO: Find mProjectSource

            if (mIsSourceCode && !mIsBeefSource)
            {
                mIsClang = true;
                //((SourceEditWidgetContent)mEditWidget.Content).mAsyncAutocomplete = true;
            }

            mJustShown = true;
            mWantsFullRefresh = true;
            mWantsFullClassify = true;

            //mCurBfParser = IDEApp.sApp.mBfResolveSystem.CreateParser(mFilePath);
            if (useFileEditData == null)
            {
                var text = scope String();
				SourceHash hash;
				if (mFilePath == null)
				{
					// Nothing
				}
                else if (gApp.LoadTextFile(mFilePath, text, true, scope [&] () => { hash = SourceHash.Create(.MD5, text); } ) case .Err)
                {
					if (silentFail)
					{
						Close();
						return false;
					}

					mEditWidget.mEditWidgetContent.mIsReadOnly = true;
                    FileOpenFailed();
                }
				else
				{
	                IDEApp.sApp.mFileWatcher.FileIsValid(mFilePath);

	                mEditWidget.Content.AppendText(text);

					using (gApp.mMonitor.Enter())
					{
		                if ((mEditData != null) && (!mEditData.mSavedCharIdData.IsEmpty))
		                {
		                    int char8IdDataLength = mEditData.mSavedCharIdData.GetTotalLength();
		                    if (char8IdDataLength == mEditWidget.Content.mData.mTextLength)
		                    {
		                        // The saved char8IdData matches the length of our text, so we can use it
		                        //  This is important for text mapping after a tab has been closed and then 
		                        //  the files is reopened
		                        mEditWidget.Content.mData.mTextIdData.DuplicateFrom(ref mEditData.mSavedCharIdData);
		                    }
		                }
					}

	                //mLastFileTextVersion = mEditWidget.Content.mData.mCurTextVersionId;
				}
            }
			else
			{
				//LoadedHash = useFileEditData.mLoadedHash;

				// Sanity check for when we have the saved data cached already
				if (useFileEditData.IsFileDeleted())
				{
					if (silentFail)
					{
						Close();
						return false;
					}

					FileOpenFailed();
				}
			}

			CheckBinary();

 			InitSplitter();

			if ((mEditData != null) && (mFilePath != null))
				Debug.Assert(Path.Equals(mFilePath, mEditData.mFilePath));
			mLastRecoveryTextVersionId = mEditWidget.Content.mData.mCurTextVersionId;

            return true;
        }

		public void RehupAlias()
		{
			if ((gApp.mDebugger.mIsRunning) && (mAliasFilePath != null))
			{
				gApp.mDebugger.SetAliasPath(mAliasFilePath, mFilePath);
			}
		}

		void BrowseForFile()
		{
#if !CLI
			var fileDialog = scope System.IO.OpenFileDialog();
			

			var initialDir = scope String(IDEApp.sApp.mWorkspace.mDir);
			//initialDir.Replace('/', '\\');

			var fileName = scope String();
			Path.GetFileName(mFilePath, fileName);

			var title = scope String();
			title.AppendF("Open {0}", fileName);
			fileDialog.Title = title;
			fileDialog.Multiselect = false;

			var ext = scope String();
			Path.GetExtension(mFilePath, ext);

			fileDialog.InitialDirectory = initialDir;
			fileDialog.ValidateNames = true;
			fileDialog.DefaultExt = ext;

			var filter = scope String();
			filter.AppendF("{0}|{0}|All files (*.*)|*.*", fileName, ext);

			fileDialog.SetFilter(filter);
			mWidgetWindow.PreModalChild();
			if (fileDialog.ShowDialog(gApp.GetActiveWindow()).GetValueOrDefault() == .OK)
			{
			    for (String filePath in fileDialog.FileNames)
			    {
					mFilePath.Set(filePath);
					RehupAlias();
					RetryLoad();
					break;
			    }
			}
#endif
		}

		void FileOpenFailed()
		{
			bool fileFromNetwork = mOldVerLoadCmd?.StartsWith("http", .OrdinalIgnoreCase) == true;

			mLoadFailed = true;
			//mLastFileTextVersion = mEditWidget.Content.mData.mCurTextVersionId;
			mPanelHeader = new PanelHeader();
			String fileName = scope String();
			Path.GetFileName(mFilePath, fileName);
			String headerStr = scope String();
			headerStr.AppendF("Source file '{0}' is unavailable. ", fileName);
			if (fileFromNetwork)
				headerStr.Append("Failed to retrieve from network.");
			else
				headerStr.AppendF("Requested path is '{0}'", mFilePath);
			mPanelHeader.Label = headerStr;
			if (!sPreviousVersionWarningShown)
			{
			    mPanelHeader.Flash();
			    sPreviousVersionWarningShown = true;
			}

			bool hasBookmarks = false;
			bool hasBreakpoints = false;

			var trackedElements = GetTrackedElementList();
			for (var element in trackedElements)
			{
				hasBookmarks |= element.mTrackedElement is Bookmark;
				hasBreakpoints |= element.mTrackedElement is Breakpoint;
			}

			if (hasBookmarks)
			{
				var button = mPanelHeader.AddButton("Remove Bookmarks");
				button.mOnMouseClick.Add(new (evt) =>
					{
						button.mVisible = false;
						var trackedElements = GetTrackedElementList();
						for (var element in trackedElements)
						{
							if (var bookmark = element.mTrackedElement as Bookmark)
							{
								gApp.mBookmarkManager.DeleteBookmark(bookmark);
							}
						}
					});
			}

			if (fileFromNetwork)
			{
				var button = mPanelHeader.AddButton("Retry");
				button.mOnMouseClick.Add(new (evt) =>
					{
						LoadOldVer();
					});
			}
			else
			{
				var button = mPanelHeader.AddButton("Retry");
				button.mOnMouseClick.Add(new (evt) =>
				    {
						Reload();
				    });
	
				button = mPanelHeader.AddButton("Auto Find");
				button.mOnMouseClick.Add(new (evt) =>
				    {
						AutoFind();
				    });
			}

			var button = mPanelHeader.AddButton("Browse...");
			button.mOnMouseClick.Add(new (evt) =>
			    {
					BrowseForFile();
			    });

			mPanelHeader.Flash();
			AddWidget(mPanelHeader);
		}

		void AutoFind()
		{
			delete mSourceFindTask;
			mSourceFindTask = new SourceFindTask();
			mSourceFindTask.mSourceViewPanel = this;
			mSourceFindTask.mFilePath = new String(mFilePath);
			mSourceFindTask.mFileName = new String();
			Path.GetFileName(mFilePath, mSourceFindTask.mFileName);

			gApp.WithSourceViewPanels(scope (sourceViewPanel) =>
				{
					if (sourceViewPanel.mAliasFilePath != null)
					{
						var origDir = scope String();
						Path.GetDirectoryPath(sourceViewPanel.mAliasFilePath, origDir);
						IDEUtils.FixFilePath(origDir);
						if (!Environment.IsFileSystemCaseSensitive)
							origDir.ToUpper();

						var localDir = scope String();
						Path.GetDirectoryPath(sourceViewPanel.mFilePath, localDir);

						if (mSourceFindTask.mRemapMap.TryAdd(origDir, var keyPtr, var valuePtr))
						{
							*keyPtr = new String(origDir);
							*valuePtr = new String(localDir);
						}
					}
				});

			ThreadPool.QueueUserWorkItem(new => mSourceFindTask.Run);

			CloseHeader();

			mPanelHeader = new PanelHeader();
			String fileName = scope String();
			Path.GetFileName(mFilePath, fileName);
			String headerStr = scope String();
			headerStr.AppendF("Finding {0}...", fileName);
			mPanelHeader.Label = headerStr;

			var button = mPanelHeader.AddButton("Cancel");
			button.mOnMouseClick.Add(new (evt) =>
				{
					mSourceFindTask.Cancel();
				});
			
			mPanelHeader.mButtonsOnBottom = true;
			
			AddWidget(mPanelHeader);
			ResizeComponents();
		}

		public void ShowWrongHash()
		{
			CloseHeader();

			mPanelHeader = new PanelHeader();
			mPanelHeader.mKind = .WrongHash;
			String fileName = scope String();
			Path.GetFileName(mFilePath, fileName);
			String headerStr = scope String();
			headerStr.AppendF("Warning: This file is not an exact match for the file this program was built with", fileName);
			mPanelHeader.Label = headerStr;

			var button = mPanelHeader.AddButton("Ok");
			button.mOnMouseClick.Add(new (evt) =>
				{
					CloseHeader();
				});

			button = mPanelHeader.AddButton("Browse...");
			button.mOnMouseClick.Add(new (evt) =>
				{
					BrowseForFile();
				});

			mPanelHeader.mButtonsOnBottom = true;

			AddWidget(mPanelHeader);
			ResizeComponents();
		}

		public void SetLoadCmd(String loadCmd)
		{
			bool isRepeat = mOldVerLoadCmd != null;

			CloseHeader();
			
			if (mOldVerLoadCmd == null)
				mOldVerLoadCmd = new String(loadCmd);

			if (loadCmd.StartsWith("http", .OrdinalIgnoreCase))
			{
				LoadOldVer();
				return;
			}
			// For testing a long command...
			//mOldVerLoadCmd.Set("/bin/sleep.exe 10");

			mPanelHeader = new PanelHeader();

			String fileName = scope String();
			Path.GetFileName(mFilePath, fileName);
			String headerStr = scope String();
			if (isRepeat)
				headerStr.AppendF("{0} Failed to retrieve file '{1}'.{2} The following command can be rerun to retry:\n{3}\nWARNING: This is a security risk if this PDB comes from an untrusted source.", Font.EncodeColor(0xFFFF8080), fileName, Font.EncodePopColor(), mOldVerLoadCmd);
			else
				headerStr.AppendF("The file '{0}' can be loaded from a source server by executing the embedded command:\n{1}\nWARNING: This is a security risk if this PDB comes from an untrusted source.", fileName, mOldVerLoadCmd);
			mPanelHeader.Label = headerStr;
			mPanelHeader.mTooltipText = new String(mOldVerLoadCmd);

			var button = mPanelHeader.AddButton("Run");
			button.mOnMouseClick.Add(new (evt) =>
				{
					LoadOldVer();
				});
			button = mPanelHeader.AddButton("Always Run");
			button.mOnMouseClick.Add(new (evt) =>
				{
					LoadOldVer();
				});

			let checkbox = new BoundCheckbox(ref gApp.mStepOverExternalFiles);
			checkbox.Label = "Step over external files";
			mPanelHeader.AddWidget(checkbox);
			checkbox.mOnValueChanged.Add(new () => { gApp.RehupStepFilters(); });

			mPanelHeader.mOnResized.Add(new (widget) =>
				{
					checkbox.Resize(GS!(10), GS!(60), checkbox.CalcWidth(), GS!(20));
				});

			//button = mPanelHeader.AddButton("Run On This ");
			//button = mPanelHeader.AddButton("Never Run");

			mPanelHeader.mButtonsOnBottom = true;
			mPanelHeader.mBaseHeight = 84;
			AddWidget(mPanelHeader);
			ResizeComponents();
		}

		void LoadOldVer()
		{
			if (mOldVerLoadCmd.StartsWith("http", .OrdinalIgnoreCase))
			{
				DeleteAndNullify!(mOldVerHTTPRequest);
				mOldVerHTTPRequest = new HTTPRequest();
				mOldVerHTTPRequest.GetFile(mOldVerLoadCmd, mFilePath);
			}
			else
			{
				Debug.Assert(mOldVerLoadExecutionInstance == null);
				mOldVerLoadExecutionInstance = gApp.DoRun(null, mOldVerLoadCmd, gApp.mInstallDir, .None);
				mOldVerLoadExecutionInstance?.mAutoDelete = false;
			}

			CloseHeader();

			mPanelHeader = new PanelHeader();
			String fileName = scope String();
			Path.GetFileName(mFilePath, fileName);
			String headerStr = scope String();
			headerStr.AppendF("Retrieving {0} via command: {1}", fileName, mOldVerLoadCmd);
			mPanelHeader.Label = headerStr;
			mPanelHeader.mTooltipText = new String(mOldVerLoadCmd);

			var button = mPanelHeader.AddButton("Cancel");
			button.mOnMouseClick.Add(new (evt) =>
				{
					if (mOldVerLoadExecutionInstance != null)
						mOldVerLoadExecutionInstance.Cancel();
					if (mOldVerHTTPRequest != null)
					{
						DeleteAndNullify!(mOldVerHTTPRequest);
					}
				});
			button = mPanelHeader.AddButton("Always Run");
			button.mOnMouseClick.Add(new (evt) =>
				{
					LoadOldVer();
				});
			//button = mPanelHeader.AddButton("Run On This ");
			//button = mPanelHeader.AddButton("Never Run");

			mPanelHeader.mButtonsOnBottom = true;
			//mPanelHeader.mBaseHeight = 72;
			AddWidget(mPanelHeader);
			ResizeComponents();
		}

		void InitSplitter()
		{
			if (mEmbedKind != .None)
				return;

			mSplitter = new PanelSplitter(mSplitTopPanel, this);
			mSplitter.mSplitAction = new => SplitView;
			mSplitter.mUnsplitAction = new => UnsplitView;
			AddWidget(mSplitter);
		}

        public void Reload_Old()
        {
            var text = scope String();
            if (gApp.LoadTextFile(mFilePath, text) case .Err)
            {
                gApp.Fail(scope String()..AppendF("Failed to open file '{0}'", mFilePath));
                return;
            }

            //mEditWidget.Content.ClearText();

            int line;
            int lineChar;
            mEditWidget.Content.GetCursorLineChar(out line, out lineChar);
            //float vertPos = mEditWidget.mVertPos.v;

            text.Replace("\r", "");

            var replaceSourceAction = new ReplaceSourceAction(mEditWidget.Content, text, true);
            mEditWidget.Content.mData.mUndoManager.Add(replaceSourceAction);
            replaceSourceAction.Redo();

            //replaceSourceActionClearTrackedElements();

            //UndoBatchStart undoBatchStart = new UndoBatchStart("reload");
            //mEditWidget.Content.mUndoManager.Add(undoBatchStart);
            //mEditWidget.Content.SelectAll();
            //mEditWidget.Content.DeleteSelection();
            //mEditWidget.Content.InsertAtCursor(text);


            /*mEditWidget.Content.MoveCursorTo(line, lineChar, true);
            mEditWidget.VertScrollTo(vertPos);            

            mEditWidget.mVertPos.mPct = 1.0f;
            mEditWidget.UpdateContentPosition();*/

            QueueFullRefresh(false);

            //mLastFileTextVersion = mEditWidget.Content.mData.mCurTextVersionId;
        }

        /*struct TextLineSegment
        {
            public int mIndex;
            public int mLength;
            public String mLine;
        }*/

        public void Reload()
        {
			bool needsFreshLoad = mLoadFailed;
			if ((mEditData != null) && (!Path.Equals(mFilePath, mEditData.mFilePath)))
			{
				// This can happen if we do an Auto Find for source, which finds an incorrect file but then we Browse
				// to the correct version
				CloseEdit();
				needsFreshLoad = true;
			}

			//TODO: Why did we ClearTrackedElements here? It caused reloads to not move breakpoints and stuff...
			//ClearTrackedElements();

			if (needsFreshLoad)
			{
				Show(mFilePath);
				ResizeComponents();
				return;
			}

			var editWidgetContent = (SourceEditWidgetContent)mEditWidget.mEditWidgetContent;
			Debug.Assert(!editWidgetContent.mIgnoreSetHistory);
			editWidgetContent.mIgnoreSetHistory = true;
			if (mEditData != null)
			{
				mEditData.Reload();
				gApp.FileChanged(mEditData);
			}
			else
			{
				editWidgetContent.Reload(mFilePath);
			}
			editWidgetContent.mIgnoreSetHistory = false;

			if (mEmitRevision == -1) // This causes a rehup loop if there's an emission error if we don't do this check
				QueueFullRefresh(false);
#if IDE_C_SUPPORT
			mClangSourceChanged = false;
#endif
			//mLastFileTextVersion = mEditWidget.Content.mData.mCurTextVersionId;
			if (mEditData != null)
			    mEditData.mLastFileTextVersion = mEditWidget.Content.mData.mCurTextVersionId;

			CheckBinary();
        }

		void CheckAdjustFile()
		{
			var wantHash = mWantHash;
			if (wantHash case .None)
			{
				if (mEditData != null)
				{
					if (!mEditData.mSHA256Hash.IsZero)
						wantHash = .SHA256(mEditData.mSHA256Hash);
					else if (!mEditData.mMD5Hash.IsZero)
						wantHash = .MD5(mEditData.mMD5Hash);
				}
			}

			if (wantHash case .None)
				return;

			String text = scope .();
			if (File.ReadAllText(mFilePath, text, true) case .Err)
				return;
			
			SourceHash textHash = SourceHash.Create(wantHash.GetKind(), text);
			if (textHash == wantHash)
				return;

			if (text.Contains('\r'))
			{
				text.Replace("\r", "");
			}
			else
			{
				text.Replace("\n", "\r\n");
			}
			textHash = SourceHash.Create(wantHash.GetKind(), text);
			if (textHash == wantHash)
			{
				if (File.WriteAllText(mFilePath, text) case .Err)
				{
					gApp.mFileWatcher.OmitFileChange(mFilePath, text);
					return;
				}
			}
		}

		void RetryLoad()
		{
			CloseHeader();

			Reload();
			if (mRequestedLineAndColumn != null)
				ShowFileLocation(-1, mRequestedLineAndColumn.Value.mLine, mRequestedLineAndColumn.Value.mColumn, .Always);
			FocusEdit();

			if ((!(mWantHash case .None)) && (mEditData != null) && (!mEditData.CheckHash(mWantHash)))
				ShowWrongHash();

			if (!mLoadFailed)
			{
				gApp.RehupStepFilters();
			}
		}

		public void RefusedReload()
		{
			if (mEditData != null)
			{
				mEditData.mHadRefusedFileChange = true;
				DeleteAndNullify!(mEditData.mQueuedContent);
			}
		}

        public bool Show(ProjectItem projectItem, bool silentFail = false)
        {
            mProjectSource = (ProjectSource)projectItem;
            if (projectItem is ProjectSource)            
			{
				var fullPath = scope String();
				mProjectSource.GetFullImportPath(fullPath);
                return Show(fullPath, silentFail);
			}
            return false;
        }        

		public void PathChanged(String path)
		{
			if (mFilePath != null)            
				IDEApp.sApp.mFileWatcher.RemoveWatch(mFilePath);
			mFilePath.Set(path);
			IDEApp.sApp.mFileWatcher.WatchFile(path);
			mWantsFullRefresh = true;

			bool wasSource = mIsBeefSource;
			mIsBeefSource = IDEApp.IsBeefFile(mFilePath);
			mIsSourceCode = IDEApp.IsSourceCode(mFilePath);

			if ((!mIsSourceCode) && (wasSource))
			{
				var ewd = mEditWidget.mEditWidgetContent.mData;
				for (int i < ewd.mTextLength)
				{
					ewd.mText[i].mDisplayFlags = 0;
					ewd.mText[i].mDisplayTypeId = 0;
				}
			}
			MarkDirty();
		}

		public void SplitView()
		{
			if (mPanelHeader != null)
				return;

			if (mSplitTopPanel != null)
				return;

			if ((mProjectSource == null) && (mFilePath == null))
			{
				//TODO: We don't allow splitting of new files
				return;
			}
			
			// User requested from menu
			if (mSplitter.mSplitPct <= 0)
				mSplitter.mSplitPct = 0.3f;

			mSplitTopPanel = new SourceViewPanel();
			mSplitTopPanel.mSplitBottomPanel = this;			
			mSplitter.mTopPanel = mSplitTopPanel;

			if (mProjectSource != null)
				mSplitTopPanel.Show(mProjectSource);
			else
				mSplitTopPanel.Show(mFilePath, false, mEditData);
			mSplitTopPanel.mDesiredVertPos = mEditWidget.mVertPos.v;
			mSplitTopPanel.Content.CursorLineAndColumn = Content.CursorLineAndColumn;

			QueueFullRefresh(false);
			mSplitTopPanel.QueueFullRefresh(false);

			AddWidget(mSplitTopPanel);			

			var ewc = (SourceEditWidgetContent)mEditWidget.mEditWidgetContent;
			var topEWC = (SourceEditWidgetContent)mSplitTopPanel.mEditWidget.mEditWidgetContent;

			for (var entry in ewc.mOrderedCollapseEntries)
			{
				if (!entry.mIsOpen)
				{
					topEWC.SetCollapseOpen(@entry.Index, false, true);
				}
			}
			topEWC.RehupLineCoords();

			ResizeComponents();

			// Match scroll positions			
			//mSplitTopPanel.mEditWidget.UpdateScrollbars();
			//mSplitTopPanel.mEditWidget.mVertScrollbar.ScrollTo(mEditWidget.mVertPos.v);
			//mSplitTopPanel.Content.CursorLineAndColumn = Content.CursorLineAndColumn;
		}

		public void UnsplitView()
		{
			//Debug.WriteLine("UnsplitView {0}\n", this);

			mSplitter.mTopPanel = null;
			mSplitTopPanel.Dispose();
			Widget.RemoveAndDelete(mSplitTopPanel);
			mSplitTopPanel = null;

			ResizeComponents();
		}

        void ShowOld(SourceViewPanel sourceViewPanel, int hotFileIdx)
        {
            mEditWidget = IDEApp.sApp.CreateSourceEditWidget();
            SetupEditWidget();

            var sourceEditWidgetContent = (SourceEditWidgetContent)mEditWidget.Content;

            sourceEditWidgetContent.SetOldVersionColors(true);

            String.NewOrSet!(mFilePath, sourceViewPanel.mFilePath);
            // We don't set mProjectSource because we don't want to actually perform a Classify, since
            //  this old version will reference NEW class info, which is a version mismatch
            //  mProjectSource = sourceViewPanel.mProjectSource;
            mIsSourceCode = sourceViewPanel.mIsSourceCode;
            mIsBeefSource = sourceViewPanel.mIsBeefSource;
            mJustShown = true;
            mWantsFullClassify = true;
            mWantsFullClassify = true;

            var projectSourceCompileInstance = IDEApp.sApp.mWorkspace.GetProjectSourceCompileInstance(sourceViewPanel.mProjectSource, hotFileIdx);
            mEditWidget.Content.AppendText(projectSourceCompileInstance.mSource);
            Debug.Assert(mEditWidget.Content.mData.mTextLength == projectSourceCompileInstance.mSource.Length);
            mEditWidget.Content.mData.mTextIdData.DuplicateFrom(ref projectSourceCompileInstance.mSourceCharIdData);
            mEditWidget.Content.mIsReadOnly = true;
            mHotFileIdx = hotFileIdx;
            mIsOldCompiledVersion = mHotFileIdx < IDEApp.sApp.mWorkspace.GetHighestCompileIdx();
			mCurrentVersionPanel = sourceViewPanel;

            mPanelHeader = new PanelHeader();
            if (mIsOldCompiledVersion)
                mPanelHeader.Label = "A previous version of this method is currently executing.  The new version will be used when next called.";
            else
                mPanelHeader.Label = "This method has changed since compiling.  Recompile to hot swap changes.";
            if (!sPreviousVersionWarningShown)
            {
                mPanelHeader.Flash();
                sPreviousVersionWarningShown = true;
            }
            var button = mPanelHeader.AddButton("Show &Current");
	        button.mOnMouseClick.Add(new (evt) =>
	            {
					ShowCurrent();
	                /*var app = IDEApp.sApp;
	                int callStackIdx = app.mDebugger.mSelectedCallStackIdx;
					float scrollTopDelta = mEditWidget.Content.GetCursorScreenRelY();
					bool isPaused = app.mDebugger.IsPaused();
	
					// Do another setPCLocation to make sure our cursor is at the PC position
					if (isPaused)
		                app.ShowPCLocation(callStackIdx, true);	
	                sourceViewPanel.mJustShown = true;
	                sourceViewPanel.CloseOldVersion();
					if (isPaused)
	                	app.ShowPCLocation(callStackIdx, true);
	                sourceViewPanel.mEditWidget.Content.SetCursorScreenRelY(scrollTopDelta + mPanelHeader.mHeight);*/
	            });
            AddWidget(mPanelHeader);

			InitSplitter();
        }

		public void ShowCurrent()
		{
			if (mOldVersionPanel != null)
			{
				mOldVersionPanel.ShowCurrent();
				return;
			}
			if (mCurrentVersionPanel == null)
				return;

			var app = IDEApp.sApp;
			int32 callStackIdx = app.mDebugger.mActiveCallStackIdx;
			float scrollTopDelta = mEditWidget.Content.GetCursorScreenRelY();
			bool isPaused = app.mDebugger.IsPaused();

			// Do another setPCLocation to make sure our cursor is at the PC position
			if (isPaused)
			    app.ShowPCLocation(callStackIdx, true);	
			mCurrentVersionPanel.mJustShown = true;
			mCurrentVersionPanel.CloseOldVersion();
			if (isPaused)
				app.ShowPCLocation(callStackIdx, true);
			mCurrentVersionPanel.mEditWidget.Content.SetCursorScreenRelY(scrollTopDelta + mPanelHeader.mHeight);
		}

        void CloseOldVersion()
        {
			if (mEditWidget == null)
			{
				// What to do?
			}	

            if (mOldVersionPanel != null)
            {
				if (mEditWidget != null)
                	mEditWidget.mVisible = true;
                if (mOldVersionPanel.mParent != null)
                    mOldVersionPanel.RemoveSelf();
                mOldVersionPanel.Dispose();
				BFApp.sApp.DeferDelete(mOldVersionPanel);
				//delete mOldVersionPanel;
                mOldVersionPanel = null;
				if (mWidgetWindow != null)
				{
					FocusEdit();
					ResizeComponents();
				}
            }
        }        

        public void ShowHotFileIdx(int hotFileIdx)
        {
			if (mLoadFailed)
				return;

            bool isOldCompiledVersion = (hotFileIdx != -1) && (hotFileIdx < IDEApp.sApp.mWorkspace.GetHighestCompileIdx());
            if ((mOldVersionPanel != null) && (mOldVersionPanel.mHotFileIdx == hotFileIdx) && (mOldVersionPanel.mIsOldCompiledVersion == isOldCompiledVersion))
                return;
            CloseOldVersion();
            //if (hotFileIdx != -1)
			if (isOldCompiledVersion)
            {
                mEditWidget.mVisible = false;
                mOldVersionPanel = new SourceViewPanel();
                if (mProjectSource != null)
                {
                    mOldVersionPanel.ShowOld(this, hotFileIdx);
                    AddWidget(mOldVersionPanel);
                    mOldVersionPanel.FocusEdit();
                    ResizeComponents();
                }
            }          
        }

        public void GetCursorPosition(out int32 line, out int32 column)
        {
            var lineAndCol = mEditWidget.Content.CursorLineAndColumn;
            line = lineAndCol.mLine;
            column = lineAndCol.mColumn;
        }

		int GetDrawLineNum(Breakpoint breakpoint)
		{
			int breakpointLineNum;

			/*if (mIsBeefSource)
				breakpointLineNum = breakpoint.GetLineNum();
			else
				breakpointLineNum = breakpoint.mLineNum;*/
			// Why did we have "mIsBeefSource" check? This broke our ability to 'move' the breakpoint down
			//  onto the actual executable line
			breakpointLineNum = breakpoint.GetLineNum();

			int drawLineNum = breakpointLineNum;
			
			// We want to use "IsBound" instead of "HasNativeBreakpoint" because otherwise when we hot-create a new method
			//  and then put a breakpoint on it then it'll remap as if it was bound
			if ((mIsBeefSource) && (breakpoint.mNativeBreakpoint != null))
			{
				int compileIdx = gApp.mWorkspace.GetHighestSuccessfulCompileIdx();
				//drawLineNum = RemapCompiledToActiveLine(/*breakpoint.mLineNum*/breakpointLineNum);
				if (compileIdx != -1)
				{
					int drawLineColumn = 0;
					RemapCompiledToActiveLine(compileIdx, ref drawLineNum, ref drawLineColumn);
					if (mHotFileIdx != -1)
					{
						drawLineNum = RemapActiveLineToHotLine(drawLineNum);
					}
				}
			}
			return drawLineNum;
		}

        public Breakpoint ToggleBreakpointAtCursor(Breakpoint.SetKind setKind = .Toggle, Breakpoint.SetFlags flags = .None, int threadId = -1)
        {
			var activePanel = GetActivePanel();
			if (activePanel != this)
				return activePanel.ToggleBreakpointAtCursor(setKind, flags, threadId);

            if (mOldVersionPanel != null)
            {                
                return null;
            }

			int lineIdx;
			int lineCharIdx;
			mEditWidget.Content.GetLineCharAtIdx(mEditWidget.Content.CursorTextPos, out lineIdx, out lineCharIdx);
			return ToggleBreakpointAt(lineIdx, lineCharIdx, setKind, flags, threadId);
		}

		public Breakpoint ToggleBreakpointAt(int lineIdx, int lineCharIdx, Breakpoint.SetKind setKind = .Toggle, Breakpoint.SetFlags flags = .None, int threadId = -1)
		{
			var lineIdx;
			var lineCharIdx;

            DebugManager debugManager = IDEApp.sApp.mDebugger;

			HashSet<Breakpoint> breakpoints = scope .();

            bool hadBreakpoint = false;
			if (setKind != .Force)
			{
	            /*WithTrackedElementsAtCursor<Breakpoint>(IDEApp.sApp.mDebugger.mBreakpointList, scope [&] (breakpoint) =>
	                {
						BfLog.LogDbg("SourceViewPanel.ToggleBreakpointAtCursor deleting breakpoint\n");
	                    debugManager.DeleteBreakpoint(breakpoint);
	                    hadBreakpoint = true;
	                });*/

				for (var breakpointView in GetTrackedElementList())
				{
					var trackedElement = breakpointView.mTrackedElement;
					if (var breakpoint = trackedElement as Breakpoint)
					{
						int drawLineNum = GetDrawLineNum(breakpoint);
						if (drawLineNum == lineIdx)
						{
							hadBreakpoint = true;
							if (setKind == .Toggle)
							{
								BfLog.LogDbg("SourceViewPanel.ToggleBreakpointAtCursor deleting breakpoint\n");
								debugManager.DeleteBreakpoint(breakpoint);
							}
							else
								breakpoints.Add(breakpoint);
						}
					}
				}
			}

			Breakpoint newBreakpoint = null;
            if ((!hadBreakpoint) && (setKind != .MustExist))
            {
				RecordHistoryLocation();

                var editWidgetContent = mEditWidget.Content;
                int textPos = mEditWidget.Content.CursorTextPos - lineCharIdx;
                lineCharIdx = 0;

                // Find first non-space char
                while ((textPos < editWidgetContent.mData.mTextLength) && (((char8)editWidgetContent.mData.mText[textPos].mChar).IsWhiteSpace))
                {
                    textPos++;
                    lineCharIdx++;
                }

				int requestedActiveLineIdx = lineIdx;
                int curCompileIdx = IDEApp.sApp.mWorkspace.GetHighestCompileIdx();
                bool foundPosition = false;
				if (gApp.mDebugger.mIsRunning)
                	foundPosition = RemapActiveToCompiledLine(curCompileIdx, ref lineIdx, ref lineCharIdx);
				bool createNow = foundPosition || !mIsBeefSource; // Only be strict about Beef source

				String filePath = mAliasFilePath ?? mFilePath;
				if (filePath == null)
					return null;
                newBreakpoint = debugManager.CreateBreakpoint_Create(filePath, lineIdx, lineCharIdx, -1);
				newBreakpoint.mThreadId = threadId;
				debugManager.CreateBreakpoint_Finish(newBreakpoint, createNow);
                int newDrawLineNum = GetDrawLineNum(newBreakpoint);

                if (setKind != .Force)
				{
	                for (int32 breakIdx = 0; breakIdx < IDEApp.sApp.mDebugger.mBreakpointList.Count; breakIdx++)
	                {
	                    var checkBreakpoint = IDEApp.sApp.mDebugger.mBreakpointList[breakIdx];
	                    if ((checkBreakpoint != newBreakpoint) && 
	                        (checkBreakpoint.mFileName == newBreakpoint.mFileName))
	                    {
							int checkDrawLineNum = GetDrawLineNum(checkBreakpoint);
							if (checkDrawLineNum == newDrawLineNum)
							{
								BfLog.LogDbg("SourceViewPanel.ToggleBreakpointAtCursor duplicate breakpoint.  Deleting breakpoint\n");

		                        // This ended up on the same line as another breakpoint after binding. Hilite the other breakpoint to show there's already one there.
		                        debugManager.DeleteBreakpoint(newBreakpoint);
								newBreakpoint = null;
								var ewc = mEditWidget.mEditWidgetContent;
								LocatorAnim.Show(.Always, mEditWidget, ewc.mX + -GS!(15), ewc.mY + newDrawLineNum * ewc.GetLineHeight(0) + GS!(12));

								breakpoints.Add(checkBreakpoint);
								break;
							}
	                    }
	                }
				}

				// If we are hot compiling, and the binding of the breakpoint moves the breakpoint (down a few lines presumably), but the text between
				//  the requested position and the bound position has had changes that haven't been compiled in yet, then we undo the binding so we can
				//  rebind when we complete the hot compile
				if ((newBreakpoint != null) && (gApp.mDebugger.mIsRunning) && (mIsBeefSource) && (mProjectSource != null))
				{
					int boundLineNum = newBreakpoint.GetLineNum();
					int boundColumn = 0;
					RemapCompiledToActiveLine(curCompileIdx, ref boundLineNum, ref boundColumn);
					if (requestedActiveLineIdx != boundLineNum)
					{
						int startCheckIdx = editWidgetContent.GetTextIdx(requestedActiveLineIdx, 0);
						int endCheckIdx = editWidgetContent.GetTextIdx(boundLineNum, 0);

						var textIdData = editWidgetContent.mData.mTextIdData.GetPrepared();
						int32 startId = textIdData.GetIdAtIndex(startCheckIdx);
						int32 endId = textIdData.GetIdAtIndex(endCheckIdx);

						if (var projectSourceInstance = gApp.mWorkspace.GetProjectSourceCompileInstance(mProjectSource, curCompileIdx))
						{
							if (!textIdData.IsRangeEqual(projectSourceInstance.mSourceCharIdData, startId, endId))
							{
								newBreakpoint.DisposeNative();
								newBreakpoint.mLineNum = (.)requestedActiveLineIdx;
							}
						}
					}
				}

				if (newBreakpoint != null)
					breakpoints.Add(newBreakpoint);
            }

			if (((flags.HasFlag(.Configure)) || (flags.HasFlag(.Disable))) &&
				(!breakpoints.IsEmpty))
			{
				gApp.mBreakpointPanel.Update();
				gApp.mBreakpointPanel.SelectBreakpoints(breakpoints);
				if (flags.HasFlag(.Configure))
					gApp.mBreakpointPanel.ConfigureBreakpoints(mWidgetWindow);
				if (flags.HasFlag(.Disable))
					gApp.mBreakpointPanel.SetBreakpointsDisabled(null);
			}

			return newBreakpoint;
        }

        public void ToggleBookmarkAtCursor()
        {
            if ((mHotFileIdx != -1) || (mOldVersionPanel != null))
                return;
			if (mFilePath == null)
				return;

			var activePanel = GetActivePanel();
			if (activePanel != this)
			{
				activePanel.ToggleBookmarkAtCursor();
				return;
			}

            BookmarkManager bookmarkManager = IDEApp.sApp.mBookmarkManager;

            int lineIdx;
            int lineCharIdx;
            mEditWidget.Content.GetLineCharAtIdx(mEditWidget.Content.CursorTextPos, out lineIdx, out lineCharIdx);

            bool hadBookmark = false;
            
			for (var folder in IDEApp.sApp.mBookmarkManager.mBookmarkFolders)
			{
				WithTrackedElementsAtCursor<Bookmark>(folder.mBookmarkList, scope [&] (bookmark) =>
				    {
				        bookmarkManager.DeleteBookmark(bookmark);
				        hadBookmark = true;
				    });
			}
            
            if (!hadBookmark)
            {
                var editWidgetContent = mEditWidget.Content;
                int textPos = mEditWidget.Content.CursorTextPos - lineCharIdx;
                lineCharIdx = 0;

                // Find first non-space char8
                while ((textPos < editWidgetContent.mData.mTextLength) && (((char8)editWidgetContent.mData.mText[textPos].mChar).IsWhiteSpace))
                {
                    textPos++;
                    lineCharIdx++;
                }

                bookmarkManager.CreateBookmark(mFilePath, lineIdx, lineCharIdx);
            }
        }
        
        void RemapCompiledToActiveLine(int compileInstanceIdx, ref int lineNum, ref int column)
        {
			let projectSource = FilteredProjectSource;
            if (projectSource != null)
            {
                int32 char8Id = IDEApp.sApp.mWorkspace.GetProjectSourceCharId(projectSource, compileInstanceIdx, lineNum, column);                
                int char8Idx = mEditWidget.Content.GetCharIdIdx(char8Id);
                if (char8Idx != -1)
                {
                    mEditWidget.Content.GetLineCharAtIdx(char8Idx, out lineNum, out column);
                }
            }
        }

        bool RemapActiveToCompiledLine(int compileInstanceIdx, ref int lineNum, ref int column)
        {
			var projectSource = FilteredProjectSource;
			if (mIsOldCompiledVersion)
				projectSource = ((SourceViewPanel)mParent).FilteredProjectSource;

            if (projectSource != null)
            {
                int char8Id = mEditWidget.Content.GetSourceCharIdAtLineChar(lineNum, column);
                if (char8Id == 0)
                    return false;
                return IDEApp.sApp.mWorkspace.GetProjectSourceCharIdPosition(projectSource, compileInstanceIdx, char8Id, ref lineNum, ref column);
            }
            return true;
        }

        int RemapActiveLineToHotLine(int line)
        {
            if (mHotFileIdx == -1)
                return line;

            var activePanel = (SourceViewPanel)mParent;
            int32 char8Id = activePanel.mEditWidget.Content.GetSourceCharIdAtLineChar(line, -1);
            if (char8Id == -1)
                return -1;
            int remapIdx = mEditWidget.Content.GetCharIdIdx(char8Id);
            if (remapIdx == -1)
                return -1;
            int remapLine;
            int remapLineChar;
            mEditWidget.Content.GetLineCharAtIdx(remapIdx, out remapLine, out remapLineChar);
            return remapLine;
        }

		enum LineFlags : uint8
		{
			None,
			BreakpointCountMask = 0x7F,
			Boomkmark = 0x80
		}
		
		static float sDrawLeftAdjust = GS!(12);

        public override void Draw(Graphics g)
        {
            base.Draw(g);

            // If we're trying to time autocomplete
            /*var bfSystem = IDEApp.sApp.mBfResolveSystem;
            if (bfSystem.mIsTiming)
            {
                bfSystem.StopTiming();
                bfSystem.DbgPrintTimings();
            }*/

            if (GetOldVersionPanel() != null)
                return;

			if (mLoadFailed)
				return;

            var ewc = (SourceEditWidgetContent)mEditWidget.Content;
			ewc.GetTextData();
			
            g.SetFont(IDEApp.sApp.mTinyCodeFont);

            using (g.PushClip(0, mEditWidget.mY, mWidth, mEditWidget.mHeight - GS!(20)))
            {
                using (g.PushTranslate(0, mEditWidget.mY + mEditWidget.Content.Y + GS!(2)))
                {
					float editX = GetEditX();

					float lineSpacing = ewc.mFont.GetLineSpacing();
					int cursorLineNumber = mEditWidget.mEditWidgetContent.CursorLineAndColumn.mLine;
					bool hiliteCurrentLine = mEditWidget.mHasFocus;

					var jumpEntry = ewc.mLineCoordJumpTable[Math.Clamp((int)(-mEditWidget.Content.Y / ewc.GetJumpCoordSpacing()), 0, ewc.mLineCoordJumpTable.Count - 1)];
					int lineStart = jumpEntry.min;
					jumpEntry = ewc.mLineCoordJumpTable[Math.Clamp((int)((-mEditWidget.Content.Y + mHeight) / ewc.GetJumpCoordSpacing()), 0, ewc.mLineCoordJumpTable.Count - 1)];
					int lineEnd = jumpEntry.max - 1;

					if (ewc.mLineRange != null)
					{
						lineStart = Math.Max(lineStart, ewc.mLineRange.Value.Start);
						lineEnd = Math.Min(lineEnd, ewc.mLineRange.Value.End);
						lineStart = Math.Min(lineStart, lineEnd);
					}

					int drawLineCount = lineEnd - lineStart + 1;

					ewc.RefreshCollapseRegions();
					if ((mCollapseRegionView.mLineStart != lineStart) || (mCollapseRegionView.mCollapseIndices.Count != drawLineCount) ||
						(mCollapseRegionView.mCollapseRevision != ewc.mCollapseParseRevision) || (mCollapseRegionView.mTextVersionId != ewc.mCollapseTextVersionId))
					{
						mCollapseRegionView.mLineStart = (.)lineStart;
						mCollapseRegionView.mCollapseIndices.Clear();
						Internal.MemSet(mCollapseRegionView.mCollapseIndices.GrowUninitialized(drawLineCount), 0, drawLineCount * sizeof(int32));
						mCollapseRegionView.mCollapseRevision = ewc.mCollapseParseRevision;
						mCollapseRegionView.mTextVersionId = ewc.mCollapseTextVersionId;

						List<int32> collapseStack = scope .(16);
						int32 curIdx = 0;
						for (int line in lineStart...lineEnd)
						{
							uint32 indexVal = 0;

							while (curIdx < ewc.mOrderedCollapseEntries.Count)
							{
								var entry = ewc.mOrderedCollapseEntries[curIdx];
								if (entry.mAnchorLine > line)
									break;
								if (!entry.mDeleted)
								{
									indexVal = (uint32)curIdx | CollapseRegionView.cStartFlag;
									collapseStack.Add(curIdx);
								}
								curIdx++;
							}

							while (!collapseStack.IsEmpty)
							{
								var entry = ewc.mOrderedCollapseEntries[collapseStack.Back];
								if (line < entry.mEndLine)
									break;
								if (indexVal == 0)
									indexVal = (uint32)collapseStack.Back | CollapseRegionView.cEndFlag;
								collapseStack.PopBack();
							}

							if ((indexVal == 0) && (!collapseStack.IsEmpty))
								indexVal = (uint32)collapseStack.Back | CollapseRegionView.cMidFlag;
							mCollapseRegionView.mCollapseIndices[line - lineStart] = indexVal;
							
						}
					}

					if ((mMousePos != null) && (mMousePos.Value.x >= mEditWidget.mX - GS!(13)) && (mMousePos.Value.x < mEditWidget.mX - GS!(0)) &&  (mMousePos.Value.y < mHeight - GS!(20)))
					{
						int lineClick = GetLineAt(0, mMousePos.Value.y);
						uint32 collapseVal = mCollapseRegionView.GetCollapseValue(lineClick);
						if (collapseVal != 0)
						{
							var entry = ewc.mOrderedCollapseEntries[collapseVal & CollapseRegionView.cIdMask];
							float startY = ewc.mLineCoords[entry.mAnchorLine];
							float endY = ewc.mLineCoords[entry.mEndLine + 1];

							using (g.PushColor(gApp.mSettings.mUISettings.mColors.mCurrentLineNumberHilite))
								g.FillRect(0, GS!(2) + startY, editX - GS!(10), endY - startY);

							hiliteCurrentLine = false;
						}
					}

					if (hiliteCurrentLine)
					{
						using (g.PushColor(gApp.mSettings.mUISettings.mColors.mCurrentLineNumberHilite))
						{
							int hiliteLineNum = cursorLineNumber;
							while (ewc.IsLineCollapsed(hiliteLineNum))
								hiliteLineNum--;
							g.FillRect(0, GS!(2) + ewc.mLineCoords[hiliteLineNum], editX - GS!(10), lineSpacing);
						}
					}

					if (lineEnd <= lineStart)
					{
						return;
					}

					LineFlags[] lineFlags = scope LineFlags[lineEnd - lineStart];

                    for (var breakpointView in GetTrackedElementList())
                    {
                        var trackedElement = breakpointView.mTrackedElement;
                        var breakpoint = trackedElement as Breakpoint;
                        var bookmark = trackedElement as Bookmark;
                        if (breakpoint != null)
                        {
							int drawLineNum = GetDrawLineNum(breakpoint);
							
							if ((drawLineNum < lineStart) || (drawLineNum >= lineEnd))
								continue;
							if (ewc.IsLineCollapsed(drawLineNum))
								continue;
							var curLineFlags = ref lineFlags[drawLineNum - lineStart];
							int breakpointCount = (.)(curLineFlags & .BreakpointCountMask);
							curLineFlags++;

							float iconX = Math.Max(GS!(-2), mEditWidget.mX - GS!(24) - sDrawLeftAdjust) + breakpointCount*-GS!(2);
							float iconY = 0 + ewc.mLineCoords[drawLineNum] + (lineSpacing - DarkTheme.sUnitSize + GS!(5)) / 2;

							// Just leave last digit visible
							/*using (g.PushColor(0xFF595959))
								g.FillRect(4, iconY, editX - 14, 20);*/

							using (g.PushColor((breakpointCount % 2 == 0) ? 0xFFFFFFFF : 0xFFC0C0C0))
	                            using (g.PushTranslate(iconX, iconY))
	                            {                                
	                                breakpoint.Draw(g, mIsOldCompiledVersion);
	                            }
                        }
                        else if (bookmark != null)
                        {
							
                            if (mHotFileIdx == -1)
							{
								int32 drawLineNum = bookmark.mLineNum;
								if ((drawLineNum < lineStart) || (drawLineNum >= lineEnd))
									continue;
								if (ewc.IsLineCollapsed(drawLineNum))
									continue;

								float iconX = Math.Max(GS!(-5), mEditWidget.mX - GS!(30) - sDrawLeftAdjust);
								float iconY = 0 + ewc.mLineCoords[drawLineNum] + (lineSpacing - DarkTheme.sUnitSize + GS!(5)) / 2;

								Image image = DarkTheme.sDarkTheme.GetImage(bookmark.mIsDisabled ? .IconBookmarkDisabled : .IconBookmark);
                                g.Draw(image, iconX, iconY);

								var curLineFlags = ref lineFlags[drawLineNum - lineStart];
								curLineFlags |= .Boomkmark;
								//FAIL
							}
                        }
                        
                        ////
                        /*var historyEntry = trackedElement as HistoryEntry;
                        if (historyEntry != null)
                        {                                                        
                            if (mHotFileIdx == -1)
                            {
                                float xPos;
                                float yPos;
                                darkEditWidgetContent.GetTextCoordAtLineChar(historyEntry.mLineNum, historyEntry.mColumn, out xPos, out yPos);

                                using (g.PushColor(0x60FFFFFF))
                                    g.Draw(DarkTheme.sDarkTheme.GetImage(DarkTheme.ImageIdx.IconBookmark), mEditWidget.mX + xPos,
                                            0 + historyEntry.mLineNum * lineSpacing);
                            }
                        }*/
                    }

					if ((gApp.mSettings.mEditorSettings.mShowLineNumbers) && (mEmbedKind == .None))
					{
						String lineStr = scope String(16);
						using (g.PushColor(0x80FFFFFF))
						{
						    for (int lineIdx = lineStart; lineIdx < lineEnd; lineIdx++)
						    {
								float drawHeight = ewc.mLineCoords[lineIdx + 1] - ewc.mLineCoords[lineIdx];
								if (drawHeight < lineSpacing * 0.25f)
									continue;

								lineStr.Clear();

								int maxLineChars = Int32.MaxValue;

								let curLineFlags = lineFlags[lineIdx - lineStart];
								if ((uint8)(curLineFlags & .BreakpointCountMask) > 0)
									maxLineChars = 1;
								else if (curLineFlags.HasFlag(.Boomkmark))
									maxLineChars = 2;

								switch (maxLineChars)
								{
								case 0:
								case 1: lineStr.AppendF("{0}", (lineIdx + 1) % 10);
								case 2: lineStr.AppendF("{0}", (lineIdx + 1) % 100);
								default: lineStr.AppendF("{0}", lineIdx + 1);
								}
								using (g.PushColor(DarkTheme.COLOR_TEXT))
						        	g.DrawString(lineStr, 0, GS!(2) + ewc.mLineCoords[lineIdx], FontAlign.Right, editX - GS!(14));
						    }
						}
					}
						
				    for (int lineIdx = lineStart; lineIdx < lineEnd; lineIdx++)
				    {
						int collapseLookup = lineIdx - mCollapseRegionView.mLineStart;
						if ((collapseLookup >= 0) && (collapseLookup < mCollapseRegionView.mCollapseIndices.Count))
						{
							float drawHeight = ewc.mLineCoords[lineIdx + 1] - ewc.mLineCoords[lineIdx];
							if (drawHeight < lineSpacing * 0.25f)
								continue;

							float boxAdjustTop = Math.Floor((lineSpacing - DarkTheme.sUnitSize)/2);
							float boxAdjustBot = Math.Ceiling((lineSpacing - DarkTheme.sUnitSize)/2);

							uint32 collapseIdx = mCollapseRegionView.mCollapseIndices[lineIdx - mCollapseRegionView.mLineStart];
							if ((collapseIdx & CollapseRegionView.cStartFlag) != 0)
							{
								var entry = ewc.mOrderedCollapseEntries[collapseIdx & CollapseRegionView.cIdMask];
								g.Draw(DarkTheme.sDarkTheme.GetImage(entry.mIsOpen ? .CollapseOpened : .CollapseClosed), editX - GS!(16), ewc.mLineCoords[lineIdx] + boxAdjustTop + GS!(2));

								int nextCollapseIdx = (collapseIdx & CollapseRegionView.cIdMask) + 1;
								if ((entry.mIsOpen) && (nextCollapseIdx < ewc.mOrderedCollapseEntries.Count))
								{
									// Draw line between two collapse boxes in a row
									var nextEntry = ewc.mOrderedCollapseEntries[nextCollapseIdx];
									if (nextEntry.mAnchorLine == lineIdx + 1)
									{
										using (g.PushColor(0xFFA5A5A5))
											g.FillRect(editX - (int)GS!(7.5f), ewc.mLineCoords[lineIdx] + boxAdjustTop + (int)GS!(15.5f), (int)GS!(1.5f), (lineSpacing - GS!(10)) + GS!(2));
									}
								}
							}
							else if ((collapseIdx & CollapseRegionView.cEndFlag) != 0)
							{
								using (g.PushColor(0xFFA5A5A5))
								{
									g.FillRect(editX - (int)GS!(7.5f), ewc.mLineCoords[lineIdx] - (int)GS!(0.5f), (int)GS!(1.5f), lineSpacing);
									g.FillRect(editX - (int)GS!(7.5f), ewc.mLineCoords[lineIdx] + lineSpacing - (int)GS!(1.5f), GS!(5), (int)GS!(1.5f));
								}
							}
							else if (collapseIdx != 0)
							{
								using (g.PushColor(0xFFA5A5A5))
								{
									g.FillRect(editX - (int)GS!(7.5f), ewc.mLineCoords[lineIdx] - boxAdjustBot - GS!(5), (int)GS!(1.5f), lineSpacing + boxAdjustBot + boxAdjustTop + (int)GS!(12f));
								}
							}
						}
				    }

                    if (IDEApp.sApp.mExecutionPaused)
                    {
                        int addr;
                        String fileName = scope String(Path.[Friend]MaxPath);
                        int hotIdx;
                        int defLineStart;
                        int defLineEnd;
                        int lineNum;
                        int column;
                        int language;
                        int stackSize;
                        DebugManager.FrameFlags flags;
                        IDEApp.sApp.mDebugger.GetStackFrameInfo(IDEApp.sApp.mDebugger.mActiveCallStackIdx, null, out addr, fileName, out hotIdx, out defLineStart, out defLineEnd, out lineNum, out column, out language, out stackSize, out flags);
                        IDEUtils.FixFilePath(fileName);
						int hashPos = fileName.IndexOf('#');
						if (hashPos != -1)
							fileName.RemoveToEnd(hashPos);
                        if (FileNameMatches(fileName))
                        {                            
                            RemapCompiledToActiveLine(hotIdx, ref lineNum, ref column);
							
                            Image img;
                            if (IDEApp.sApp.mDebugger.mActiveCallStackIdx == 0)
							{
								if (flags.HasFlag(.Optimized))
									img = DarkTheme.sDarkTheme.GetImage(.LinePointer_Opt);
								else
									img = DarkTheme.sDarkTheme.GetImage(.LinePointer);
							}
							else
								img = DarkTheme.sDarkTheme.GetImage(.LinePointer_Prev);

							// If our step/continue doesn't actually change the line-pointer position, then we
							//  want to give just the littlest 'flash' of the cursor to indicate to the user
							//  that something actually happened. The most common case is a breakpoint that
							//  gets hit over and over F5 (continue).
							bool doDraw = false;
							if ((mLinePointerDrawData.mImage != img) ||
								(mLinePointerDrawData.mLine != lineNum))
							{
								mLinePointerDrawData.mImage = img;
								mLinePointerDrawData.mLine = (.)lineNum;
								doDraw = true;
							}
							else if ((mLinePointerDrawData.mDebuggerContinueIdx == gApp.mDebuggerContinueIdx) ||
								(gApp.mUpdateCnt - mLinePointerDrawData.mUpdateCnt >= 3))
							{
								doDraw = true;
							}

							if ((lineNum < lineStart) || (lineNum >= lineEnd))
								doDraw = false;

							if (doDraw)
							{
								mLinePointerDrawData.mUpdateCnt = gApp.mUpdateCnt;
								mLinePointerDrawData.mDebuggerContinueIdx = gApp.mDebuggerContinueIdx;
								g.Draw(img, mEditWidget.mX - GS!(20) - sDrawLeftAdjust,
									0 + ewc.GetLineY(lineNum, 0));
							}

							if (mMousePos != null && mIsDraggingLinePointer)
							{
								int dragLineNum = GetLineAt(0, mMousePos.Value.y);
								if (dragLineNum >= 0 && dragLineNum != lineNum)
								{
									using (g.PushColor(0x7FFFFFFF))
										g.Draw(img, mEditWidget.mX - GS!(20) - sDrawLeftAdjust,
											0 + ewc.GetLineY(dragLineNum, 0));
								}
							}
                        }
                    }
                }
            }

			bool drawLock = (mSplitBottomPanel == null) && (mEmbedKind == .None);
			if (drawLock)
			{
				IDEUtils.DrawLock(g, mEditWidget.mX - GS!(20), mHeight - GS!(20), IsReadOnly, mLockFlashPct);
			}

            /*using (g.PushColor(0x80FF0000))
                g.FillRect(0, 0, mWidth, mHeight);*/
        }

        /*void UpdateCharData()
        {
            var bfSystem = IDEApp.sApp.mBfResolveSystem;
            bfSystem.PerfZoneStart("UpdateCharData");

            // Inject new char8 attributes into text
            uint highestSrcCharId = 0;
            for (int i = 0; i < mProcessingCharData.Length; i++)
            {
                uint char8Id = mProcessingCharData[i].mCharId;
                if (char8Id > highestSrcCharId)
                    highestSrcCharId = char8Id;
            }

            int srcIdx = 0;
            int destIdx = 0;
            var destText = mEditWidget.Content.mText;
            int destTextLength = mEditWidget.Content.mTextLength;
            while ((srcIdx < mProcessingCharData.Length) && (destIdx < destTextLength))
            {
                if (destText[destIdx].mCharId > highestSrcCharId)
                {
                    // This is new text since we did the background compile, skip
                    destIdx++;
                    continue;
                }

                if (mProcessingCharData[srcIdx].mCharId != destText[destIdx].mCharId)
                {
                    // Id doesn't match, character must have been deleted
                    srcIdx++;
                    continue;
                }

                Debug.Assert(destText[destIdx].mChar == mProcessingCharData[srcIdx].mChar);

                if (destText[destIdx].mDisplayPassId == (byte)SourceDisplayId.AutoComplete)
                {
                    // Autocomplete beat us to it
                    destText[destIdx].mDisplayPassId = (byte)SourceDisplayId.Cleared;                    
                }
                else
                {
                    byte prevFlags = destText[destIdx].mDisplayFlags;
                    destText[destIdx] = mProcessingCharData[srcIdx];
                    destText[destIdx].mDisplayFlags = (byte)
                        ((prevFlags & (byte)SourceElementFlags.EditorFlags_Mask) |
                        (destText[destIdx].mDisplayFlags & (byte)SourceElementFlags.CompilerFlags_Mask));                    
                }
                srcIdx++;
                destIdx++;                    
            }            

            mProcessingCharData = null;            

            bfSystem.PerfZoneEnd();
        }*/

        void UpdateCharData(ref EditWidgetContent.CharData[] charData, ref IdSpan charIdData, uint8 replaceFlags, bool flagsOnly)
        {
			//Debug.WriteLine("UpdateCharData: {0}", char8Data);

			if (mEditWidget == null)
				return;

			scope AutoBeefPerf("SourceViewPanel.UpdateCharData");

			charIdData.Prepare();
			var editTextIdData = ref mEditWidget.Content.mData.mTextIdData;
			editTextIdData.Prepare();

            // Inject new char8 attributes into text
            int32 highestSrcCharId = 0;
            int32 srcCharId = 1;

            //string dbgStr = "";
            int srcEncodeIdx = 0;
            //dbgStr += "Src: ";
            while (true)
            {
                int32 cmd = Utils.DecodeInt(charIdData.mData, ref srcEncodeIdx);                                
                if (cmd > 0)
                {
                    srcCharId = cmd;
                }
                else
                {
                    srcCharId += -cmd;
                    highestSrcCharId = Math.Max(highestSrcCharId, srcCharId - 1);
                    if (cmd == 0)
                        break;
                }
                //dbgStr += " " + cmd;                
            }

            int destEncodeIdx = 0;
            /*dbgStr += "  Dest: ";
            while (true)
            {
                int cmd = Utils.DecodeInt(mProcessCharIdData, ref destEncodeIdx);
                if (cmd == 0)
                    break;
                dbgStr += " " + cmd;                
            }*/
            //Debug.WriteLine(dbgStr);

            int32 srcIdx = 0;
            int32 destIdx = 0;
            var destText = mEditWidget.Content.mData.mText;
            int32 destTextLength = mEditWidget.Content.mData.mTextLength;

            srcEncodeIdx = 0;            
            int32 srcSpanLeft = 0;
            srcCharId = 1;
            destEncodeIdx = 0;
            int32 destSpanLeft = 0;
            int32 destCharId = 1;

            while ((srcIdx < charData.Count) && (destIdx < destTextLength))
            {
                while (srcSpanLeft == 0)
                {
                    int32 cmd = Utils.DecodeInt(charIdData.mData, ref srcEncodeIdx);
                    if (cmd > 0)
                        srcCharId = cmd;
                    else
                        srcSpanLeft = -cmd;
                }

                while (destSpanLeft == 0)
                {
                    int32 cmd = Utils.DecodeInt(editTextIdData.mData, ref destEncodeIdx);
                    if (cmd > 0)
                        destCharId = cmd;
                    else
                        destSpanLeft = -cmd;
                }
                
                if (destCharId > highestSrcCharId)
                {
                    // This is new text since we did the background compile, skip
                    destIdx++;
                    destSpanLeft--;
                    destCharId++;
                    continue;
                }
                
                if (srcCharId != destCharId)
                {
                    // Id doesn't match, character must have been deleted
                    srcIdx++;
                    srcSpanLeft--;
                    srcCharId++;
                    continue;
                }
                
                Debug.Assert(destCharId == srcCharId);
				Debug.Assert(destText[destIdx].mChar == charData[srcIdx].mChar);
				
                if (destText[destIdx].mDisplayPassId == (uint8)SourceDisplayId.AutoComplete)
                {
                    // Autocomplete beat us to it
                    destText[destIdx].mDisplayPassId = (uint8)SourceDisplayId.Cleared;
                }
				else if (charData[srcIdx].mDisplayPassId == (uint8)SourceDisplayId.SkipResult)
				{
					//
				}
                else
                {
                    uint8 prevFlags = destText[destIdx].mDisplayFlags;
					if (!flagsOnly)
                    	destText[destIdx] = charData[srcIdx];
                    destText[destIdx].mDisplayFlags = (uint8)
                            ((prevFlags & ~replaceFlags) |
                            (charData[srcIdx].mDisplayFlags & replaceFlags));
                }

                srcIdx++;
                srcSpanLeft--;
                srcCharId++;
                destIdx++;
                destSpanLeft--;
                destCharId++;
            }

			delete charData;
            charData = null;
            charIdData.Dispose();
        }

        public override void ShowQuickFind(bool isReplace)
        {
			//RecordHistoryLocation();
			var activePanel = GetActivePanel();
			if (Content.Data.mCurQuickFind != null)
			{
				Content.Data.mCurQuickFind.Close();
			}
			
			if (activePanel != this)
			{
				activePanel.ShowQuickFind(isReplace);
				return;
			}

            /*if (mOldVersionPanel != null)
            {
                mOldVersionPanel.ShowQuickFind(isReplace);
                return;
            }*/

            if (mRenameSymbolDialog != null)            
                mRenameSymbolDialog.Close();            
            
            base.ShowQuickFind(isReplace);

			Content.Data.mCurQuickFind = mQuickFind;
        }

        public override void FindNext(int32 dir = 1)
        {
			var activePanel = GetActivePanel();
			if (activePanel != this)
			{
				activePanel.FindNext();
				return;
			}

            if (mOldVersionPanel != null)
            {
                mOldVersionPanel.FindNext(dir);
                return;
            }

            base.FindNext(dir);
        }

        public void ReformatDocument(bool ignoreSelection = false)
        {
			if (!mIsBeefSource)
				return;

            var bfSystem = IDEApp.sApp.mBfResolveSystem;
			if (bfSystem == null)
				return;
            var parser = bfSystem.CreateEmptyParser(null);
			defer delete parser;
            var text = scope String();
            mEditWidget.GetText(text);
            parser.SetSource(text, mFilePath, -1);
            var passInstance = bfSystem.CreatePassInstance();
			defer delete passInstance;
            parser.Parse(passInstance, false);
            parser.Reduce(passInstance);
			mWantsParserCleanup = true;
            bool performSanityCheck = false;
#if !DEBUG
            performSanityCheck = false;
#endif

            if (performSanityCheck)
            {
                int32[] char8Mapping;
                var newText = scope String();
                parser.Reformat(-1, -1, out char8Mapping, newText); // Just reprint without reformatting first            

                int32 lineNum = 0;
                int32 lineStart = 0;
                for (int32 i = 0; i < Math.Min(newText.Length, text.Length); i++)
                {
                    if (text[i] == '\n')
                    {
                        lineNum++;
                        lineStart = i + 1;
                    }
                    if (text[i] != newText[i])
                    {
                        IDEApp.sApp.OutputLine("Reformat had a difference at line {0}", (lineNum + 1));

                        int nextCr = text.IndexOf('\n', lineStart);
                        IDEApp.sApp.OutputLine(" {0}", scope String(text, lineStart, nextCr - lineStart));

                        nextCr = newText.IndexOf('\n', lineStart);
                        IDEApp.sApp.OutputLine(" {0}", scope String(newText, lineStart, nextCr - lineStart));

                        break;
                    }
                }
            }

            if ((mEditWidget.Content.HasSelection()) && (!ignoreSelection))
                parser.ReformatInto(mEditWidget, mEditWidget.Content.mSelection.Value.MinPos, mEditWidget.Content.mSelection.Value.MaxPos);
            else
                parser.ReformatInto(mEditWidget, 0, text.Length);

            //mEditWidget.SetText(newText);
        }

        public void GotoLine()
        {                        
            GoToLineDialog aDialog = new GoToLineDialog("Go To Line", scope String()..AppendF("Line Number ({0}-{1})", 1, mEditWidget.Content.GetLineCount()));
            aDialog.Init(this);                        
            aDialog.PopupWindow(mWidgetWindow);
        }

        public void GotoMethod()
        {
			if (mSplitBottomPanel != null)
				mSplitBottomPanel.GotoMethod();
			else
            	mNavigationBar.ShowDropdown();            
        }

		public void FixitAtCursor()
		{
			if (!mIsBeefSource)
				return;

			//TODO: Make better, do async, etc...			
			DoClassify(ResolveType.GetFixits, null, true);
		}

        public void ShowSymbolReferenceHelper(SymbolReferenceHelper.Kind symbolReferenceKind)
        {
            if (gApp.mSymbolReferenceHelper != null)
			{
                gApp.mSymbolReferenceHelper.Close();
			}

            SymbolReferenceHelper symbolReferenceHelper = new SymbolReferenceHelper();
			//symbolReferenceHelper.[Friend]GCMarkMembers();
			//Debug.WriteLine("SymbolReferenceHelper {0} ResolveParams:{1}", symbolReferenceHelper, symbolReferenceHelper.[Friend]mResolveParams);

            mRenameSymbolDialog = symbolReferenceHelper;
            gApp.mSymbolReferenceHelper = symbolReferenceHelper;
			//BfResolveCompiler.mThreadWorkerHi.WaitForBackground(); // We need to finish up anything on the hi thread worker so we can queue this
            symbolReferenceHelper.Init(this, symbolReferenceKind);
            if (!symbolReferenceHelper.mFailed)
            {
                AddWidget(symbolReferenceHelper);
                ResizeComponents();
            }
            else
            {
                mRenameSymbolDialog?.Close();
            }

			if ((symbolReferenceKind == .Rename) && (let autoComplete = GetAutoComplete()))
				autoComplete.Close();
        }

        public void RenameSymbol()
        {
			if (mQuickFind != null)
				mQuickFind.Close();

			var sourceEditWidgetContent = (SourceEditWidgetContent)mEditWidget.Content;
			if (!sourceEditWidgetContent.CheckReadOnly())
            	ShowSymbolReferenceHelper(SymbolReferenceHelper.Kind.Rename);
        }

		public void FindAllReferences()
		{
			ShowSymbolReferenceHelper(SymbolReferenceHelper.Kind.FindAllReferences);
		}

        public override void SetVisible(bool visible)
        {
            base.SetVisible(visible);
            mWantsFullClassify = true;
            mWantsClassifyAutocomplete = false;
        }

        public override void RecordHistoryLocation(bool ignoreIfClose = false)
        {
            var sourceEditWidgetContent = (SourceEditWidgetContent)mEditWidget.Content;
            sourceEditWidgetContent.RecordHistoryLocation(ignoreIfClose);
        }        

		bool CheckLeftMouseover()
		{
			if (mWidgetWindow == null)
				return false;
			if (!mWidgetWindow.mHasMouseInside)
				return false;

			Point mousePos;
			bool mouseoverFired = DarkTooltipManager.CheckMouseover(this, 10, out mousePos);

			String tooltipStr = scope String();

			if ((DarkTooltipManager.sTooltip != null) && (DarkTooltipManager.sTooltip.mRelWidget == this))
				mouseoverFired = true;

			if (!mouseoverFired)
				return false;

			float leftAdjust = GS!(12);

			float editX = GetEditX();
			if ((mousePos.x < editX - GS!(24) - leftAdjust) || (mousePos.x > editX - GS!(5) - leftAdjust))
				return false;

			int mouseLine = GetLineAt(mousePos.x, mousePos.y);

			for (var breakpointView in GetTrackedElementList())
			{
			    var trackedElement = breakpointView.mTrackedElement;
			    var breakpoint = trackedElement as Breakpoint;
			    //var bookmark = trackedElement as Bookmark;

				if (breakpoint != null)
				{
					int breakpointLineNum;
					if (mIsBeefSource)
				    	breakpointLineNum = breakpoint.GetLineNum();
					else
						breakpointLineNum = breakpoint.mLineNum;
					int drawLineNum = breakpointLineNum;

					if (drawLineNum == mouseLine)
					{
						if (!tooltipStr.IsEmpty)
							tooltipStr.Append("\n\n");

						breakpoint.ToString_Location(tooltipStr);

						if (breakpoint.mThreadId != -1)
							tooltipStr.AppendF("\nThread: {0}", breakpoint.mThreadId);

						tooltipStr.Append("\nHits: ");
						breakpoint.ToString_HitCount(tooltipStr);

						if (breakpoint.mLogging != null)
							tooltipStr.Append("\nLog: ", breakpoint.mLogging);
					}	
				}				  
			}

			if (tooltipStr.IsEmpty)
				return false;

			if ((DarkTooltipManager.sTooltip != null) && (DarkTooltipManager.sTooltip.mText == tooltipStr))
				return true;

			DarkTooltipManager.ShowTooltip(tooltipStr, this, mousePos.x, mousePos.y);
			return true;
		}

		public void GetDebugExpressionAt(int textIdx, String debugExpr)
		{
			BfSystem bfSystem = IDEApp.sApp.mBfResolveSystem;
			let parser = bfSystem.CreateEmptyParser(null);

			var text = scope String();
			mEditWidget.GetText(text);
			parser.SetSource(text, mFilePath, -1);
			parser.SetAutocomplete(textIdx);
			let passInstance = bfSystem.CreatePassInstance("Mouseover");
			parser.SetCompleteParse();
			parser.Parse(passInstance, !mIsBeefSource);
			parser.Reduce(passInstance);
			if (parser.GetDebugExpressionAt(textIdx, debugExpr))
			{
			    if (debugExpr.StartsWith("`"))
					debugExpr[0] = ':';
			    else if (debugExpr.StartsWith(":"))
			        debugExpr.Clear();
			}
			delete passInstance;
			delete parser;
		}

		public void UpdateMouseover(bool mouseoverFired, bool mouseInbounds, int line, int lineChar, bool isManual = false)
		{
#unwarn
		    CompilerBase compiler = ResolveCompiler;

			bool hasClangHoverErrorData = false;
			var editWidgetContent = mEditWidget.Content;

#if IDE_C_SUPPORT
			hasClangHoverErrorData = mClangHoverErrorData != null;
#endif
		    
	        String debugExpr = null;

	        BfSystem bfSystem = IDEApp.sApp.mBfResolveSystem;                
	        BfPassInstance passInstance = null;
	        BfParser parser = null;
	        int textIdx = -1;

	        bool isOverMessage = false;
	        if (mouseInbounds)
	        {
	            textIdx = editWidgetContent.GetTextIdx(line, lineChar);
	            
	            int startIdx = editWidgetContent.GetTextIdx(line, lineChar);

	            uint8 checkFlags = (uint8)SourceElementFlags.Error;
	            if (!IDEApp.sApp.mDebugger.mIsRunning)
	            {
	                // Prioritize debug info over warning when we are debugging
	                checkFlags |= (uint8)SourceElementFlags.Warning; 
	            }
	            if ((editWidgetContent.mData.mText[startIdx].mDisplayFlags & checkFlags) != 0)
	                isOverMessage = true;

				bool doSimpleMouseover = false;

	            if ((editWidgetContent.mSelection != null) &&
	                (textIdx >= editWidgetContent.mSelection.Value.MinPos) &&
	                (textIdx < editWidgetContent.mSelection.Value.MaxPos))
	            {
	                debugExpr = scope:: String();
	                editWidgetContent.GetSelectionText(debugExpr);
	            }
	            else if (mIsBeefSource)
	            {
					if (bfSystem != null)
					{
						parser = bfSystem.CreateEmptyParser(null);
					
	                    var text = scope String();
	                    mEditWidget.GetText(text);
	                    parser.SetSource(text, mFilePath, -1);
	                    parser.SetAutocomplete(textIdx);
	                    passInstance = bfSystem.CreatePassInstance("Mouseover");
						parser.SetCompleteParse();
	                    parser.Parse(passInstance, !mIsBeefSource);
	                    parser.Reduce(passInstance);
	                    debugExpr = scope:: String();
	                    if (parser.GetDebugExpressionAt(textIdx, debugExpr))
	                    {
	                        if (debugExpr.StartsWith("`"))
								debugExpr[0] = ':';
	                        else if (debugExpr.StartsWith(":"))
	                            debugExpr = null;
	                    }
					}
	            }
	            else if (mIsClang)
					doSimpleMouseover = true;

				if (doSimpleMouseover)
				SimpleMouseover: do
	            {
	                int endIdx = startIdx;
	                String sb = scope:: String();
	                bool isInvalid = false;
	                bool prevWasSpace = false;

					if (editWidgetContent.mData.mText[startIdx].mChar.IsWhiteSpace)
						break;

	                startIdx--;
	                while (startIdx > 0)
	                {
	                    var char8Data = editWidgetContent.mData.mText[startIdx];
	                    if (char8Data.mDisplayTypeId == (uint8)SourceElementType.Comment)
	                    {
	                        if (startIdx == endIdx - 1)
	                        {
	                            // Inside comment
	                            isInvalid = true;
	                            break;
	                        }
	                    }
	                    else
	                    {
	                        char8 c = (char8)char8Data.mChar;
	                        if ((c == ' ') || (c == '\t'))
	                        {
	                            // Ignore
	                            prevWasSpace = true;
	                        }
							else if (c == '\n')
							{
								break;
							}
	                        else
	                        {
	                            if (c == '>')
	                            {
	                                // Is this "->"?
	                                if ((startIdx > 1) && ((char8)editWidgetContent.mData.mText[startIdx - 1].mChar == '-'))
	                                {
	                                    sb.Insert(0, "->");
	                                    startIdx--;
	                                }
	                                else
	                                    break;
	                            }
	                            else if (c == ':')
	                            {
	                                // Is this "::"?
	                                if ((startIdx > 1) && ((char8)editWidgetContent.mData.mText[startIdx - 1].mChar == ':'))
	                                {
	                                    sb.Insert(0, "::");
	                                    startIdx--;
	                                }
	                                else
	                                    break;
	                            }
	                            else if (c == '.')
	                                sb.Insert(0, c);
	                            else if ((c == '_') || (c.IsLetterOrDigit))
	                            {
	                                if (prevWasSpace)
	                                    break;
	                                sb.Insert(0, c);
	                            }
	                            else
	                                break;

	                            prevWasSpace = false;
	                        }
	                    }
	                    startIdx--;
	                }
					
	                prevWasSpace = false;
	                while ((endIdx < editWidgetContent.mData.mTextLength) && (endIdx > startIdx))
	                {
	                    var char8Data = editWidgetContent.mData.mText[endIdx];
	                    if (char8Data.mDisplayTypeId == (uint8)SourceElementType.Comment)
	                    {
	                        // Ignore
	                        prevWasSpace = true;
	                    }
	                    else
	                    {
	                        char8 c = (char8)char8Data.mChar;
	                        if ((c == ' ') || (c == '\t'))
	                        {
	                            // Ignore
	                            prevWasSpace = true;
	                        }
	                        else if ((c == '_') || (c.IsLetterOrDigit))
	                        {
	                            if (prevWasSpace)
	                                break;

	                            sb.Append(c);
	                        }
	                        else
	                            break;

	                        prevWasSpace = false;
	                    }
	                    endIdx++;
	                }

	                if (!isInvalid)
	                    debugExpr = sb;
	            }
	        }

	        bool triedShow = false;

	        if (mHoverWatch != null)
	        {
	            if (debugExpr != null)                        
	            {
	                if (mHoverWatch.mEvalString != debugExpr)
					{
	                    mHoverWatch.Close();
						mHoverWatch = null;
					}
	                else
	                    triedShow = true;
	            }
	        }

	        if (((mHoverWatch == null) && (mouseoverFired)) || (debugExpr == null) || (hasClangHoverErrorData) || (mHoverResolveTask?.mResult != null))
	        {
	            float x;
	            float y;
	            editWidgetContent.GetTextCoordAtLineChar(line, lineChar, out x, out y);

				bool hasHoverWatchOpen = (mHoverWatch != null) && (mHoverWatch.mListView != null);
	            if (mHoverWatch == null)
				{
	                mHoverWatch = new HoverWatch();
				}

	            if (debugExpr != null)
	                triedShow = true;

				bool didShow = false;
				//if ((debugExpr == "var") || (debugExpr == "let"))

				String origDebugExpr = null;

				bool handlingHoverResolveTask = false;

				if ((debugExpr != null) || (isOverMessage))
				{
					if (mHoverResolveTask != null)
					{
						if (mHoverResolveTask.mCursorPos != textIdx)
						{
							DeleteAndNullify!(mHoverResolveTask);
						}
					}

					if ((!String.IsNullOrEmpty(mHoverResolveTask?.mResult)))
					{
						origDebugExpr = scope:: String();
						origDebugExpr.Set("");

						debugExpr.Set(mHoverResolveTask.mResult);

						if (debugExpr.StartsWith(':'))
						{
							int docsPos = debugExpr.IndexOf('\x03');
							if (docsPos != -1)
							{
								String docs = scope String()..Append(debugExpr, docsPos + 1);
								debugExpr.RemoveToEnd(docsPos);

								DocumentationParser docParser = scope .(docs);
								var showString = docParser.ShowDocString;
								if (!String.IsNullOrEmpty(showString))
								{
									debugExpr.AppendF("\n{}", Font.EncodeColor(0xFFC0C0C0));
									debugExpr.Append(showString);
								}
							}
						}
					}

					if (mHoverResolveTask?.mResult != null)
					{
						handlingHoverResolveTask = true;
						DeleteAndNullify!(mHoverResolveTask);
					}

					if (!triedShow)
					{
				        mHoverWatch.Show(this, x, y, debugExpr, debugExpr);
						triedShow = true;
					}
				}

	            /*if ((!didShow) &&
					((debugExpr == null) || (isOverMessage) || (!mHoverWatch.Show(this, x, y, origDebugExpr ?? debugExpr, debugExpr))))*/
				if (!didShow)
	            {
					if ((debugExpr != null) && (!isOverMessage))
					{
						if ((mHoverWatch.mIsShown) && (!debugExpr.StartsWith(':')))
							didShow = true;
						else
							didShow = mHoverWatch.Show(this, x, y, origDebugExpr ?? debugExpr, debugExpr);
					}

					if ((handlingHoverResolveTask) && (mHoverWatch.mIsShown))
					{
						// Keep existing content
						didShow = true;
					}

					if ((mHoverResolveTask == null) &&
						((debugExpr == null) || (!debugExpr.StartsWith(':'))))
					{
						bool wantDebugEval = false;
						if ((gApp.mDebugger.mIsRunning) && (!String.IsNullOrEmpty(debugExpr)))
						{
							wantDebugEval = true;
							if (FilteredProjectSource != null)
							{
								// This is active Beef source
								if ((debugExpr[0].IsNumber) || (debugExpr.StartsWith('\'')) || (debugExpr.StartsWith('"')))
								{
									// Literal, don't debug eval
									wantDebugEval = false;
								}
							}
						}

						if (((!wantDebugEval) || (!mHoverWatch.HasDisplay)) && // Don't show extended information for debug watches
							(!handlingHoverResolveTask) && (ResolveCompiler != null) && (!ResolveCompiler.mThreadWorkerHi.mThreadRunning) && (gApp.mSettings.mEditorSettings.mHiliteCursorReferences) && (!gApp.mDeterministic))
						{
							ResolveParams resolveParams = new .();
							resolveParams.mOverrideCursorPos = (int32)textIdx;
							Classify(ResolveType.GetResultString, resolveParams);
							//Debug.WriteLine($"GetResultString {resolveParams} {resolveParams.mInDeferredList}");
							if (!resolveParams.mInDeferredList)
								delete resolveParams;

							mHoverResolveTask = new HoverResolveTask();
							mHoverResolveTask.mCursorPos = (int32)textIdx;
							if (isManual)
							{
								mHoverResolveTask.mLine = (.)line;
								mHoverResolveTask.mLineChar = (.)lineChar;
							}
						}
					}

#if IDE_C_SUPPORT
	                if ((mIsClang) && (textIdx != -1))
	                {
	                    bool hasErrorFlag = (mEditWidget.Content.mData.mText[textIdx].mDisplayFlags != 0);

	                    if (hasErrorFlag)
	                    {
	                        if (!compiler.IsPerformingBackgroundOperation())
	                        {
	                            bool hadValidError = false;
	                            if (mClangHoverErrorData != null)
	                            {
	                                String[] stringParts = String.StackSplit!(mClangHoverErrorData, '\t');
	                                int startIdx = (int32)int32.Parse(stringParts[0]);
	                                int endIdx = (int32)int32.Parse(stringParts[1]);
	                                if ((textIdx >= startIdx) && (textIdx < endIdx))
	                                {
	                                    hadValidError = true;
	                                    triedShow = true;
	                                    mHoverWatch.Show(this, x, y, scope String(":", stringParts[2]));
										if (debugExpr != null)
	                                    	mHoverWatch.mEvalString.Set(debugExpr); // Set to old debugStr for comparison
										else
											mHoverWatch.mEvalString.Clear();
	                                }

	                            }

	                            if (!hadValidError)
	                            {
	                                mErrorLookupTextIdx = (int32)textIdx;
	                                Classify(ResolveType.Classify);
	                                triedShow = false;
	                            }
	                        }
	                    }
	                    else
	                    {
	                        triedShow = false;
							delete mClangHoverErrorData;
	                        mClangHoverErrorData = null;
	                    }
	                }
#endif

	                if ((parser != null) && (mIsBeefSource) && (!didShow) && (mHoverWatch != null) && (!mHoverWatch.mIsShown))
					ErrorScope:
	                {
						//TODO: Needed this?
	                    /*var resolvePassData = parser.CreateResolvePassData();
						defer (scope) delete resolvePassData;
	                    bfSystem.NotifyWillRequestLock(1);
	                    bfSystem.Lock(1);
	                    parser.BuildDefs(passInstance, resolvePassData, false);
	                    BfResolveCompiler.ClassifySource(passInstance, parser, resolvePassData, null);*/
	                    
	                    BfPassInstance.BfError bestError = scope BfPassInstance.BfError();

	                    for (var bfError in mErrorList)
	                    {
							if ((bfError.mWhileSpecializing.HasFlag(.Type)) && (mEmbedKind == .None))
	                            continue;
							if ((bfError.mWhileSpecializing.HasFlag(.Method)) && (mEmbedKind != .Method))
								continue;

	                        if ((textIdx >= bfError.mSrcStart) && (textIdx < bfError.mSrcEnd))
	                        {
	                            if ((bestError.mError == null) || (bestError.mIsWarning) || (bestError.mIsPersistent))
	                                bestError = bfError;                                    
	                        }
	                    }
	                    
	                    String showMouseoverString = null;
	                    if (bestError.mError != null)
	                    {
							int maxLen = 16*1024;
							if (bestError.mError.Length > maxLen)
	                        	showMouseoverString = scope:: String()..Concat(":", StringView(bestError.mError, 0, maxLen), "...");
							else
								showMouseoverString = scope:: String()..Concat(":", bestError.mError);

							if (bestError.mMoreInfo != null)
							{
								for (var moreInfo in bestError.mMoreInfo)
								{
									if (moreInfo.mLine != -1)
										showMouseoverString.AppendF("\n@{}\t{}:{}\t{}", moreInfo.mFilePath, moreInfo.mLine, moreInfo.mColumn, moreInfo.mError);
									else if (moreInfo.mFilePath != null)
										showMouseoverString.AppendF("\n@{0}\t{1}\t{2}", moreInfo.mFilePath, moreInfo.mSrcStart, moreInfo.mError);
									else
										showMouseoverString.AppendF("\n{}", moreInfo.mError);
								}
							}
	                    }
						else
						{
							var flags = (SourceElementFlags)editWidgetContent.mData.mText[textIdx].mDisplayFlags;
							if ((flags.HasFlag(.Error)) || (flags.HasFlag(.Warning)))
							{
								mWantsFullRefresh = true;
								mRefireMouseOverAfterRefresh = true;
							}
						}

	                    if (showMouseoverString != null)
	                    {
	                        triedShow = true;
	                        mHoverWatch.Show(this, x, y, showMouseoverString, showMouseoverString);
							if (debugExpr != null)
	                        	mHoverWatch.mEvalString.Set(debugExpr); // Set to old debugStr for comparison
	                    }
						else
	                        triedShow = false;
	                }
	            }
				if (!hasHoverWatchOpen)
	            	mHoverWatch?.mOpenMousePos = DarkTooltipManager.sLastRelMousePos;
	        }

			// Not used?
			if ((mHoverWatch != null) && (mHoverWatch.mTextPanel != this))
			{
				mHoverWatch.Close();
				mHoverWatch = null;
			}

	        if (mHoverWatch != null)
	        {
				if ((!triedShow) && (!IDEApp.sApp.HasPopupMenus()))
				{
					if (mHoverWatch.mCloseDelay > 0)
					{
						mHoverWatch.mCloseDelay--;
						mHoverWatch.mCloseCountdown = 20;
					}
	                else
	                {
	                    mHoverWatch.Close();
	                    mHoverWatch = null;
#if IDE_C_SUPPORT
						delete mClangHoverErrorData;
	                    mClangHoverErrorData = null;
#endif
	                }
				}
				else
				{
					mHoverWatch.mCloseCountdown = 0;
				}
	        }            
	        
	        if (passInstance != null)
	            delete passInstance;
	        if (parser != null)
	        {
	            delete parser;
	            mWantsParserCleanup = true;
	        }
		}

		public void UpdateMouseover()
		{
			if (mWidgetWindow == null)
				return;

			if (CheckLeftMouseover())
			{
				return;
			}

			if ((DarkTooltipManager.sTooltip != null) && (DarkTooltipManager.sTooltip.mRelWidget == this))
				DarkTooltipManager.CloseTooltip();

			if ((!CheckAllowHoverWatch()) && (mHoverResolveTask?.mResult == null))
			{
				return;
			}

		    /*if ((mHoverWatch != null) && (mHoverWatch.mCloseDelay > 0))
		        return;*/
		    var editWidgetContent = mEditWidget.Content;
		    Point mousePos;
		    bool mouseoverFired = DarkTooltipManager.CheckMouseover(editWidgetContent, 10, out mousePos);

			if (mouseoverFired)
			{
				
			}

#unwarn
		    CompilerBase compiler = ResolveCompiler;

			bool hasClangHoverErrorData = false;

#if IDE_C_SUPPORT
			hasClangHoverErrorData = mClangHoverErrorData != null;
#endif

			if (mHoverResolveTask != null)
			{
				if (mHoverResolveTask.mLine != null)
				{
					UpdateMouseover(true, true, mHoverResolveTask.mLine.Value, mHoverResolveTask.mLineChar.Value, true);
					return;
				}
			}
			
		    if (((mouseoverFired) || (mHoverWatch != null) || (hasClangHoverErrorData) || (mHoverResolveTask?.mResult != null)) && 
		        (mousePos.x >= 0))
		    {
		        int line;
		        int lineChar;
		        float overflowX;
		        if (editWidgetContent.GetLineCharAtCoord(mousePos.x, mousePos.y, out line, out lineChar, out overflowX))
				{
					UpdateMouseover(mouseoverFired, true, line, lineChar);
				}
				else
				{
					UpdateMouseover(mouseoverFired, false, line, lineChar);
				}
			}
		}

        void DuplicateEditState(out EditWidgetContent.CharData[] char8Data, out IdSpan char8IdData)
        {
            var srcCharData = mEditWidget.Content.mData.mText;
            char8Data = new EditWidgetContent.CharData[mEditWidget.Content.mData.mTextLength];
			var editIdData = ref mEditWidget.Content.mData.mTextIdData;
			editIdData.Prepare();
            char8IdData = editIdData.Duplicate();
            for (int32 i = 0; i < char8Data.Count; i++)
            {
                srcCharData[i].mDisplayPassId = (uint8)SourceDisplayId.Cleared;
                char8Data[i] = srcCharData[i];
            }
        }

        void DoSpellCheck()
        {
            String sb = scope String();
            var spellChecker = IDEApp.sApp.mSpellChecker;
            int32 wordStart = -1;
            bool skipWord = false;
            bool isSectionText = true;
            int32 spanSectionIdx = -1;
            bool skipNextChar = false;
			bool isVerbatimString = false;
			bool prevWasLetter = false;
			SourceElementType prevElementType = .Normal;
            for (int32 i = 0; i < mProcessSpellCheckCharData.Count; i++)
            {
                mProcessSpellCheckCharData[i].mDisplayFlags = 0;
                mProcessSpellCheckCharData[i].mDisplayPassId = (uint8)SourceDisplayId.SpellCheck;

                if (skipNextChar)
                {
                    skipNextChar = false;
                    continue;
                }

				if (spellChecker == null)
					continue;

                var char8Data = mProcessSpellCheckCharData[i];
				char8 c = (char8)char8Data.mChar;
                var elementType = (SourceElementType)char8Data.mDisplayTypeId;
                bool endString = false;
				if (elementType == .Literal)
				{
					if (prevElementType != .Literal)
						isVerbatimString = (c == '@');
				}
				else
					isVerbatimString = false;

                if ((elementType == SourceElementType.Comment) || (elementType == SourceElementType.Literal))
                {
                    if (i >= spanSectionIdx)
                    {
                        isSectionText = true;
                        spanSectionIdx = i;
                        while (spanSectionIdx < mProcessSpellCheckCharData.Count)
                        {
                            var checkCharData = mProcessSpellCheckCharData[spanSectionIdx];
                            var checkElementType = (SourceElementType)checkCharData.mDisplayTypeId;
                            if (checkElementType != elementType)
                                break;
                            char8 checkC = (char8)checkCharData.mChar;
                            if (checkC == '\n')
                                break;
                            if ((checkC == '*') || (checkC == ';'))
                                isSectionText = false;
							if (checkC >= '\x80') // Don't process high characters
								isSectionText = false;
                            spanSectionIdx++;
                        }
                    }                    

                    if ((c == '\\') && (elementType == SourceElementType.Literal) && (!isVerbatimString))
                    {                        
                        endString = true;
                        skipNextChar = true;                        
                    }

					bool isLetter = c.IsLetter;

                    if ((isLetter) || ((c == '\'') && (prevWasLetter)))
                    {
                        if (i > 0)
                        {
                            char8 prevC = (char8)mProcessSpellCheckCharData[i - 1].mChar;
                            if ((prevC == '.') || (prevC.IsNumber))
                            {
                                // Looks like extension
                                skipWord = true;
                            }
                        }

                        if ((c.IsUpper) && (wordStart != -1))
                            skipWord = true;
                        if (wordStart == -1)
                            wordStart = i;                      
                    }
                    else if (c == '_')
                    {
                        skipWord = true;
                    }
                    else if (c == '.')
                    {
                        if (i < mProcessSpellCheckCharData.Count - 1)
                        {
                            char8 nextC = (char8)mProcessSpellCheckCharData[i + 1].mChar;
                            if (nextC.IsLetter)
                            {
                                // Looks like a filename
                                skipWord = true;
                            }
                        }
                        endString = true;
                    }
                    else 
                    {
                        endString = true;
                    }

                    if (c == '\n')
                        spanSectionIdx = i;
					prevWasLetter = isLetter;
                }
                else
                {
                    endString = true;
					prevWasLetter = false;
                }
                
                if ((i == mProcessSpellCheckCharData.Count - 1) && (!endString))
                {
                    // Process last word
                    i++;
                    endString = true;
                }

                if ((endString) && (wordStart != -1))
                {
                    int32 wordLen = i - wordStart;
                    if (wordLen <= 1)
                        skipWord = true;
                    if (!isSectionText)
                        skipWord = true;
                    if (!skipWord)
                    {
                        sb.Clear();

						if (mProcessSpellCheckCharData[i - 1].mChar == '\'')
							i--;
                        for (int32 wordCharIdx = wordStart; wordCharIdx < i; wordCharIdx++)
                            sb.Append(mProcessSpellCheckCharData[wordCharIdx].mChar);
                        String word = sb;
                        bool hasSpellingError = (word.Length > 1) && (!IDEApp.sApp.mSpellChecker.IsWord(word));
                        if (hasSpellingError)
                        {
							word.ToLower();
                            using (spellChecker.mMonitor.Enter())                            
                                hasSpellingError = !spellChecker.mIgnoreWordList.Contains(word);
                        }
                        
                        if (hasSpellingError)
                        {
                            for (int32 wordCharIdx = wordStart; wordCharIdx < i; wordCharIdx++)
                            {                                
                                mProcessSpellCheckCharData[wordCharIdx].mDisplayFlags = (uint8)SourceElementFlags.SpellingError;
                            }
                        }
                    }
                    skipWord = false;                
                    wordStart = -1;
                }

				prevElementType = elementType;
            }
        }

		void SpellCheckDone()
		{
			mSpellCheckJobCount--;
		}

        void StartSpellCheck()
        {
			if (gApp.mSpellChecker == null)
			{
				if (mDidSpellCheck)
				{
					var data = mEditWidget.Content.mData;
					for (int i < data.mTextLength)
					{
						data.mText[i].mDisplayFlags &= ~((uint8)SourceElementFlags.SpellingError);
					}
				}
				mDidSpellCheck = false;
				return;
			}

            DuplicateEditState(out mProcessSpellCheckCharData, out mProcessSpellCheckCharIdSpan);

			mDidSpellCheck = true;
			mSpellCheckJobCount++;
            IDEApp.sApp.mSpellChecker.DoBackground(new => DoSpellCheck, new => SpellCheckDone);
        }
		
		void AddHistory()
		{

		}

		/*bool ProcessResolveData()
		{
			scope AutoBeefPerf("SourceViewPanel.ProcessResolveData");

			bool canDoBackground = true;

			if ((mProcessResolveCharData != null) && (mProcessingPassInstance != null))
			{
				MarkDirty();
			    InjectErrors(mProcessingPassInstance, mProcessResolveCharData, mProcessResolveCharIdSpan, false);
			    canDoBackground = false;
			}

			if (mProcessResolveCharData != null)
			{
				for (int i < mProcessResolveCharData.Count)
				{
					
				}

				MarkDirty();
			    UpdateCharData(ref mProcessResolveCharData, ref mProcessResolveCharIdSpan, (uint8)SourceElementFlags.CompilerFlags_Mask);
			    canDoBackground = false;
			}

			if (mProcessingPassInstance != null)
			{
				MarkDirty();
			    if (mProcessingPassInstance.HadSignatureChanges())
			        mWantsFullRefresh = true;

			    delete mProcessingPassInstance;
			    mProcessingPassInstance = null;
			}

			return canDoBackground;
		}*/

		public void EnsureReady()
		{
			if (mWantsFastClassify)
			{
				DoFastClassify();
				mWantsFastClassify = false;
			}
		}

		public bool HasDeferredResolveResults()
		{
			using (mMonitor.Enter())
			{
				return !mDeferredResolveResults.IsEmpty;
			}
		}

		void ProcessDeferredResolveResults(int waitTime, bool autocompleteOnly = false)
		{
			//bool canDoBackground = true;

			int checkIdx = 0;

			while (true)
			{
				ResolveParams resolveResult = null;
				using (mMonitor.Enter())
				{
					if (checkIdx >= mDeferredResolveResults.Count)
						break;
					resolveResult = mDeferredResolveResults[checkIdx];
				}

				if ((autocompleteOnly) && (resolveResult.mResolveType != .Autocomplete))
				{
					checkIdx++;
					continue;
				}

				if (!resolveResult.mWaitEvent.WaitFor(0))
				{
					if (waitTime != 0)
						ResolveCompiler.RequestFastFinish();
				}

				if (!resolveResult.mWaitEvent.WaitFor(waitTime))
				{
					checkIdx++;
					continue;
				}

				using (mMonitor.Enter())
					mDeferredResolveResults.RemoveAt(checkIdx);

				//Debug.WriteLine($"HandleResolveResult {resolveResult}");

				HandleResolveResult(resolveResult.mResolveType, resolveResult.mAutocompleteInfo, resolveResult);

				if (resolveResult.mStopwatch != null)
				{
					resolveResult.mStopwatch.Stop();
					if (var autoComplete = GetAutoComplete())
						Debug.WriteLine($"Autocomplete {resolveResult.mStopwatch.ElapsedMilliseconds}ms entries: {(autoComplete.mAutoCompleteListWidget?.mEntryList.Count).GetValueOrDefault()}");
				}

				//Debug.WriteLine("ProcessDeferredResolveResults finished {0}", resolveResult.mResolveType);

				//bool checkIt = (mFilePath.Contains("Program.bf")) && (mEditWidget.mEditWidgetContent.mData.mCurTextVersionId > 3);
				/*var data = ref mEditWidget.Content.mData.mText[10018];
				if (checkIt)
				{
					Debug.Assert(resolveResult.mCharData[10018].mDisplayTypeId == 8);
					Debug.Assert(data.mDisplayTypeId == 8);
				}
				uint8* ptr = &data.mDisplayTypeId;*/

				scope AutoBeefPerf("SourceViewPanel.ProcessResolveData");

				bool canDoBackground = true;

				bool wantsData = (!resolveResult.mCancelled) && (resolveResult.mResolveType != .GetCurrentLocation) && (resolveResult.mResolveType != .GetSymbolInfo);
				if (wantsData)
				{
					bool filterErrors = !resolveResult.mEmitEmbeds.IsEmpty;

					if ((resolveResult.mCharData != null) && (resolveResult.mPassInstance != null))
					{
						bool isAutocomplete = (resolveResult.mResolveType == .Autocomplete) || (resolveResult.mResolveType == .Autocomplete_HighPri);

						MarkDirty();
					    InjectErrors(resolveResult.mPassInstance, resolveResult.mCharData, resolveResult.mCharIdSpan, isAutocomplete, filterErrors);
					    canDoBackground = false;
					}

					if (resolveResult.mCharData != null)
					{
						MarkDirty();
					    UpdateCharData(ref resolveResult.mCharData, ref resolveResult.mCharIdSpan, (uint8)SourceElementFlags.CompilerFlags_Mask, false);
					    canDoBackground = false;
					}

					if ((!resolveResult.mEmitEmbeds.IsEmpty) && (resolveResult.mResolveType.IsClassify))
					{
						let ewc = (SourceEditWidgetContent)mEditWidget.mEditWidgetContent;

						Dictionary<String, SourceEditWidgetContent.EmitEmbed.View> emitViewDict = scope .();
						Dictionary<String, String> remappedTypeNames = scope .();

						for (var embed in ewc.mEmbeds.Values)
						{
							if (var emitEmbed = embed as SourceEditWidgetContent.EmitEmbed)
							{
								String useTypeName = emitEmbed.mTypeName;
								if (!mExplicitEmitTypes.IsEmpty)
								{
									if (remappedTypeNames.TryAdd(useTypeName, var keyPtr, var valuePtr))
									{
										*valuePtr = useTypeName;
										for (var explicitTypeName in mExplicitEmitTypes)
										{
											if (IDEUtils.GenericEquals(useTypeName, explicitTypeName))
											{
												*valuePtr = explicitTypeName;
												break;
											}
										}
									}
									emitEmbed.mTypeName.Set(*valuePtr);
								}

								if (emitEmbed.mView != null)
								{
									if (emitViewDict.TryAdd(emitEmbed.mTypeName, var keyPtr, var valuePtr))
									{
										*valuePtr = emitEmbed.mView;
									}
									else if (emitEmbed.mView.mTypeName != emitEmbed.mTypeName)
									{
										emitEmbed.mView.RemoveSelf();
										DeleteAndNullify!(emitEmbed.mView);
										ewc.mCollapseNeedsUpdate = true;
									}
								}
							}
						}

						for (var embed in resolveResult.mEmitEmbeds)
						{
							if (embed.mCharData == null)
								continue;

							if (emitViewDict.GetAndRemove(embed.mTypeName) case .Ok((var name, var emitEmbedView)))
							{
								var emitEmbed = emitEmbedView.mEmitEmbed;

								if (emitEmbedView.mEmitEmbed.mTypeName != emitEmbedView.mTypeName)
								{
									int focusIdx = -1;
									if (emitEmbedView.mSourceViewPanel.mEditWidget.mHasFocus)
										focusIdx = 0;
									else if (emitEmbedView.mGenericTypeCombo?.mEditWidget.mHasFocus == true)
										focusIdx = 1;
									else if (emitEmbedView.mGenericMethodCombo?.mEditWidget.mHasFocus == true)
										focusIdx = 2;

									emitEmbedView.RemoveSelf();
									DeleteAndNullify!(emitEmbed.mView);

									emitEmbedView = new .(emitEmbed);
									emitEmbed.mView = emitEmbedView;
									mEditWidget.mEditWidgetContent.AddWidget(emitEmbed.mView);

									var sewc = mEditWidget.mEditWidgetContent as SourceEditWidgetContent;
									sewc.RehupLineCoords();

									if (focusIdx == 0)
										emitEmbedView.mSourceViewPanel.mEditWidget.SetFocus();
									else if (focusIdx == 1)
										emitEmbedView.mGenericTypeCombo?.mEditWidget.SetFocus();
									else if (focusIdx == 2)
										emitEmbedView.mGenericMethodCombo?.mEditWidget.SetFocus();
								}

								var firstSourceViewPanel = emitEmbedView.mSourceViewPanel;

								var firstEmbedEWC = firstSourceViewPanel.mEditWidget.mEditWidgetContent;

								var prevCursorLineAndColumn = firstEmbedEWC.CursorLineAndColumn;

								var editData = firstSourceViewPanel.mEditWidget.mEditWidgetContent.mData;
								if (editData.mTextLength == 0)
									DeleteAndNullify!(firstSourceViewPanel.mTrackedTextElementViewList);

								delete editData.mText;
								editData.mText = embed.mCharData;
								editData.mTextLength = (.)embed.mCharData.Count - 1;
								embed.mCharData = null;
								editData.mTextIdData.Dispose();
								editData.mTextIdData = IdSpan();
								editData.mNextCharId = 0;
								editData.mTextIdData.Insert(0, editData.mTextLength, ref editData.mNextCharId);

								firstSourceViewPanel.mEmitRevision = embed.mRevision;
								firstSourceViewPanel.InjectErrors(resolveResult.mPassInstance, editData.mText, editData.mTextIdData, false, true);

								for (var user in editData.mUsers)
								{
									if (var embedEWC = user as SourceEditWidgetContent)
									{
										var sourceViewPanel = embedEWC.mSourceViewPanel;

										sourceViewPanel.mEditWidget.mEditWidgetContent.ContentChanged();
										// We have a full classify now, FastClassify will just mess it up
										sourceViewPanel.mSkipFastClassify = true; 

										if (prevCursorLineAndColumn.mLine >= firstEmbedEWC.GetLineCount())
											embedEWC.CursorLineAndColumn = .(firstEmbedEWC.GetLineCount() - 1, prevCursorLineAndColumn.mColumn);
									}
								}
							}
						}
					}

					if (resolveResult.mPassInstance != null)
					{
						MarkDirty();
					    if (resolveResult.mPassInstance.HadSignatureChanges())
						{
					        mWantsFullRefresh = true;
						}
					}
				}

				/*if (checkIt)
					Debug.Assert(data.mDisplayTypeId == 8);*/

				//Debug.WriteLine($"Deleting {resolveResult}");
				delete resolveResult;
			}
		}

        public override void Update()
        {
            base.Update();

			scope AutoBeefPerf("SourceViewPanel.Update");

			EnsureReady();

			if (mPanelHeader != null)
			{
				if (mPanelHeader.mKind == .WrongHash)
				{
					if (!gApp.mDebugger.mIsRunning)
					{
						// No longer makes sense if we're not even running
						CloseHeader();
					}
				}
			}

			if (mProjectSource == null)
			{
				if (mEditData != null)
					Debug.Assert(mEditData.mProjectSources.IsEmpty);
			}
			else
			{
				if (mEditData != null)
					Debug.Assert(mEditData.mProjectSources.Contains(mProjectSource));
			}

			let projectSource = FilteredProjectSource;

			/*if (mWidgetWindow.IsKeyDown(.Control) && mWidgetWindow.IsKeyDown(.Alt))
				QueueFullRefresh(false);*/

			if (mEditData != null)
				Debug.Assert(Path.Equals(mFilePath, mEditData.mFilePath));


			bool hasFocus = HasFocus(false);
			bool selfHasFocus = HasFocus(true);

			if (mSourceFindTask != null)
			{
				if (mSourceFindTask.WaitFor(0))
				{
					String foundPath = null;
					bool isWrongHash = false;
					if (mSourceFindTask.mFoundPath != null)
					{
						foundPath = mSourceFindTask.mFoundPath;
					}
					else if (mSourceFindTask.mBackupFileName != null)
					{
						foundPath = mSourceFindTask.mBackupFileName;
						isWrongHash = true;
					}

					if (foundPath != null)
					{
						mFilePath.Set(foundPath);
						RehupAlias();
					}

					DeleteAndNullify!(mSourceFindTask);

					RetryLoad();
				}
			}

			/*if (mEditData != null)
			{
				Debug.Assert(!mEditData.mOwnsEditWidget);
				Debug.Assert(!mEditData.mFilePath.Contains("\\\\"));
				if (mEditData.mFilePath.IndexOf("BfModule.cpp", true) != -1)
				{
					Debug.Assert(mProjectSource != null);
				}
			}*/

            if (GetEditX() != mEditWidget.mX)
                ResizeComponents();

            if (!IDEApp.sApp.mDebugger.mIsRunning)
                CloseOldVersion();

			if (mOldVerLoadExecutionInstance != null)
			{
				if (mOldVerLoadExecutionInstance.mExitCode != null)
				{
					if ((int)mOldVerLoadExecutionInstance.mExitCode == 0)
					{
						CheckAdjustFile();
                        RetryLoad();
					}
					else
						SetLoadCmd(mOldVerLoadCmd);
					delete mOldVerLoadExecutionInstance;
					mOldVerLoadExecutionInstance = null;
				}
			}

			if (mOldVerHTTPRequest != null)
			{
				let result = mOldVerHTTPRequest.GetResult();
				if (result != .NotDone)
				{
					if (result == .Failed)
					{
						String errorMsg = scope .();
						errorMsg.AppendF("Failed to retrieve source from {}", mOldVerLoadCmd);

						String errorReason = scope .();
						mOldVerHTTPRequest.GetLastError(errorReason);

						if (!errorReason.IsEmpty)
							errorMsg.AppendF(" ({})", errorReason);

						gApp.OutputErrorLine(errorMsg);
					}

					CheckAdjustFile();
					RetryLoad();
					DeleteAndNullify!(mOldVerHTTPRequest);
				}
			}

			if (gApp.mIsUpdateBatchStart)
            	UpdateMouseover();
            
            var compiler = ResolveCompiler;
            var bfSystem = BfResolveSystem;
            var sourceEditWidgetContent = (SourceEditWidgetContent)mEditWidget.Content;

            if (bfSystem != null)
                bfSystem.PerfZoneStart("Update");

            if ((compiler != null) && (!compiler.IsPerformingBackgroundOperation()))
                mBackgroundResolveType = ResolveType.None;

            bool canDoBackground = (compiler != null) && (!compiler.IsPerformingBackgroundOperation()) && (!compiler.HasQueuedCommands());
#if IDE_C_SUPPORT
            if (mIsClang)
            {
                var buildClang = IDEApp.sApp.mDepClang;
                if ((buildClang.IsPerformingBackgroundOperation()) && (mWantsFullClassify))
                {
                    // Don't let buildClang get in the way of autocompletion
                    buildClang.mThreadYieldCount = 20;
                    canDoBackground = false;
                }
            }
#endif

			if (mResolveJobCount > 0)
			{
				if (compiler != null)
					Debug.Assert((compiler.IsPerformingBackgroundOperation()) || (compiler.mThreadWorker.mOnThreadDone != null) || (compiler.mThreadWorkerHi.mOnThreadDone != null));
			}

            if (mBackgroundDelay > 0)
            {
                --mBackgroundDelay;
                canDoBackground = false;
            }

            if (mIsPerformingBackgroundClassify)
            {
                canDoBackground = false;
            }
            else
            {
                // Handle finishing old backgrounds             
				//canDoBackground &= ProcessResolveData();
            }                           

            if (canDoBackground)
            {
                // Check for starting new backgrounds

                // Wait longer for Clang since it'll delay autocompletions whereas Beef can be interrupted
                int32 classifyDelayTicks = (mIsBeefSource || (mUpdateCnt < 40)) ? 2 : 40;
				if (mUpdateCnt <= 1)
					classifyDelayTicks = 0;
                
                if (mWantsBackgroundAutocomplete)
                {
                    Classify(ResolveType.Autocomplete);
                    mWantsBackgroundAutocomplete = false;
					canDoBackground = false;
                }
                else if ((mWantsFullClassify) && (mTicksSinceTextChanged >= classifyDelayTicks) 
                    //TODO: Debug, remove
                        /*&& (mWidgetWindow.IsKeyDown(KeyCode.Alt))*/)
                {
					if (IsControllingEditData())
					{
	                    if (Classify(mWantsFullRefresh ? ResolveType.ClassifyFullRefresh : ResolveType.Classify))
	                    {
	                        mWantsFullClassify = false;
	                        mWantsFullRefresh = false;
							mWantsCollapseRefresh = false;
	                    }
						canDoBackground = false;
					}
                }
				else if (mWantsCollapseRefresh)
				{
					if (!compiler.IsPerformingBackgroundOperation())
					{
						bfSystem?.Log("SourceViewPanel handling mWantsCollapseRefresh");
						mWantsCollapseRefresh = false;
						/*Classify(.GetCollapse);*/

						if ((projectSource != null) && (mIsBeefSource))
						do
						{
					        var bfProject = bfSystem.GetBfProject(projectSource.mProject);
					        if (bfProject.mDisabled)
								break;
							
					        var bfParser = bfSystem.FindParser(projectSource);
							if (bfParser == null)
								break;

							var data = mEditWidget.mEditWidgetContent.mData;
							if (mParsedState.mTextVersion == -1)
							{
								mParsedState.mIdSpan.DuplicateFrom(ref data.mTextIdData);
								mParsedState.mTextVersion = data.mCurTextVersionId;
							}

							//Debug.WriteLine($"Queueing DoRefreshCollapse TextVersion:{mParsedState.mTextVersion} IdSpan:{mParsedState.mIdSpan:D}");
							compiler.DoBackground(new () =>
								{
									DoRefreshCollapse(bfParser, mParsedState.mTextVersion, mParsedState.mIdSpan);
								});
						}
					}
				}
				else if (mWantsParserCleanup)
				{
					if (!compiler.IsPerformingBackgroundOperation())
					{
						mWantsParserCleanup = false;
						compiler.DoBackground(new => DoParserCleanup);
						canDoBackground = false;
					}
				}
            }
            else if ((mWantsFullClassify) && (selfHasFocus))
            {
                // Already changed - cancel and restart
				if (compiler != null)
                	compiler.RequestCancelBackground();
                //Debug.WriteLine(String.Format("Cancel From: {0}", mFilePath));
            }
            
            if ((IDEApp.sApp.mSpellChecker == null) || (!IDEApp.sApp.mSpellChecker.IsPerformingBackgroundOperation()))
            {
                if (mProcessSpellCheckCharData != null)
				{
                    UpdateCharData(ref mProcessSpellCheckCharData, ref mProcessSpellCheckCharIdSpan, (uint8)SourceElementFlags.SpellingError, true);
					delete mProcessSpellCheckCharData;
					mProcessSpellCheckCharData = null;
					mProcessSpellCheckCharIdSpan.Dispose();
				}
                if ((mTicksSinceTextChanged >= 60) && (mWantsSpellCheck))
                {
					if ((IsControllingEditData()) && (mEmbedKind == .None))
                    	StartSpellCheck();
                    mWantsSpellCheck = false;
                }
            }            

#if IDE_C_SUPPORT
            if ((mAutocompleteTextVersionId != mEditWidget.Content.mData.mCurTextVersionId) && (mIsClang))
            {
                // We used an edit that didn't fire the autocompletion, and thus didn't do a FastClassify                
				if (IsControllingEditData())
                	DoFastClassify();
                mAutocompleteTextVersionId = mEditWidget.Content.mData.mCurTextVersionId;
            }
#endif

            if ((mLastTextVersionId != mEditWidget.Content.mData.mCurTextVersionId) ||
                (mClassifiedTextVersionId != mEditWidget.Content.mData.mCurTextVersionId))
            {
                if ((mIsBeefSource) && (projectSource != null))
                {
                    // If this file is included in multiple projects then we need to
                    //  reparse these contents in the context of the other projects
					if ((IsControllingEditData()) && (IDEApp.sApp.mBfResolveHelper != null))
                    	IDEApp.sApp.mBfResolveHelper.DeferReparse(mFilePath, this);
                }

#if IDE_C_SUPPORT
                if (mIsClang)
                {
                    mClangSourceChanged = true;
                    IDEApp.sApp.mResolveClang.mProjectSourceVersion++;
                }
#endif

                if (mClassifiedTextVersionId != mEditWidget.Content.mData.mCurTextVersionId)
                {
                    mWantsSpellCheck = true;
                    mWantsFullClassify = true;
                    mClassifiedTextVersionId = mEditWidget.Content.mData.mCurTextVersionId;

                    if ((mProjectSource != null) && (IDEApp.sApp.mWakaTime != null) && (IsControllingEditData()))
                    {
                        IDEApp.sApp.mWakaTime.QueueFile(mFilePath, mProjectSource.mProject.mProjectName, false);
                    }
                }
                mLastTextVersionId = mEditWidget.Content.mData.mCurTextVersionId;
                mTicksSinceTextChanged = 0;
				if (mProjectSource != null)
					mProjectSource.HasChangedSinceLastCompile = true;
				
                EnsureTrackedElementsValid();
                UpdateHasChangedSinceLastCompile();
                if (mHoverWatch != null)
				{
                    mHoverWatch.Close();
					Debug.Assert(mHoverWatch == null);
				}
            }
			else
			{
				// If we do a non-autocomplete change that modifies a type signature, that will generate a Classify which detects
				//  the signature change afterward, and then we need to do a full classify after that
				if (mWantsFullRefresh)
					mWantsFullClassify = true;
	            if (IDEApp.sApp.mIsUpdateBatchStart)
	                mTicksSinceTextChanged++;
			}

			if ((mLastRecoveryTextVersionId != mEditWidget.Content.mData.mCurTextVersionId) && (mTicksSinceTextChanged >= 16))
			{
#if !CLI
				DeleteAndNullify!(mFileRecoveryEntry);
				if ((mFilePath != null) && (mEditData != null) && (!mEditData.mRecoveryHash.IsZero) && (gApp.mSettings.mEditorSettings.mEnableFileRecovery != .No) && (!gApp.mFileRecovery.mDisabled))
				{
					String contents = scope .();
					mEditWidget.GetText(contents);
					mFileRecoveryEntry = new .(gApp.mFileRecovery, mFilePath, mEditData.mRecoveryHash, contents, mEditWidget.mEditWidgetContent.CursorTextPos);
				}
#endif

				mLastRecoveryTextVersionId = mEditWidget.Content.mData.mCurTextVersionId;
			}

            //TODO: This is just a test!
            /*if (Rand.Float() <so 0.05f)
                Classify(false, true);
            if (Rand.Float() < 0.05f)
            {
                mWantsFullClassify = true;
                if (Rand.Float() < 0.5f)
                    mWantsFullRefresh = true;
            }*/

            UpdateTrackedElements();

            if (bfSystem != null)
                bfSystem.PerfZoneEnd();
            mJustShown = false;

            if (hasFocus)
            {
                IDEApp.sApp.SetInDisassemblyView(false);
                /*if ((IDEApp.sApp.mRenameSymbolDialog != null) && (mRenameSymbolDialog == null))
                {
                    // Someone else has one open, cancel it
                    IDEApp.sApp.mRenameSymbolDialog.Close();
                }*/
            }

			// When files changes we move it to the permanent area
            if ((HasUnsavedChanges()) && (gApp.mSymbolReferenceHelper?.IsRenaming != true))
            {
                var parent = mParent;
                while (parent != null)
                {
                    var tabbedView = mParent as TabbedView;
                    if (tabbedView != null)
                    {
                        var activeTab = (DarkTabbedView.DarkTabButton)tabbedView.GetActiveTab();
                        //This isn't true if we have a split view
                        // Debug.Assert(activeTab.mContent == this);
                        if (activeTab.mIsRightTab)
                        {
                            IDEApp.sApp.ShowSourceFile(mFilePath, mProjectSource, SourceShowType.ShowExisting, false);
                        }
                        break;
                    }
                    parent = parent.mParent;
                }
            }

			// This potentially closes the symbol reference helper if there's nothing going on
            if ((selfHasFocus) /*&& (sourceEditWidgetContent.mCursorStillTicks == 0)*/)
            {
				var symbolReferenceHelper = IDEApp.sApp.mSymbolReferenceHelper;
				if ((symbolReferenceHelper != null) && //(symbolReferenceHelper.HasStarted) && (!symbolReferenceHelper.IsStarting) &&
                    (symbolReferenceHelper.mKind == SymbolReferenceHelper.Kind.ShowFileReferences))
                {
                    int cursorIdx = sourceEditWidgetContent.CursorTextPos;

                    bool hasFlag = false;
					if (!sourceEditWidgetContent.mVirtualCursorPos.HasValue)
					{
	                    for (int32 ofs = -1; ofs <= 0; ofs++)
	                    {
	                        if ((cursorIdx + ofs >= 0) && (cursorIdx + ofs < sourceEditWidgetContent.mData.mTextLength) &&
	                            ((sourceEditWidgetContent.mData.mText[cursorIdx + ofs].mDisplayFlags & (uint8)(SourceElementFlags.SymbolReference)) != 0))
	                            hasFlag = true;
	                    }
					}

                    if ((!hasFlag) /*|| 
                        ((!mEditWidget.mHasFocus) && (!Utils.FileNameEquals(symbolReferenceHelper.mSourceViewPanel.mFilePath, mFilePath)))*/)
                    {
						if ((symbolReferenceHelper.HasStarted) && (!symbolReferenceHelper.IsStarting))
						{
							symbolReferenceHelper.Close();
						}
						else
                        {
							//symbolReferenceHelper.mWantsClose = true;
							//Debug.WriteLine("Queued close...");
						}
                    }                    
                }
            }

			if ((gApp.mSymbolReferenceHelper != null) && (gApp.mSymbolReferenceHelper.mWantsClose) &&
				(gApp.mSymbolReferenceHelper.HasStarted) && (!gApp.mSymbolReferenceHelper.IsStarting))
			{
				gApp.mSymbolReferenceHelper.Close();
			}

			// Set this to 'false' for debugging to remove the hilighting of all symbol references under the cursor
			if (BFApp.sApp.mIsUpdateBatchStart)
            	sourceEditWidgetContent.mCursorStillTicks++;

            if ((gApp.mSettings.mEditorSettings.mHiliteCursorReferences) && (!gApp.mDeterministic) && (HasFocus(true)) &&
				((mProjectSource != null) || (mEmbedKind != .None)) /*&& (IDEApp.sApp.mSymbolReferenceHelper == null)*/)
            {
                if ((mEditWidget.mHasFocus) && (mIsBeefSource) && (sourceEditWidgetContent.mCursorStillTicks == 10) && (!sourceEditWidgetContent.mCursorImplicitlyMoved) && (!sourceEditWidgetContent.mVirtualCursorPos.HasValue))
                {
					var symbolReferenceHelper = IDEApp.sApp.mSymbolReferenceHelper;
                    if (symbolReferenceHelper == null)
                    {
						if ((compiler != null) && (!compiler.mThreadWorkerHi.mThreadRunning) && (mProjectSource != null))
						{
                        	ShowSymbolReferenceHelper(SymbolReferenceHelper.Kind.ShowFileReferences);
						}
						else
						{
							sourceEditWidgetContent.mCursorStillTicks--; // Try again later (kindof a hack)
						}
                    }
					else if (symbolReferenceHelper.mWantsClose)
					{
						//Debug.WriteLine("Delayed...");
						sourceEditWidgetContent.mCursorStillTicks--; // Try again later (kindof a hack)
					}
					else
					{
						// Still trying to show the old location
						sourceEditWidgetContent.mCursorStillTicks--; // Try again later (kindof a hack)
					}
                }

				if (sourceEditWidgetContent.mCursorStillTicks == 5)
				{
					mWantsCurrentLocation = true;
				}

				if ((mWantsCurrentLocation) && (compiler != null) && (!compiler.mThreadWorkerHi.mThreadRunning))
				{
					bool canClassify = true;
#if IDE_C_SUPPORT
	                if (mIsClang)
	                    canClassify = canDoBackground;
#endif
					if (canClassify)
					{
						Classify(ResolveType.GetCurrentLocation);
						canDoBackground = false;
						mWantsCurrentLocation = false;
					}
				}

				if ((mQueuedLocation != null) && (!compiler.IsPerformingBackgroundOperation()))
				{
					PrimaryNavigationBar.SetLocation(mQueuedLocation);
					DeleteAndNullify!(mQueuedLocation);
				}
            }

			if ((mQueuedAutoComplete != null) & (compiler != null) && (!compiler.mThreadWorkerHi.mThreadRunning))
			{
				DoAutoComplete(mQueuedAutoComplete.mKeyChar, mQueuedAutoComplete.mOptions);
				DeleteAndNullify!(mQueuedAutoComplete);
			}

			if (mLockFlashPct != 0)
			{
				mLockFlashPct += 0.02f;
				if (mLockFlashPct >= 1.0f)
					mLockFlashPct = 0;
				MarkDirty();
			}

			if ((mEmitRevision >= 0) && ((mUpdateCnt % 30) == 0))
				CheckEmitRevision();

			var ewc = (SourceEditWidgetContent)mEditWidget.Content;
			using (mMonitor.Enter())
			{
				if (mQueuedCollapseData != null)
				{
					if (gApp.mSettings.mEditorSettings.mEmitCompiler == .Build)
					{
						if (mQueuedCollapseData.mBuildData != null)
						{
							bool foundData = false;

							using (gApp.mMonitor.Enter())
							{                
							    var projectSourceCompileInstance = gApp.mWorkspace.GetProjectSourceCompileInstance(projectSource, gApp.mWorkspace.HotCompileIdx);
								if (projectSourceCompileInstance != null)
								{
									foundData = true;
									ewc.ParseCollapseRegions(mQueuedCollapseData.mBuildData, mQueuedCollapseData.mTextVersion, ref projectSourceCompileInstance.mSourceCharIdData, null);

									HashSet<EditWidgetContent.Data> dataLoaded = scope .();

									for (var embed in ewc.mEmbeds.Values)
									{
										if (var emitEmbed = embed as SourceEditWidgetContent.EmitEmbed)
										{
											if (emitEmbed.mView != null)
											{
												if (dataLoaded.Add(emitEmbed.mView.mSourceViewPanel.mEditWidget.mEditWidgetContent.mData))
												{
													emitEmbed.mView.mSourceViewPanel.mSkipFastClassify = false;
													emitEmbed.mView.mSourceViewPanel.Reload();
													emitEmbed.mView.mSourceViewPanel.mWantsFastClassify = true;
												}
											}
										}
									}
								}
							}

							if (!foundData)
							{
								for (var embed in ewc.mEmbeds.Values)
								{
									if (var emitEmbed = embed as SourceEditWidgetContent.EmitEmbed)
									{
										if (emitEmbed.mView != null)
										{
											emitEmbed.mView.mSourceViewPanel.mEditWidget.mEditWidgetContent.ClearText();
										}
									}
								}
							}
						}
					}
					
					ewc.ParseCollapseRegions(mQueuedCollapseData.mData, mQueuedCollapseData.mTextVersion, ref mQueuedCollapseData.mCharIdSpan, mQueuedCollapseData.mResolveType);
				}
				DeleteAndNullify!(mQueuedCollapseData);
			}

			UpdateQueuedEmitShowData();

			// Process after mQueuedCollapseData so mCharIdSpan is still valid
			ProcessDeferredResolveResults(0);

#if !CLI
			if (ewc.mCollapseDBDirty)
			{
				MemoryStream memStream = scope .();

				String text = scope .();
				mEditWidget.GetText(text);
				var hash = MD5.Hash(.((uint8*)text.Ptr, text.Length));
				memStream.Write(hash);

				bool hadData = false;

				for (var kv in ewc.mOrderedCollapseEntries)
				{
					if (kv.mIsOpen != kv.DefaultOpen)
					{
						hadData = true;
						memStream.Write(kv.mAnchorIdx);
					}
				}

				String filePath = scope .(mFilePath);
				IDEUtils.MakeComparableFilePath(filePath);

				if (!hadData)
					gApp.mFileRecovery.DeleteDB(filePath);
				else
					gApp.mFileRecovery.SetDB(filePath, memStream.Memory);
				ewc.mCollapseDBDirty = false;
			}
#endif
        }

		public override void UpdateF(float updatePct)
		{
			base.UpdateF(updatePct);

			var ewc = (SourceEditWidgetContent)mEditWidget.Content;
			if (ewc.mCollapseNeedsUpdate)
				ewc.UpdateCollapse(updatePct);
		}

		public void UpdateQueuedEmitShowData()
		{
			var compiler = ResolveCompiler;
			var bfSystem = BfResolveSystem;
			var ewc = (SourceEditWidgetContent)mEditWidget.Content;

			if (mQueuedEmitShowData == null)
				return;
		
			if (mQueuedEmitShowData.mTypeId == -1)
			{
				if (!compiler.IsPerformingBackgroundOperation())
				{
					var bfCompiler = compiler as BfCompiler;
					if (bfCompiler != null)
					{
						bfSystem.Lock(0);
						defer bfSystem.Unlock();

						mQueuedEmitShowData.mTypeId = (.)bfCompiler.GetTypeId(mQueuedEmitShowData.mTypeName);
					}
				}
			}

			if (mQueuedEmitShowData.mTypeId != -1)
			{
				Find: do
				{
					for (var embed in ewc.mEmbeds.Values)
					{
					 	if (var emitEmbed = embed as SourceEditWidgetContent.EmitEmbed)
						{
							if ((emitEmbed.mTypeName == mQueuedEmitShowData.mTypeName) && (mQueuedEmitShowData.mLine >= emitEmbed.mStartLine) &&
								(mQueuedEmitShowData.mLine < emitEmbed.mEndLine))
							{
								if (emitEmbed.mView == null)
								{
									emitEmbed.mIsOpen = true;
									ewc.mCollapseNeedsUpdate = true;
								}
								else
								{
									var embedEditWidget = emitEmbed.mView.mSourceViewPanel.mEditWidget;
									var embedEWC = embedEditWidget.mEditWidgetContent;
									if (embedEWC.mData.mTextLength > 0)
									{
										int idx = embedEWC.GetTextIdx(mQueuedEmitShowData.mLine, mQueuedEmitShowData.mColumn);
										emitEmbed.mView.mSourceViewPanel.FocusEdit();
										if (idx >= 0)
											emitEmbed.mView.mSourceViewPanel.ShowFileLocation(idx, .Always);
										DeleteAndNullify!(mQueuedEmitShowData);
									}
								}

								break Find;
							}
						}
					}

					// Couldn't find it even after a refresh
					if (ewc.mCollapseParseRevision > mQueuedEmitShowData.mPrevCollapseParseRevision)
						DeleteAndNullify!(mQueuedEmitShowData);
				}
			}
		}

        void InjectErrors(BfPassInstance processingPassInstance, EditWidgetContent.CharData[] processResolveCharData, IdSpan processCharIdSpan, bool keepPersistentErrors, bool filterErrors)
        {
            if (keepPersistentErrors)
            {                
                for (int errorIdx = mErrorList.Count - 1; errorIdx >= 0; errorIdx--)
                {
                    var bfError = mErrorList[errorIdx];
                    if (bfError.mIsPersistent)
                    {
                        
                    }
                    else
                    {
						delete bfError;
                        mErrorList.RemoveAt(errorIdx);                        
                    }
                }
            }
            else
            {
				ClearAndDeleteItems(mErrorList);
            }
            
            int32 errorCount = processingPassInstance.GetErrorCount();
            mErrorList.Capacity = mErrorList.Count + errorCount;

			bool hadNonDeferredErrors = false;

            for (int32 errorIdx = 0; errorIdx < errorCount; errorIdx++)
            {
                BfPassInstance.BfError bfError = new BfPassInstance.BfError();
                processingPassInstance.GetErrorData(errorIdx, bfError);

				if (filterErrors)
				{
					bool matches = Path.Equals(bfError.mFilePath, mFilePath);

					if (!matches)
					{
						delete bfError;
						continue;
					}
				}

				if (!bfError.mIsDeferred)
					hadNonDeferredErrors = true;

				for (int32 moreInfoIdx < bfError.mMoreInfoCount)
				{
					BfPassInstance.BfError moreInfo = new BfPassInstance.BfError();
					processingPassInstance.GetMoreInfoErrorData(errorIdx, moreInfoIdx, moreInfo);
					if (bfError.mMoreInfo == null)
						bfError.mMoreInfo = new List<BfPassInstance.BfError>();
					bfError.mMoreInfo.Add(moreInfo);
				}

                mErrorList.Add(bfError);
            }

            if (processResolveCharData != null)
            {
                IdSpan dupSpan = IdSpan();

                for (var bfError in mErrorList)
                {
                    int srcStart = bfError.mSrcStart;
                    int srcEnd = bfError.mSrcEnd;

                    if ((bfError.mWhileSpecializing.HasFlag(.Type)) && (mEmbedKind == .None))
					    continue;
					if ((bfError.mWhileSpecializing.HasFlag(.Method)) && (mEmbedKind != .Method))
						continue;

					if ((bfError.mIsDeferred) && (hadNonDeferredErrors))
						continue;

                    if (bfError.mIsPersistent)
                    {
                        if (bfError.mIdSpan.IsEmpty)
                        {
                            // New error - set current span
                            if (dupSpan.IsEmpty)
							{
	                        	dupSpan = processCharIdSpan.Duplicate();
								bfError.mOwnsSpan = true;
							}

                            bfError.mIdSpan = dupSpan;
                        }
                        else
                        {
                            // Old error - remap position
                            int32 startId = bfError.mIdSpan.GetIdAtIndex(srcStart);
                            int32 endId = bfError.mIdSpan.GetIdAtIndex(srcEnd);

                            srcStart = processCharIdSpan.GetIndexFromId(startId);
                            srcEnd = processCharIdSpan.GetIndexFromId(endId);
                        }
                    }

                    if (srcStart == -1)
                        continue;
                    srcEnd = Math.Min(srcEnd, processResolveCharData.Count);
                    
                    uint8 flagsOr = bfError.mIsWarning ? (uint8)SourceElementFlags.Warning : (uint8)SourceElementFlags.Error;
                    if (bfError.mIsAfter)
                        flagsOr |= (uint8)SourceElementFlags.IsAfter;                    
                    for (int i = srcStart; i < srcEnd; i++)
                        processResolveCharData[i].mDisplayFlags |= flagsOr;                    
                }
            }

			if ((mRefireMouseOverAfterRefresh) && (!mWantsFullRefresh))
			{
				mRefireMouseOverAfterRefresh = false;
				DarkTooltipManager.RefireMouseOver();
			}
        }

        void UpdateHasChangedSinceLastCompile()
        {
            mHasChangedSinceLastCompile = false;
            if (mProjectSource == null)
                return;
            int compileIdx = IDEApp.sApp.mWorkspace.GetHighestSuccessfulCompileIdx();
            var projectSourceCompileInstance = IDEApp.sApp.mWorkspace.GetProjectSourceCompileInstance(mProjectSource, compileIdx);
            if (projectSourceCompileInstance == null)
                return;
            //var sourceCharIdData = mEditWidget.Content.mTextIdData;
			mEditWidget.Content.mData.mTextIdData.Prepare();
            mHasChangedSinceLastCompile = !mEditWidget.Content.mData.mTextIdData.Equals(projectSourceCompileInstance.mSourceCharIdData);            
        }

        float GetEditX()
        {
			if ((!gApp.mSettings.mEditorSettings.mShowLineNumbers) || (mEmbedKind != .None))
				return GS!(24);

            var font = IDEApp.sApp.mTinyCodeFont;

            float lineWidth = Math.Max(font.GetWidth(ToStackString!(mEditWidget.Content.GetLineCount())) + GS!(24), GS!(32));
            return Math.Max(GS!(24), lineWidth);
        }

        protected override void ResizeComponents()
        {
			float topY = 0;
			if (mSplitBottomPanel == null)
			{
				if (mNavigationBar != null)
				{
	            	mNavigationBar.Resize(GS!(2), 0, Math.Max(mWidth - GS!(2), 0), GS!(22));
					topY = GS!(24);
				}
			}
			else
			{
				mNavigationBar?.mVisible = false;
			}

			// Always leave enough to read the first 3 lines
			if ((mHeight < GS!(88)) && (mSplitBottomPanel == null))
				mHeight = GS!(88);

			float splitterHeight = GS!(3);

			float splitTopHeight = 0;
			float splitBotHeight = Math.Max(mHeight - topY, 0);
			if (mSplitTopPanel != null)
			{
				float splitTotal = Math.Max(splitBotHeight - splitterHeight, 0);
				splitTopHeight = (int32)(splitTotal * mSplitter.mSplitPct);
				float minTopSize = 0;
				float minBotSize = GS!(64);
				splitTopHeight = Math.Clamp(splitTopHeight, minTopSize, Math.Max(splitTotal - minBotSize, 0));
				splitBotHeight = Math.Max(splitTotal - splitTopHeight, 0);
			}

			if (mSplitTopPanel != null)
			{								
				mSplitTopPanel.Resize(0, topY, mWidth, splitTopHeight);
				mSplitter.Resize(0, topY + splitTopHeight - 1, mWidth, splitterHeight + 2);
				topY += splitTopHeight + splitterHeight;
			}
			else if (mSplitTopPanel == null)
			{
				mSplitter?.Resize(mWidth - GS!(20), GS!(22 - 1), GS!(20), splitterHeight + GS!(2));
			}						

			mSplitter?.SetVisible(mPanelHeader == null);

            float editX = GetEditX();
            if (mPanelHeader != null)
            {
                mPanelHeader.Resize(editX, topY, mWidth - editX, GS!(mPanelHeader.mBaseHeight));
                mEditWidget.Resize(editX, topY + GS!(mPanelHeader.mBaseHeight), mWidth - editX, splitBotHeight - GS!(mPanelHeader.mBaseHeight));
            }
            else
                mEditWidget.Resize(editX, topY, Math.Max(mWidth - editX, 0), splitBotHeight);
			mEditWidget.SetVisible(mEditWidget.mHeight > 0);
			mEditWidget.mClipGfx = mEditWidget.mHeight < GS!(20);

            float rightCornerY = mEditWidget.mY + GS!(2);

            if (mRenameSymbolDialog != null)
            {
                float renameWidth = GS!(240);
                float renameHeight = GS!(56);
                mRenameSymbolDialog.Resize(mWidth - renameWidth - GS!(10), mEditWidget.mY + GS!(2), renameWidth, renameHeight);
                rightCornerY += renameHeight + GS!(20);
            }

            if (mQuickFind != null)
            {
                /*float findWidth = GS!(200);
                float findHeight = mQuickFind.mIsReplace ? GS!(84) : GS!(58);
                mQuickFind.Resize(mWidth - findWidth - GS!(10), mEditWidget.mY + GS!(2), findWidth, findHeight);*/
				mQuickFind.ResizeSelf();
                //rightCornerY += findHeight + GS!(20);
            }

            if (mOldVersionPanel != null)    
			{	        	
	        	mOldVersionPanel.Resize(0, 0, mWidth, mHeight);
				if (mSplitTopPanel != null)
					mSplitTopPanel.mVisible = false;
				mEditWidget.mVisible = false;
			}
			else if (mSplitTopPanel != null)
			{
				mSplitTopPanel.mVisible = true;
				mEditWidget.mVisible = true;

				//Why did we have this? There were some cases where some text was "peeking through" something, but setting this to false
				// breaks the normal split-window functionality
				//mEditWidget.mVisible = false;
			}
        }        

		public override void MouseDown(float x, float y, int32 btn, int32 btnCount)
		{
			base.MouseDown(x, y, btn, btnCount);

			var ewc = (SourceEditWidgetContent)mEditWidget.Content;

			if ((btn == 0) && (x >= mEditWidget.mX - GS!(13)) && (x < mEditWidget.mX - GS!(0)) && (y < mHeight - GS!(20)))
			{
				int lineClick = GetLineAt(0, y);
				if (lineClick >= mCollapseRegionView.mLineStart)
				{
					int relLine = lineClick - mCollapseRegionView.mLineStart;
					if ((relLine < mCollapseRegionView.mCollapseIndices.Count) && (!ewc.mOrderedCollapseEntries.IsEmpty))
					{
						uint32 collapseVal = mCollapseRegionView.mCollapseIndices[relLine];
						if ((((collapseVal & CollapseRegionView.cStartFlag) != 0) && (btnCount == 1)) ||
							(btnCount > 1))
						{
							int collapseIndex = collapseVal & CollapseRegionView.cIdMask;

							var entry = ewc.mOrderedCollapseEntries[collapseIndex];
							ewc.SetCollapseOpen(collapseIndex, !entry.mIsOpen);
						}
						return;
					}
				}
			}

			if (mSplitBottomPanel != null)
			{
				return;
			}

			float lockX = mEditWidget.mX - GS!(20);
			float lockY = mHeight - GS!(20);

			if ((mEmbedKind == .None) && (Rect(lockX, lockY, GS!(20), GS!(20)).Contains(x, y)))
			{
				Menu menu = new Menu();
				var menuItem = menu.AddItem("Lock Editing");
				if (gApp.mSettings.mEditorSettings.mLockEditing)
					menuItem.mIconImage = DarkTheme.sDarkTheme.GetImage(.Check);
				menuItem.mOnMenuItemSelected.Add(new (evt) =>
					{
						gApp.mSettings.mEditorSettings.mLockEditing = !gApp.mSettings.mEditorSettings.mLockEditing;
					});

				if (mProjectSource != null)
				{
					menuItem = menu.AddItem("Lock Project");
					if (mProjectSource.mProject.mLocked)
						menuItem.mIconImage = DarkTheme.sDarkTheme.GetImage(.Check);
					menuItem.mOnMenuItemSelected.Add(new (item) =>
						{
							if (mProjectSource.mProject.mLocked && mProjectSource.mProject.mLockedDefault)
							{
								let dialog = new DarkDialog("Unlock Project?",
									"This project is locked because it may be a shared library, and editing shared libraries may have unwanted effects on other programs that use it.\n\nAre you sure you want to unlock it?",
									DarkTheme.sDarkTheme.mIconWarning);
								dialog.mWindowFlags |= .Modal;
								dialog.AddYesNoButtons(new (dlg) =>
									{
										mProjectSource.mProject.mLocked = false;
										gApp.mWorkspace.SetChanged();
									});
								dialog.PopupWindow(mWidgetWindow);
								return;
							}
							mProjectSource.mProject.mLocked = !mProjectSource.mProject.mLocked;
							gApp.mWorkspace.SetChanged();
						});
				}

				menuItem = menu.AddItem("Lock while Debugging");
				void AddLockType(String name, Settings.EditorSettings.LockWhileDebuggingKind kind)
				{
					var subItem = menuItem.AddItem(name);
					if (gApp.mSettings.mEditorSettings.mLockEditingWhenDebugging == kind)
						subItem.mIconImage = DarkTheme.sDarkTheme.GetImage(.Check);
					subItem.mOnMenuItemSelected.Add(new (evt) =>
						{
							gApp.mSettings.mEditorSettings.mLockEditingWhenDebugging = kind;
						});
				}

				AddLockType("Never", .Never);
				AddLockType("Always", .Always);
				AddLockType("When not Hot Swappable", .WhenNotHotSwappable);

				MenuWidget menuWidget = DarkTheme.sDarkTheme.CreateMenuWidget(menu);
				menuWidget.Init(this, x, y, .AllowScrollable);
			}
		}

		public override void MouseUp(float x, float y, int32 btn)
		{
			base.MouseUp(x, y, btn);

			if (mIsDraggingLinePointer)
			{
				mIsDraggingLinePointer = false;

				float origX;
				float origY;
				RootToSelfTranslate(mWidgetWindow.mMouseDownX, mWidgetWindow.mMouseDownY, out origX, out origY);

				int newLine = GetLineAt(0, y);
				if (newLine >= 0 && newLine != GetLineAt(origX, origY))
				{
					gApp.mDebugger.SetNextStatement(false, mFilePath, (int)newLine, 0);

					gApp.[Friend]PCChanged();
					gApp.[Friend]DebuggerUnpaused();
				}
			}
		}

		public int GetLineAt(float x, float y)
		{
			if (x > mEditWidget.mX - GS!(4))
				return -1;

			var ewc = (SourceEditWidgetContent)mEditWidget.Content;

			float relY = y - mEditWidget.mY - mEditWidget.Content.Y - GS!(3);
			if (relY < 0)
				return -1;
			int resultIdx = ewc.mLineCoords.BinarySearch(relY);
			if (resultIdx < 0)
				return ~resultIdx - 1;
			return resultIdx;
		}

		public bool SelectBreakpointsAtLine(int selectLine)
		{
			if (selectLine == -1)
				return false;

			HashSet<Breakpoint> selectedBreakpoints = scope HashSet<Breakpoint>();

			for (var breakpointView in GetTrackedElementList())
			{
			    var trackedElement = breakpointView.mTrackedElement;
			    var breakpoint = trackedElement as Breakpoint;
			    if (breakpoint != null)
			    {
					int drawLineNum = RemapActiveLineToHotLine(breakpoint.mLineNum);
					if (selectLine == drawLineNum)
					{
						selectedBreakpoints.Add(breakpoint);
					}
				}
			}

			if (selectedBreakpoints.IsEmpty)
				return false;
			
			gApp.mBreakpointPanel.Update();
			gApp.mBreakpointPanel.SelectBreakpoints(selectedBreakpoints);
			return true;
		}

		public override void MouseClicked(float x, float y, float origX, float origY, int32 btn)
		{
			base.MouseClicked(x, y, origX, origY, btn);

			if (btn == 0)
			{
				if ((x >= GS!(3)) && (x < mEditWidget.mX - GS!(14)))
				{
					int lineMouseDown = GetLineAt(origX, origY);
					int lineClick = GetLineAt(x, y);
					if (lineClick >= 0 && lineMouseDown == lineClick)
					{
						ToggleBreakpointAt(lineClick, 0);
					}
					return;
				}
			}

			if (btn == 1)
			{
				int lineClick = GetLineAt(x, y);
				if (SelectBreakpointsAtLine(lineClick))
				{
#unwarn
					var menuWidget = gApp.mBreakpointPanel.ShowRightClickMenu(this, x, y, true);
				}
			}
		}

		public override void MouseLeave()
		{
			base.MouseLeave();
			mMousePos = null;
		}

		public override void MouseMove(float x, float y)
		{
			base.MouseMove(x, y);
			mMousePos = .(x, y);

			if (!mIsDraggingLinePointer && IDEApp.sApp.mExecutionPaused && gApp.mDebugger.mActiveCallStackIdx == 0 && mMouseFlags.HasFlag(.Left))
			{         
				SourceEditWidgetContent ewc = (.)mEditWidget.Content;
				Rect linePointerRect = .(
					mEditWidget.mX - GS!(20) - sDrawLeftAdjust,
					0 + ewc.GetLineY(mLinePointerDrawData.mLine, 0),
					GS!(15),
					GS!(15)
				);

				float origX;
                float origY;
                RootToSelfTranslate(mWidgetWindow.mMouseDownX, mWidgetWindow.mMouseDownY, out origX, out origY);

				if (linePointerRect.Contains(origX, origY - mEditWidget.mY - mEditWidget.Content.Y - GS!(3)))
				{
					mIsDraggingLinePointer = true;
				}
			}
			else if (mIsDraggingLinePointer)
			{
				SourceEditWidgetContent ewc = (.)mEditWidget.Content;
				float linePos = ewc.GetLineY(GetLineAt(0, mMousePos.Value.y), 0);
				Rect visibleRange = mEditWidget.GetVisibleContentRange();

				if (visibleRange.Top > linePos)
					mEditWidget.mVertScrollbar.ScrollTo(linePos);
				else if (visibleRange.Bottom - mEditWidget.mHorzScrollbar.mHeight < linePos)
					mEditWidget.mVertScrollbar.ScrollTo(linePos - visibleRange.mHeight + ewc.GetLineHeight(0));
			}
		}

        public override void DrawAll(Graphics g)
        {
			DarkEditWidgetContent darkEditWidgetContent = (DarkEditWidgetContent)mEditWidget.Content;
			darkEditWidgetContent.mViewWhiteSpaceColor = gApp.mViewWhiteSpace.Bool ? darkEditWidgetContent.mTextColors[(int)SourceElementType.VisibleWhiteSpace] : 0;

			/*using (g.PushColor(0x50FFFFFF))
				g.FillRect(0, 0, mWidth, mHeight);*/

            //IDEApp.sApp.mBfResolveSystem.PerfZoneStart("SourceViewPanel.DrawAll");
            base.DrawAll(g);            

            if (mHotFileIdx != -1)
            {                
                /*using (g.PushColor(0x50D0D0D0))                
                    g.FillRect(0, 0, mWidth, mHeight);*/
            }

            //using (g.PushClip(0, 0, mWidth, mHeight))
            //{
            //    using (g.PushTranslate(0, mEditWidget.Content.Y))
            //    {
            //        foreach (var breakpointView in GetTrackedElementList())
            //        {
            //            /*var breakpoint = breakpointView.mTrackedElement as Breakpoint;
            //            using (g.PushColor((breakpoint.GetAddress() != 0) ? Color.White : 0x8080FFFF))
            //            {                            
            //                var sourceEditWidgetContent = (SourceEditWidgetContent)mEditWidget.Content;
            //                float breakX;
            //                float breakY;
            //                sourceEditWidgetContent.GetTextCoordAtLineChar(breakpoint.mLineNum, breakpoint.mColumn, out breakX, out breakY);
            //                g.Draw(DarkTheme.sDarkTheme.GetImage(DarkTheme.ImageIdx.RedDot), mEditWidget.mX + breakX, mEditWidget.mY + breakY);
            //            }*/

            //            var historyEntry = breakpointView.mTrackedElement as HistoryEntry;
            //            if (historyEntry != null)
            //            {
            //                using (g.PushColor(0x8080FFFF))
            //                {
            //                    var sourceEditWidgetContent = (SourceEditWidgetContent)mEditWidget.Content;
            //                    float breakX;
            //                    float breakY;
            //                    sourceEditWidgetContent.GetTextCoordAtLineChar(historyEntry.mLineNum, historyEntry.mColumn, out breakX, out breakY);
            //                    g.Draw(DarkTheme.sDarkTheme.GetImage(DarkTheme.ImageIdx.IconBookmark), mEditWidget.mX + breakX, mEditWidget.mY + breakY);
            //                }
            //            }
            //        }
            //    }
            //}

            //IDEApp.sApp.mBfResolveSystem.PerfZoneEnd();
        }
		

		public void WithTrackedElementsAtCursor<T>(List<T> trackedElementList, delegate void(T) func) where T : TrackedTextElement
		{
		    int lineIdx;
		    int lineCharIdx;
		    mEditWidget.Content.GetLineCharAtIdx(mEditWidget.Content.CursorTextPos, out lineIdx, out lineCharIdx);

		    int32 idx = 0;            
		    while (idx < trackedElementList.Count)
		    {
		        var trackedElement = trackedElementList[idx];
		        if (trackedElement.mLineNum == lineIdx)
		        {
		            int prevSize = trackedElementList.Count;
		            func(trackedElement);                    
		            if (trackedElementList.Count >= prevSize)
		                idx++;
		        }
		        else
		            idx++;
		    }
		}

		public bool HasTextAtCursor()
		{
			let ewc = mEditWidget.mEditWidgetContent;
			int textPos = mEditWidget.mEditWidgetContent.CursorTextPos;
			if (textPos >= ewc.mData.mTextLength)
				return false;

			for (int offset = -1; offset <= 0; offset++)
			{
				int checkPos = textPos + offset;
				if (checkPos < 0)
					continue;

				let c = ewc.mData.mText[checkPos].mChar;
				if ((c.IsLetterOrDigit) || (c == '_') || (c == '@'))
					return true;
				if ((offset == 0) && (c == '.'))
					return true;
				let elementType = (SourceElementType)ewc.mData.mText[checkPos].mDisplayTypeId;
				if (elementType == .Method)
					return true;
			}

			return false;
		}

		public void CheckEmitRevision()
		{
			if (mEmitRevision != -1)
			{
				var compiler = gApp.mBfResolveCompiler;

				if ((compiler != null) && (!compiler.IsPerformingBackgroundOperation()))
				{
					compiler.mBfSystem.Lock(0);
					int32 version = compiler.GetEmitVersion(mFilePath);
					compiler.mBfSystem.Unlock();

					if ((version >= 0) && (version != mEmitRevision))
					{
						mEmitRevision = version;
						Reload();
					}
				}
			}
		}

		public SourceViewPanel GetFocusedEmbeddedView()
		{
			if (mEditWidget.mHasFocus)
				return this;

			var editWidget = mWidgetWindow.mFocusWidget as SourceEditWidget;
			if (editWidget != null)
			{
				var sewc = editWidget.mEditWidgetContent as SourceEditWidgetContent;
				if (sewc.mSourceViewPanel?.mEmbedParent == this)
					return sewc.mSourceViewPanel;
			}

			return this;
		}

		public bool AddExplicitEmitType(StringView typeName)
		{
			for (var checkTypeName in mExplicitEmitTypes)
			{
				if (IDEUtils.GenericEquals(checkTypeName, typeName))
				{
					if (checkTypeName == typeName)
						return false;

					checkTypeName.Set(typeName);
					return true;
				}
			}

			mExplicitEmitTypes.Add(new .(typeName));
			return true;
		}
    }
}