Datasets:

introvoyz041
/

Dwsim

﻿// Copyright (c) 2010 Joe Moorhouse

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Threading;
using Microsoft.Scripting.Hosting.Shell;
using System.Windows.Input;
using Microsoft.Scripting;
using IronPython.Hosting;
using IronPython.Runtime;
using Microsoft.Scripting.Hosting;
using Microsoft.Scripting.Hosting.Providers;
using System.Diagnostics;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Threading;
using System.Windows.Documents;
using ICSharpCode.AvalonEdit.Editing;
using ICSharpCode.AvalonEdit.Document;
using ICSharpCode.AvalonEdit.Highlighting;
using ICSharpCode.AvalonEdit.Utils;
using Style = Microsoft.Scripting.Hosting.Shell.Style;

public class TextEventArgs : EventArgs
{
    public TextEventArgs(string text)
    {
        Text = text;
    }

    public string Text { get;  }

}


namespace PythonConsoleControl
{
    public delegate void ConsoleInitializedEventHandler(object sender, EventArgs e);
    
    /// <summary>
    /// Custom IronPython console. The command dispacher runs on a separate UI thread from the REPL
    /// and also from the WPF control.
    /// </summary>
    public class PythonConsole : IConsole, IDisposable
    {
        bool allowFullAutocompletion = true;
        public bool AllowFullAutocompletion
        {
            get { return allowFullAutocompletion; }
            set { allowFullAutocompletion = value; }
        }

        bool disableAutocompletionForCallables = true;
        public bool DisableAutocompletionForCallables
        {
            get { return disableAutocompletionForCallables; }
            set 
            {
                if (textEditor.CompletionProvider != null) textEditor.CompletionProvider.ExcludeCallables = value;
                disableAutocompletionForCallables = value; 
            }
        }

        bool allowCtrlSpaceAutocompletion = false;
        public bool AllowCtrlSpaceAutocompletion
        {
            get { return allowCtrlSpaceAutocompletion; }
            set { allowCtrlSpaceAutocompletion = value; }
        }

        public Action<ScriptScope> UpdateVariables { get; set; }
        
        PythonTextEditor textEditor;
        int lineReceivedEventIndex = 0; // The index into the waitHandles array where the lineReceivedEvent is stored.
        ManualResetEvent lineReceivedEvent = new ManualResetEvent(false);
        ManualResetEvent disposedEvent = new ManualResetEvent(false);
        AutoResetEvent statementsExecutionRequestedEvent = new AutoResetEvent(false);
        WaitHandle[] waitHandles;
        int promptLength = 4;
        List<string> previousLines = new List<string>();
        CommandLine commandLine;
        CommandLineHistory commandLineHistory = new CommandLineHistory();

        volatile bool _executing = false;

        // This is the thread upon which all commands execute unless the dipatcher is overridden.
        Thread dispatcherThread;
        Window dispatcherWindow;
        Dispatcher dispatcher;

        bool consoleInitialized = false;
        string prompt;
        private DateTime _lastWrite;
        private Style _lastStyle;

        public event ConsoleInitializedEventHandler ConsoleInitialized;
        public event EventHandler<EventArgs> ScriptStarting;
        public event EventHandler<EventArgs> ScriptFinished;
        public event EventHandler<TextEventArgs> Error;

        public ScriptScope ScriptScope
        {
            get { return commandLine.ScriptScope; }
        }

        public PythonConsole(PythonTextEditor textEditor, CommandLine commandLine)
        {   
            waitHandles = new WaitHandle[] { lineReceivedEvent, disposedEvent };

            this.commandLine = commandLine;
            this.textEditor = textEditor;
            textEditor.CompletionProvider = new PythonConsoleCompletionDataProvider(commandLine) { ExcludeCallables = disableAutocompletionForCallables };
            textEditor.PreviewKeyDown += textEditor_PreviewKeyDown;
            textEditor.TextEntering += textEditor_TextEntering;
            dispatcherThread = new Thread(new ThreadStart(DispatcherThreadStartingPoint));
            dispatcherThread.SetApartmentState(ApartmentState.STA);
            dispatcherThread.IsBackground = true;
            dispatcherThread.Start();

            // Only required when running outside REP loop.
            prompt = ">>> ";

            // Set commands:
            this.textEditor.textArea.Dispatcher.Invoke(new Action(delegate()
            {
                CommandBinding pasteBinding = null;
                CommandBinding copyBinding = null;
                CommandBinding cutBinding = null;
                CommandBinding undoBinding = null;
                CommandBinding deleteBinding = null;
                foreach (CommandBinding commandBinding in (this.textEditor.textArea.CommandBindings))
                {
                    if (commandBinding.Command == ApplicationCommands.Paste) pasteBinding = commandBinding;
                    if (commandBinding.Command == ApplicationCommands.Copy) copyBinding = commandBinding;
                    if (commandBinding.Command == ApplicationCommands.Cut) cutBinding = commandBinding;
                    if (commandBinding.Command == ApplicationCommands.Undo) undoBinding = commandBinding;
                    if (commandBinding.Command == ApplicationCommands.Delete) deleteBinding = commandBinding;
                }
                // Remove current bindings completely from control. These are static so modifying them will cause other
                // controls' behaviour to change too.
                if (pasteBinding != null) this.textEditor.textArea.CommandBindings.Remove(pasteBinding);
                if (copyBinding != null) this.textEditor.textArea.CommandBindings.Remove(copyBinding);
                if (cutBinding != null) this.textEditor.textArea.CommandBindings.Remove(cutBinding);
                if (undoBinding != null) this.textEditor.textArea.CommandBindings.Remove(undoBinding);
                if (deleteBinding != null) this.textEditor.textArea.CommandBindings.Remove(deleteBinding);
                this.textEditor.textArea.CommandBindings.Add(new CommandBinding(ApplicationCommands.Paste, OnPaste, CanPaste));
                this.textEditor.textArea.CommandBindings.Add(new CommandBinding(ApplicationCommands.Copy, OnCopy, PythonEditingCommandHandler.CanCutOrCopy));
                this.textEditor.textArea.CommandBindings.Add(new CommandBinding(ApplicationCommands.Cut, PythonEditingCommandHandler.OnCut, CanCut));
                this.textEditor.textArea.CommandBindings.Add(new CommandBinding(ApplicationCommands.Undo, OnUndo, CanUndo));
                this.textEditor.textArea.CommandBindings.Add(new CommandBinding(ApplicationCommands.Delete, PythonEditingCommandHandler.OnDelete(ApplicationCommands.NotACommand), CanDeleteCommand));
			
            }));
            CodeContext codeContext = DefaultContext.Default;
            // Set dispatcher to run on a UI thread independent of both the Control UI thread and thread running the REPL.
            ClrModule.SetCommandDispatcher(codeContext, DispatchCommand);
        }

        protected void DispatchCommand(Delegate command)
        {
            if (command != null)
            {
                // Slightly involved form to enable keyboard interrupt to work.
                Executing = true;
                var operation = dispatcher.BeginInvoke(DispatcherPriority.Normal, command);
                while (Executing)
                {
                    if (operation.Status != DispatcherOperationStatus.Completed) 
                        operation.Wait(TimeSpan.FromSeconds(1));
                    if (operation.Status == DispatcherOperationStatus.Completed)
                        Executing = false;
                }
            }
        }

        private void DispatcherThreadStartingPoint()
        {
            dispatcherWindow = new Window();
            dispatcher = dispatcherWindow.Dispatcher;
            while (true)
            {
                try
                {
                    System.Windows.Threading.Dispatcher.Run();
                }
                catch (ThreadAbortException tae)
                {
                    if (tae.ExceptionState is Microsoft.Scripting.KeyboardInterruptException)
                    {
                        Thread.ResetAbort();
                        Executing = false;
                    }
                }
            }
        }

        public void SetDispatcher(Dispatcher dispatcher)
        {
            this.dispatcher = dispatcher;
        }

        public void Dispose()
        {
            disposedEvent.Set();
            textEditor.PreviewKeyDown -= textEditor_PreviewKeyDown;
            textEditor.TextEntering -= textEditor_TextEntering;
        }

        public TextWriter Output
        {
            get { return null; }
            set { }
        }

        public TextWriter ErrorOutput
        {
            get { return null; }
            set { }
        }

        #region CommandHandling
        protected void CanPaste(object target, CanExecuteRoutedEventArgs args)
        {
            if (IsInReadOnlyRegion)
            {
                args.CanExecute = false;
            }
            else
                args.CanExecute = true;
        }

        protected void CanCut(object target, CanExecuteRoutedEventArgs args)
        {
            if (!CanDelete)
            {
                args.CanExecute = false;
            }
            else
                PythonEditingCommandHandler.CanCutOrCopy(target, args);
        }

        protected void CanDeleteCommand(object target, CanExecuteRoutedEventArgs args)
        {
            if (!CanDelete)
            {
                args.CanExecute = false;
            }
            else
                PythonEditingCommandHandler.CanDelete(target, args);
        }

        protected void CanUndo(object target, CanExecuteRoutedEventArgs args)
        {
            args.CanExecute = false;
        }

        protected void OnPaste(object target, ExecutedRoutedEventArgs args)
        {
            if (target != textEditor.textArea) return;
            TextArea textArea = textEditor.textArea;
            if (textArea != null && textArea.Document != null)
            {
                Debug.WriteLine(Clipboard.GetText(TextDataFormat.Html));

                // convert text back to correct newlines for this document
                string newLine = TextUtilities.GetNewLineFromDocument(textArea.Document, textArea.Caret.Line);
                string text = TextUtilities.NormalizeNewLines(Clipboard.GetText(), newLine);
                string[] commands = text.Split(new String[] {newLine}, StringSplitOptions.None);
                string scriptText = "";
                if (commands.Length > 1)
                {
                    text = newLine;
                    foreach (string command in commands)
                    {
                        text += "... " + command + newLine;
                        scriptText += command.Replace("\t", "   ") + newLine;
                    }
                }

                if (!string.IsNullOrEmpty(text))
                {
                    bool fullLine = textArea.Options.CutCopyWholeLine && Clipboard.ContainsData(LineSelectedType);
                    bool rectangular = Clipboard.ContainsData(RectangleSelection.RectangularSelectionDataType);
                    if (fullLine)
                    {
                        DocumentLine currentLine = textArea.Document.GetLineByNumber(textArea.Caret.Line);
                        if (textArea.ReadOnlySectionProvider.CanInsert(currentLine.Offset))
                        {
                            textArea.Document.Insert(currentLine.Offset, text);
                        }
                    }
                    else if (rectangular && textArea.Selection.IsEmpty)
                    {
                        if (!RectangleSelection.PerformRectangularPaste(textArea, textArea.Caret.Position, text, false))
                            textEditor.Write(text, false);
                    }
                    else
                    {
                        textEditor.Write(text, false);
                    }
                }
                textArea.Caret.BringCaretToView();
                args.Handled = true;

                if (commands.Length > 1)
                {
                    dispatcherWindow.Dispatcher.BeginInvoke(new Action(delegate() { ExecuteStatements(scriptText); }));
                }
            }
        }

        protected void OnCopy(object target, ExecutedRoutedEventArgs args)
        {
            if (target != textEditor.textArea) return;
            if (textEditor.SelectionLength == 0 && Executing)
            {
                // Send the 'Ctrl-C' abort 
                //if (!IsInReadOnlyRegion)
                //{
                    MoveToHomePosition();
                    //textEditor.Column = GetLastTextEditorLine().Length + 1;
                    //textEditor.Write(Environment.NewLine);
                //}
                AbortRunningScript();
                args.Handled = true;
            }
            else PythonEditingCommandHandler.OnCopy(target, args);
        }

        public void AbortRunningScript()
        {
            if (Executing)
                dispatcherThread.Abort(new KeyboardInterruptException(""));
        }

        const string LineSelectedType = "MSDEVLineSelect";  // This is the type VS 2003 and 2005 use for flagging a whole line copy

        protected void OnUndo(object target, ExecutedRoutedEventArgs args)
        {
        }
        #endregion

        /// <summary>
        /// Run externally provided statements in the Console Engine. 
        /// </summary>
        /// <param name="statements"></param>
        public void RunStatements(string statements)
        {
            MoveToHomePosition();
           
            dispatcher.BeginInvoke(new Action(delegate() { ExecuteStatements(statements); }));
        }

        /// <summary>
        /// Run externally provided statements in the Console Engine. 
        /// </summary>
        /// <param name="statements"></param>
        public void RunStatementsSync(string statements)
        {
            MoveToHomePosition();

            using (var evt = new AutoResetEvent(false))
            {
                

                dispatcher.BeginInvoke(new Action(delegate()
                {
                    try
                    {
                        ExecuteStatements(statements);
                    }
                    finally
                    {
                        evt.Set();
                    }
                }));

                while (true)
                {
                    if (evt.WaitOne(1))
                        break;

                    System.Windows.Forms.Application.DoEvents();
                }

            }
        }

        /// <summary>
        /// Run on the statement execution thread. 
        /// </summary>
        void ExecuteStatements(string scriptText)
        {
            UpdateVariables?.Invoke(commandLine.ScriptScope);
            lock (scriptText)
            {
                textEditor.Write("\r\n");
                ScriptSource scriptSource = commandLine.ScriptScope.Engine.CreateScriptSourceFromString(scriptText, SourceCodeKind.Statements);
                string error = "";
                try
                {
                    Executing = true;
                    scriptSource.Execute(commandLine.ScriptScope);
                }
                catch (ThreadAbortException tae)
                {
                    if (tae.ExceptionState is Microsoft.Scripting.KeyboardInterruptException) Thread.ResetAbort();
                    error = "KeyboardInterrupt" + System.Environment.NewLine;
                }
                catch (Microsoft.Scripting.SyntaxErrorException exception)
                {
                    ExceptionOperations eo;
                    eo = commandLine.ScriptScope.Engine.GetService<ExceptionOperations>();
                    error = eo.FormatException(exception);
                }
                catch (Exception exception)
                {
                    ExceptionOperations eo;
                    eo = commandLine.ScriptScope.Engine.GetService<ExceptionOperations>();
                    error = eo.FormatException(exception) + System.Environment.NewLine;
                }
                Executing = false;
                if (error != "")
                {
                    textEditor.Write(error);
                    OnError(new TextEventArgs(error));
                }
                textEditor.Write(prompt);
            }
        }

        /// <summary>
        /// Returns the next line typed in by the console user. If no line is available this method
        /// will block.
        /// </summary>
        public string ReadLine(int autoIndentSize)
        {
            string indent = String.Empty;
            if (autoIndentSize > 0)
            {
                indent = String.Empty.PadLeft(autoIndentSize);
                Write(indent, Style.Prompt);
            }

            string line = ReadLineFromTextEditor();
            if (line != null)
            {
                return indent + line;
            }
            return null;
        }

        /// <summary>
        /// Writes text to the console.
        /// </summary>
        public void Write(string text, Style style)
        {
            textEditor.Write(text);
            if (style == Style.Prompt)
            {
                promptLength = text.Length;
                if (!consoleInitialized)
                {
                    consoleInitialized = true;
                    if (ConsoleInitialized != null) ConsoleInitialized(this, EventArgs.Empty);
                }
            }


            _lastStyle = style;
        }

        private void AddPrompt()
        {
            if ((DateTime.UtcNow - _lastWrite).TotalSeconds > 1)
            {
                //textEditor.Write(prompt);
                _lastWrite = DateTime.UtcNow;
            }
        }

        /// <summary>
        /// Writes text followed by a newline to the console.
        /// </summary>
        public void WriteLine(string text, Style style)
        {
            Write(text + Environment.NewLine, style);
        }

        /// <summary>
        /// Writes an empty line to the console.
        /// </summary>
        public void WriteLine()
        {
            Write(Environment.NewLine, Style.Out);
        }

        /// <summary>
        /// Indicates whether there is a line already read by the console and waiting to be processed.
        /// </summary>
        public bool IsLineAvailable
        {
            get
            {
                lock (previousLines)
                {
                    return previousLines.Count > 0;
                }
            }
        }

        /// <summary>
        /// Gets the text that is yet to be processed from the console. This is the text that is being
        /// typed in by the user who has not yet pressed the enter key.
        /// </summary>
        public string GetCurrentLine()
        {
            string fullLine = GetLastTextEditorLine();
            return fullLine.Substring(promptLength);
        }

        /// <summary>
        /// Gets the lines that have not been returned by the ReadLine method. This does not
        /// include the current line.
        /// </summary>
        public string[] GetUnreadLines()
        {
            return previousLines.ToArray();
        }

        string GetLastTextEditorLine()
        {
            return textEditor.GetLine(textEditor.TotalLines - 1);
        }

        string ReadLineFromTextEditor()
        {
            int result = WaitHandle.WaitAny(waitHandles);
            if (result == lineReceivedEventIndex)
            {
                lock (previousLines)
                {
                    string line = previousLines[0];
                    previousLines.RemoveAt(0);
                    if (previousLines.Count == 0)
                    {
                        lineReceivedEvent.Reset();
                    }
                    return line;
                }
            }
            return null;
        }

        /// <summary>
        /// Processes characters entered into the text editor by the user.
        /// </summary>
        void textEditor_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            switch (e.Key)
            {
                case Key.Delete:
                    if (!CanDelete) e.Handled = true;
                    return;
                case Key.Tab:
                    if (IsInReadOnlyRegion) e.Handled = true;
                    return;
                case Key.Back:
                    if (!CanBackspace) e.Handled = true;
                    return;
                case Key.Home:
                    MoveToHomePosition();
                    e.Handled = true;
                    return;
                case Key.Down:
                    if (!IsInReadOnlyRegion) MoveToNextCommandLine();
                    e.Handled = true;
                    return;
                case Key.Up:
                    if (!IsInReadOnlyRegion) MoveToPreviousCommandLine();
                    e.Handled = true;
                    return;
            }
        }

        /// <summary>
        /// Processes characters entering into the text editor by the user.
        /// </summary>
        void textEditor_TextEntering(object sender, TextCompositionEventArgs e)
        {
            if (e.Text.Length > 0)
            {
                if (!char.IsLetterOrDigit(e.Text[0]))
                {
                    // Whenever a non-letter is typed while the completion window is open,
                    // insert the currently selected element.
                    textEditor.RequestCompletioninsertion(e);
                }
            }

            if (IsInReadOnlyRegion)
            {
                e.Handled = true;
            }
            else
            {
                if (e.Text[0] == '\n')
                {
                    UpdateVariables?.Invoke(commandLine.ScriptScope);
                    OnEnterKeyPressed();
                }

                if (e.Text[0] == '.' && allowFullAutocompletion)
                {
                    textEditor.ShowCompletionWindow();
                }

                if ((e.Text[0] == ' ') && (Keyboard.Modifiers == ModifierKeys.Control))
                {
                    e.Handled = true;
                    if (allowCtrlSpaceAutocompletion) textEditor.ShowCompletionWindow();
                }
            }
        }

        /// <summary>
        /// Move cursor to the end of the line before retrieving the line.
        /// </summary>
        void OnEnterKeyPressed()
        {
            textEditor.StopCompletion();
            if (textEditor.WriteInProgress) return;
            lock (previousLines)
            {
                // Move cursor to the end of the line.
                textEditor.Column = GetLastTextEditorLine().Length + 1;

                // Append line.
                string currentLine = GetCurrentLine();
                previousLines.Add(currentLine);
                commandLineHistory.Add(currentLine);

                lineReceivedEvent.Set();
            }
        }

        /// <summary>
        /// Returns true if the cursor is in a readonly text editor region.
        /// </summary>
        bool IsInReadOnlyRegion
        {
            get { return IsCurrentLineReadOnly || IsInPrompt; }
        }

        /// <summary>
        /// Only the last line in the text editor is not read only.
        /// </summary>
        bool IsCurrentLineReadOnly
        {
            get { return textEditor.Line < textEditor.TotalLines; }
        }

        /// <summary>
        /// Determines whether the current cursor position is in a prompt.
        /// </summary>
        bool IsInPrompt
        {
            get { return textEditor.Column - promptLength - 1 < 0; }
        }

        /// <summary>
        /// Returns true if the user can delete at the current cursor position.
        /// </summary>
        bool CanDelete
        {
            get
            {
                if (textEditor.SelectionLength > 0) return SelectionIsDeletable;
                else return !IsInReadOnlyRegion;
            }
        }

        /// <summary>
        /// Returns true if the user can backspace at the current cursor position.
        /// </summary>
        bool CanBackspace
        {
            get
            {
                if (textEditor.SelectionLength > 0) return SelectionIsDeletable;
                else
                {
                    int cursorIndex = textEditor.Column - promptLength - 1;
                    return !IsCurrentLineReadOnly && (cursorIndex > 0 || (cursorIndex == 0 && textEditor.SelectionLength > 0));
                }
            }
        }

        bool SelectionIsDeletable
        {
            get
            {
                return (!textEditor.SelectionIsMultiline
                    && !IsCurrentLineReadOnly
                    && (textEditor.SelectionStartColumn - promptLength - 1 >= 0)
                    && (textEditor.SelectionEndColumn - promptLength - 1 >= 0));
            }
        }

        public bool Executing
        {
            get { return _executing; }
            set
            {
                if (value && !_executing && ScriptStarting != null)
                    ScriptStarting(this, null);
                if (!value && _executing && ScriptFinished != null)
                    ScriptFinished(this, null);
                _executing = value;
            }
        }

        /// <summary>
        /// The home position is at the start of the line after the prompt.
        /// </summary>
        void MoveToHomePosition()
        {
            textEditor.Line = textEditor.TotalLines;
            textEditor.Column = promptLength + 1;
        }

        /// <summary>
        /// Shows the previous command line in the command line history.
        /// </summary>
        void MoveToPreviousCommandLine()
        {
            if (commandLineHistory.MovePrevious())
            {
                ReplaceCurrentLineTextAfterPrompt(commandLineHistory.Current);
            }
        }

        /// <summary>
        /// Shows the next command line in the command line history.
        /// </summary>
        void MoveToNextCommandLine()
        {
            textEditor.Line = textEditor.TotalLines;
            if (commandLineHistory.MoveNext())
            {
                ReplaceCurrentLineTextAfterPrompt(commandLineHistory.Current);
            }
        }

        /// <summary>
        /// Replaces the current line text after the prompt with the specified text.
        /// </summary>
        void ReplaceCurrentLineTextAfterPrompt(string text)
        {
            string currentLine = GetCurrentLine();
            textEditor.Replace(promptLength, currentLine.Length, text);

            // Put cursor at end.
            textEditor.Column = promptLength + text.Length + 1;
        }

        public void OutputWritten(object sender, EventArgs e)
        {
            if (!Executing )
            {
                _lastWrite = DateTime.UtcNow;
                Task.Run(async () =>
                {
                    await Task.Delay(1100);
                    await dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(AddPrompt));
                });
            }
        }

        protected virtual void OnError(TextEventArgs e)
        {
            Error?.Invoke(this, e);
        }
    }
}

	// Copyright (c) 2010 Joe Moorhouse

	using System;
	using System.Collections.Generic;
	using System.Linq;
	using System.Text;
	using System.IO;
	using System.Threading;
	using Microsoft.Scripting.Hosting.Shell;
	using System.Windows.Input;
	using Microsoft.Scripting;
	using IronPython.Hosting;
	using IronPython.Runtime;
	using Microsoft.Scripting.Hosting;
	using Microsoft.Scripting.Hosting.Providers;
	using System.Diagnostics;
	using System.Globalization;
	using System.Runtime.InteropServices;
	using System.Threading.Tasks;
	using System.Windows;
	using System.Windows.Threading;
	using System.Windows.Documents;
	using ICSharpCode.AvalonEdit.Editing;
	using ICSharpCode.AvalonEdit.Document;
	using ICSharpCode.AvalonEdit.Highlighting;
	using ICSharpCode.AvalonEdit.Utils;
	using Style = Microsoft.Scripting.Hosting.Shell.Style;

	public class TextEventArgs : EventArgs
	{
	public TextEventArgs(string text)
	{
	Text = text;
	}

	public string Text { get; }

	}


	namespace PythonConsoleControl
	{
	public delegate void ConsoleInitializedEventHandler(object sender, EventArgs e);

	/// <summary>
	/// Custom IronPython console. The command dispacher runs on a separate UI thread from the REPL
	/// and also from the WPF control.
	/// </summary>
	public class PythonConsole : IConsole, IDisposable
	{
	bool allowFullAutocompletion = true;
	public bool AllowFullAutocompletion
	{
	get { return allowFullAutocompletion; }
	set { allowFullAutocompletion = value; }
	}

	bool disableAutocompletionForCallables = true;
	public bool DisableAutocompletionForCallables
	{
	get { return disableAutocompletionForCallables; }
	set
	{
	if (textEditor.CompletionProvider != null) textEditor.CompletionProvider.ExcludeCallables = value;
	disableAutocompletionForCallables = value;
	}
	}

	bool allowCtrlSpaceAutocompletion = false;
	public bool AllowCtrlSpaceAutocompletion
	{
	get { return allowCtrlSpaceAutocompletion; }
	set { allowCtrlSpaceAutocompletion = value; }
	}

	public Action<ScriptScope> UpdateVariables { get; set; }

	PythonTextEditor textEditor;
	int lineReceivedEventIndex = 0; // The index into the waitHandles array where the lineReceivedEvent is stored.
	ManualResetEvent lineReceivedEvent = new ManualResetEvent(false);
	ManualResetEvent disposedEvent = new ManualResetEvent(false);
	AutoResetEvent statementsExecutionRequestedEvent = new AutoResetEvent(false);
	WaitHandle[] waitHandles;
	int promptLength = 4;
	List<string> previousLines = new List<string>();
	CommandLine commandLine;
	CommandLineHistory commandLineHistory = new CommandLineHistory();

	volatile bool _executing = false;

	// This is the thread upon which all commands execute unless the dipatcher is overridden.
	Thread dispatcherThread;
	Window dispatcherWindow;
	Dispatcher dispatcher;

	bool consoleInitialized = false;
	string prompt;
	private DateTime _lastWrite;
	private Style _lastStyle;

	public event ConsoleInitializedEventHandler ConsoleInitialized;
	public event EventHandler<EventArgs> ScriptStarting;
	public event EventHandler<EventArgs> ScriptFinished;
	public event EventHandler<TextEventArgs> Error;

	public ScriptScope ScriptScope
	{
	get { return commandLine.ScriptScope; }
	}

	public PythonConsole(PythonTextEditor textEditor, CommandLine commandLine)
	{
	waitHandles = new WaitHandle[] { lineReceivedEvent, disposedEvent };

	this.commandLine = commandLine;
	this.textEditor = textEditor;
	textEditor.CompletionProvider = new PythonConsoleCompletionDataProvider(commandLine) { ExcludeCallables = disableAutocompletionForCallables };
	textEditor.PreviewKeyDown += textEditor_PreviewKeyDown;
	textEditor.TextEntering += textEditor_TextEntering;
	dispatcherThread = new Thread(new ThreadStart(DispatcherThreadStartingPoint));
	dispatcherThread.SetApartmentState(ApartmentState.STA);
	dispatcherThread.IsBackground = true;
	dispatcherThread.Start();

	// Only required when running outside REP loop.
	prompt = ">>> ";

	// Set commands:
	this.textEditor.textArea.Dispatcher.Invoke(new Action(delegate()
	{
	CommandBinding pasteBinding = null;
	CommandBinding copyBinding = null;
	CommandBinding cutBinding = null;
	CommandBinding undoBinding = null;
	CommandBinding deleteBinding = null;
	foreach (CommandBinding commandBinding in (this.textEditor.textArea.CommandBindings))
	{
	if (commandBinding.Command == ApplicationCommands.Paste) pasteBinding = commandBinding;
	if (commandBinding.Command == ApplicationCommands.Copy) copyBinding = commandBinding;
	if (commandBinding.Command == ApplicationCommands.Cut) cutBinding = commandBinding;
	if (commandBinding.Command == ApplicationCommands.Undo) undoBinding = commandBinding;
	if (commandBinding.Command == ApplicationCommands.Delete) deleteBinding = commandBinding;
	}
	// Remove current bindings completely from control. These are static so modifying them will cause other
	// controls' behaviour to change too.
	if (pasteBinding != null) this.textEditor.textArea.CommandBindings.Remove(pasteBinding);
	if (copyBinding != null) this.textEditor.textArea.CommandBindings.Remove(copyBinding);
	if (cutBinding != null) this.textEditor.textArea.CommandBindings.Remove(cutBinding);
	if (undoBinding != null) this.textEditor.textArea.CommandBindings.Remove(undoBinding);
	if (deleteBinding != null) this.textEditor.textArea.CommandBindings.Remove(deleteBinding);
	this.textEditor.textArea.CommandBindings.Add(new CommandBinding(ApplicationCommands.Paste, OnPaste, CanPaste));
	this.textEditor.textArea.CommandBindings.Add(new CommandBinding(ApplicationCommands.Copy, OnCopy, PythonEditingCommandHandler.CanCutOrCopy));
	this.textEditor.textArea.CommandBindings.Add(new CommandBinding(ApplicationCommands.Cut, PythonEditingCommandHandler.OnCut, CanCut));
	this.textEditor.textArea.CommandBindings.Add(new CommandBinding(ApplicationCommands.Undo, OnUndo, CanUndo));
	this.textEditor.textArea.CommandBindings.Add(new CommandBinding(ApplicationCommands.Delete, PythonEditingCommandHandler.OnDelete(ApplicationCommands.NotACommand), CanDeleteCommand));

	}));
	CodeContext codeContext = DefaultContext.Default;
	// Set dispatcher to run on a UI thread independent of both the Control UI thread and thread running the REPL.
	ClrModule.SetCommandDispatcher(codeContext, DispatchCommand);
	}

	protected void DispatchCommand(Delegate command)
	{
	if (command != null)
	{
	// Slightly involved form to enable keyboard interrupt to work.
	Executing = true;
	var operation = dispatcher.BeginInvoke(DispatcherPriority.Normal, command);
	while (Executing)
	{
	if (operation.Status != DispatcherOperationStatus.Completed)
	operation.Wait(TimeSpan.FromSeconds(1));
	if (operation.Status == DispatcherOperationStatus.Completed)
	Executing = false;
	}
	}
	}

	private void DispatcherThreadStartingPoint()
	{
	dispatcherWindow = new Window();
	dispatcher = dispatcherWindow.Dispatcher;
	while (true)
	{
	try
	{
	System.Windows.Threading.Dispatcher.Run();
	}
	catch (ThreadAbortException tae)
	{
	if (tae.ExceptionState is Microsoft.Scripting.KeyboardInterruptException)
	{
	Thread.ResetAbort();
	Executing = false;
	}
	}
	}
	}

	public void SetDispatcher(Dispatcher dispatcher)
	{
	this.dispatcher = dispatcher;
	}

	public void Dispose()
	{
	disposedEvent.Set();
	textEditor.PreviewKeyDown -= textEditor_PreviewKeyDown;
	textEditor.TextEntering -= textEditor_TextEntering;
	}

	public TextWriter Output
	{
	get { return null; }
	set { }
	}

	public TextWriter ErrorOutput
	{
	get { return null; }
	set { }
	}

	#region CommandHandling
	protected void CanPaste(object target, CanExecuteRoutedEventArgs args)
	{
	if (IsInReadOnlyRegion)
	{
	args.CanExecute = false;
	}
	else
	args.CanExecute = true;
	}

	protected void CanCut(object target, CanExecuteRoutedEventArgs args)
	{
	if (!CanDelete)
	{
	args.CanExecute = false;
	}
	else
	PythonEditingCommandHandler.CanCutOrCopy(target, args);
	}

	protected void CanDeleteCommand(object target, CanExecuteRoutedEventArgs args)
	{
	if (!CanDelete)
	{
	args.CanExecute = false;
	}
	else
	PythonEditingCommandHandler.CanDelete(target, args);
	}

	protected void CanUndo(object target, CanExecuteRoutedEventArgs args)
	{
	args.CanExecute = false;
	}

	protected void OnPaste(object target, ExecutedRoutedEventArgs args)
	{
	if (target != textEditor.textArea) return;
	TextArea textArea = textEditor.textArea;
	if (textArea != null && textArea.Document != null)
	{
	Debug.WriteLine(Clipboard.GetText(TextDataFormat.Html));

	// convert text back to correct newlines for this document
	string newLine = TextUtilities.GetNewLineFromDocument(textArea.Document, textArea.Caret.Line);
	string text = TextUtilities.NormalizeNewLines(Clipboard.GetText(), newLine);
	string[] commands = text.Split(new String[] {newLine}, StringSplitOptions.None);
	string scriptText = "";
	if (commands.Length > 1)
	{
	text = newLine;
	foreach (string command in commands)
	{
	text += "... " + command + newLine;
	scriptText += command.Replace("\t", " ") + newLine;
	}
	}

	if (!string.IsNullOrEmpty(text))
	{
	bool fullLine = textArea.Options.CutCopyWholeLine && Clipboard.ContainsData(LineSelectedType);
	bool rectangular = Clipboard.ContainsData(RectangleSelection.RectangularSelectionDataType);
	if (fullLine)
	{
	DocumentLine currentLine = textArea.Document.GetLineByNumber(textArea.Caret.Line);
	if (textArea.ReadOnlySectionProvider.CanInsert(currentLine.Offset))
	{
	textArea.Document.Insert(currentLine.Offset, text);
	}
	}
	else if (rectangular && textArea.Selection.IsEmpty)
	{
	if (!RectangleSelection.PerformRectangularPaste(textArea, textArea.Caret.Position, text, false))
	textEditor.Write(text, false);
	}
	else
	{
	textEditor.Write(text, false);
	}
	}
	textArea.Caret.BringCaretToView();
	args.Handled = true;

	if (commands.Length > 1)
	{
	dispatcherWindow.Dispatcher.BeginInvoke(new Action(delegate() { ExecuteStatements(scriptText); }));
	}
	}
	}

	protected void OnCopy(object target, ExecutedRoutedEventArgs args)
	{
	if (target != textEditor.textArea) return;
	if (textEditor.SelectionLength == 0 && Executing)
	{
	// Send the 'Ctrl-C' abort
	//if (!IsInReadOnlyRegion)
	//{
	MoveToHomePosition();
	//textEditor.Column = GetLastTextEditorLine().Length + 1;
	//textEditor.Write(Environment.NewLine);
	//}
	AbortRunningScript();
	args.Handled = true;
	}
	else PythonEditingCommandHandler.OnCopy(target, args);
	}

	public void AbortRunningScript()
	{
	if (Executing)
	dispatcherThread.Abort(new KeyboardInterruptException(""));
	}

	const string LineSelectedType = "MSDEVLineSelect"; // This is the type VS 2003 and 2005 use for flagging a whole line copy

	protected void OnUndo(object target, ExecutedRoutedEventArgs args)
	{
	}
	#endregion

	/// <summary>
	/// Run externally provided statements in the Console Engine.
	/// </summary>
	/// <param name="statements"></param>
	public void RunStatements(string statements)
	{
	MoveToHomePosition();

	dispatcher.BeginInvoke(new Action(delegate() { ExecuteStatements(statements); }));
	}

	/// <summary>
	/// Run externally provided statements in the Console Engine.
	/// </summary>
	/// <param name="statements"></param>
	public void RunStatementsSync(string statements)
	{
	MoveToHomePosition();

	using (var evt = new AutoResetEvent(false))
	{


	dispatcher.BeginInvoke(new Action(delegate()
	{
	try
	{
	ExecuteStatements(statements);
	}
	finally
	{
	evt.Set();
	}
	}));

	while (true)
	{
	if (evt.WaitOne(1))
	break;

	System.Windows.Forms.Application.DoEvents();
	}

	}
	}

	/// <summary>
	/// Run on the statement execution thread.
	/// </summary>
	void ExecuteStatements(string scriptText)
	{
	UpdateVariables?.Invoke(commandLine.ScriptScope);
	lock (scriptText)
	{
	textEditor.Write("\r\n");
	ScriptSource scriptSource = commandLine.ScriptScope.Engine.CreateScriptSourceFromString(scriptText, SourceCodeKind.Statements);
	string error = "";
	try
	{
	Executing = true;
	scriptSource.Execute(commandLine.ScriptScope);
	}
	catch (ThreadAbortException tae)
	{
	if (tae.ExceptionState is Microsoft.Scripting.KeyboardInterruptException) Thread.ResetAbort();
	error = "KeyboardInterrupt" + System.Environment.NewLine;
	}
	catch (Microsoft.Scripting.SyntaxErrorException exception)
	{
	ExceptionOperations eo;
	eo = commandLine.ScriptScope.Engine.GetService<ExceptionOperations>();
	error = eo.FormatException(exception);
	}
	catch (Exception exception)
	{
	ExceptionOperations eo;
	eo = commandLine.ScriptScope.Engine.GetService<ExceptionOperations>();
	error = eo.FormatException(exception) + System.Environment.NewLine;
	}
	Executing = false;
	if (error != "")
	{
	textEditor.Write(error);
	OnError(new TextEventArgs(error));
	}
	textEditor.Write(prompt);
	}
	}

	/// <summary>
	/// Returns the next line typed in by the console user. If no line is available this method
	/// will block.
	/// </summary>
	public string ReadLine(int autoIndentSize)
	{
	string indent = String.Empty;
	if (autoIndentSize > 0)
	{
	indent = String.Empty.PadLeft(autoIndentSize);
	Write(indent, Style.Prompt);
	}

	string line = ReadLineFromTextEditor();
	if (line != null)
	{
	return indent + line;
	}
	return null;
	}

	/// <summary>
	/// Writes text to the console.
	/// </summary>
	public void Write(string text, Style style)
	{
	textEditor.Write(text);
	if (style == Style.Prompt)
	{
	promptLength = text.Length;
	if (!consoleInitialized)
	{
	consoleInitialized = true;
	if (ConsoleInitialized != null) ConsoleInitialized(this, EventArgs.Empty);
	}
	}


	_lastStyle = style;
	}

	private void AddPrompt()
	{
	if ((DateTime.UtcNow - _lastWrite).TotalSeconds > 1)
	{
	//textEditor.Write(prompt);
	_lastWrite = DateTime.UtcNow;
	}
	}

	/// <summary>
	/// Writes text followed by a newline to the console.
	/// </summary>
	public void WriteLine(string text, Style style)
	{
	Write(text + Environment.NewLine, style);
	}

	/// <summary>
	/// Writes an empty line to the console.
	/// </summary>
	public void WriteLine()
	{
	Write(Environment.NewLine, Style.Out);
	}

	/// <summary>
	/// Indicates whether there is a line already read by the console and waiting to be processed.
	/// </summary>
	public bool IsLineAvailable
	{
	get
	{
	lock (previousLines)
	{
	return previousLines.Count > 0;
	}
	}
	}

	/// <summary>
	/// Gets the text that is yet to be processed from the console. This is the text that is being
	/// typed in by the user who has not yet pressed the enter key.
	/// </summary>
	public string GetCurrentLine()
	{
	string fullLine = GetLastTextEditorLine();
	return fullLine.Substring(promptLength);
	}

	/// <summary>
	/// Gets the lines that have not been returned by the ReadLine method. This does not
	/// include the current line.
	/// </summary>
	public string[] GetUnreadLines()
	{
	return previousLines.ToArray();
	}

	string GetLastTextEditorLine()
	{
	return textEditor.GetLine(textEditor.TotalLines - 1);
	}

	string ReadLineFromTextEditor()
	{
	int result = WaitHandle.WaitAny(waitHandles);
	if (result == lineReceivedEventIndex)
	{
	lock (previousLines)
	{
	string line = previousLines[0];
	previousLines.RemoveAt(0);
	if (previousLines.Count == 0)
	{
	lineReceivedEvent.Reset();
	}
	return line;
	}
	}
	return null;
	}

	/// <summary>
	/// Processes characters entered into the text editor by the user.
	/// </summary>
	void textEditor_PreviewKeyDown(object sender, KeyEventArgs e)
	{
	switch (e.Key)
	{
	case Key.Delete:
	if (!CanDelete) e.Handled = true;
	return;
	case Key.Tab:
	if (IsInReadOnlyRegion) e.Handled = true;
	return;
	case Key.Back:
	if (!CanBackspace) e.Handled = true;
	return;
	case Key.Home:
	MoveToHomePosition();
	e.Handled = true;
	return;
	case Key.Down:
	if (!IsInReadOnlyRegion) MoveToNextCommandLine();
	e.Handled = true;
	return;
	case Key.Up:
	if (!IsInReadOnlyRegion) MoveToPreviousCommandLine();
	e.Handled = true;
	return;
	}
	}

	/// <summary>
	/// Processes characters entering into the text editor by the user.
	/// </summary>
	void textEditor_TextEntering(object sender, TextCompositionEventArgs e)
	{
	if (e.Text.Length > 0)
	{
	if (!char.IsLetterOrDigit(e.Text[0]))
	{
	// Whenever a non-letter is typed while the completion window is open,
	// insert the currently selected element.
	textEditor.RequestCompletioninsertion(e);
	}
	}

	if (IsInReadOnlyRegion)
	{
	e.Handled = true;
	}
	else
	{
	if (e.Text[0] == '\n')
	{
	UpdateVariables?.Invoke(commandLine.ScriptScope);
	OnEnterKeyPressed();
	}

	if (e.Text[0] == '.' && allowFullAutocompletion)
	{
	textEditor.ShowCompletionWindow();
	}

	if ((e.Text[0] == ' ') && (Keyboard.Modifiers == ModifierKeys.Control))
	{
	e.Handled = true;
	if (allowCtrlSpaceAutocompletion) textEditor.ShowCompletionWindow();
	}
	}
	}

	/// <summary>
	/// Move cursor to the end of the line before retrieving the line.
	/// </summary>
	void OnEnterKeyPressed()
	{
	textEditor.StopCompletion();
	if (textEditor.WriteInProgress) return;
	lock (previousLines)
	{
	// Move cursor to the end of the line.
	textEditor.Column = GetLastTextEditorLine().Length + 1;

	// Append line.
	string currentLine = GetCurrentLine();
	previousLines.Add(currentLine);
	commandLineHistory.Add(currentLine);

	lineReceivedEvent.Set();
	}
	}

	/// <summary>
	/// Returns true if the cursor is in a readonly text editor region.
	/// </summary>
	bool IsInReadOnlyRegion
	{
	get { return IsCurrentLineReadOnly \|\| IsInPrompt; }
	}

	/// <summary>
	/// Only the last line in the text editor is not read only.
	/// </summary>
	bool IsCurrentLineReadOnly
	{
	get { return textEditor.Line < textEditor.TotalLines; }
	}

	/// <summary>
	/// Determines whether the current cursor position is in a prompt.
	/// </summary>
	bool IsInPrompt
	{
	get { return textEditor.Column - promptLength - 1 < 0; }
	}

	/// <summary>
	/// Returns true if the user can delete at the current cursor position.
	/// </summary>
	bool CanDelete
	{
	get
	{
	if (textEditor.SelectionLength > 0) return SelectionIsDeletable;
	else return !IsInReadOnlyRegion;
	}
	}

	/// <summary>
	/// Returns true if the user can backspace at the current cursor position.
	/// </summary>
	bool CanBackspace
	{
	get
	{
	if (textEditor.SelectionLength > 0) return SelectionIsDeletable;
	else
	{
	int cursorIndex = textEditor.Column - promptLength - 1;
	return !IsCurrentLineReadOnly && (cursorIndex > 0 \|\| (cursorIndex == 0 && textEditor.SelectionLength > 0));
	}
	}
	}

	bool SelectionIsDeletable
	{
	get
	{
	return (!textEditor.SelectionIsMultiline
	&& !IsCurrentLineReadOnly
	&& (textEditor.SelectionStartColumn - promptLength - 1 >= 0)
	&& (textEditor.SelectionEndColumn - promptLength - 1 >= 0));
	}
	}

	public bool Executing
	{
	get { return _executing; }
	set
	{
	if (value && !_executing && ScriptStarting != null)
	ScriptStarting(this, null);
	if (!value && _executing && ScriptFinished != null)
	ScriptFinished(this, null);
	_executing = value;
	}
	}

	/// <summary>
	/// The home position is at the start of the line after the prompt.
	/// </summary>
	void MoveToHomePosition()
	{
	textEditor.Line = textEditor.TotalLines;
	textEditor.Column = promptLength + 1;
	}

	/// <summary>
	/// Shows the previous command line in the command line history.
	/// </summary>
	void MoveToPreviousCommandLine()
	{
	if (commandLineHistory.MovePrevious())
	{
	ReplaceCurrentLineTextAfterPrompt(commandLineHistory.Current);
	}
	}

	/// <summary>
	/// Shows the next command line in the command line history.
	/// </summary>
	void MoveToNextCommandLine()
	{
	textEditor.Line = textEditor.TotalLines;
	if (commandLineHistory.MoveNext())
	{
	ReplaceCurrentLineTextAfterPrompt(commandLineHistory.Current);
	}
	}

	/// <summary>
	/// Replaces the current line text after the prompt with the specified text.
	/// </summary>
	void ReplaceCurrentLineTextAfterPrompt(string text)
	{
	string currentLine = GetCurrentLine();
	textEditor.Replace(promptLength, currentLine.Length, text);

	// Put cursor at end.
	textEditor.Column = promptLength + text.Length + 1;
	}

	public void OutputWritten(object sender, EventArgs e)
	{
	if (!Executing )
	{
	_lastWrite = DateTime.UtcNow;
	Task.Run(async () =>
	{
	await Task.Delay(1100);
	await dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(AddPrompt));
	});
	}
	}

	protected virtual void OnError(TextEventArgs e)
	{
	Error?.Invoke(this, e);
	}
	}
	}