public override void HandleTextEntered(CodeEditor control, string insertText)
    {
      switch (insertText)
      {
        case "\\":
          ShowCompletions(control);
          break;
        case "{":
        case "(":
        case "[":
          if (_currentInsight != null)
            _currentInsight.Hide();

          var overload = new OverloadInsightWindow(control.Editor.TextArea);
          if (insertText == "{")
            overload.Provider = _quantifiers;
          else if (insertText == "(")
            overload.Provider = _groups;
          else
            overload.Provider = _charClass;
          overload.Show();
          _currentInsight = overload;
          break;
        case "}":
        case ")":
        case "]":
          if (_currentInsight != null)
            _currentInsight.Hide();

          _currentInsight = null;
          break;
      }
    }
    public override IPromise<CompletionContext> ShowCompletions(CodeEditor control)
    {
      var length = control.Editor.Document.TextLength;
      var caret = control.Editor.CaretOffset;

      if (control.Editor.CaretOffset >= 2 && control.Editor.Document.GetText(control.Editor.CaretOffset - 2, 2) == "<!")
      {
        var context = new CompletionContext()
        {
          Items = new ICompletionData[] {
            new BasicCompletionData() {
              Text = "--",
              Content = "-- (Comment)",
              Action = () => "---->",
              CaretOffset = -3
            },
            new BasicCompletionData() {
              Text = "[CDATA[",
              Action = () => "[CDATA[]]>",
              CaretOffset = -3
            }
          }
        };

        control.ShowCompletionWindow(context.Items, context.Overlap);

        return Promises.Resolved(context);
      }
      else
      {
        return this.GetCompletions(control.Document, control.Editor.CaretOffset, this.SoapAction)
          .ToPromise()
          .UiPromise(control)
          .Convert(data => {
            if (length != control.Editor.Document.TextLength
              || caret != control.Editor.CaretOffset)
            {
              ShowCompletions(control);
              return null;
            }

            if (data.Items.Any())
            {
              var items = data.Items.ToArray();
              var contextItems = items.OfType<IContextCompletions>();
              foreach (var contextItem in contextItems)
              {
                contextItem.SetContext(this, control);
              }

              control.ShowCompletionWindow(items, data.Overlap);
            }

            return data;
          });
      }

    }
 public override void HandleTextEntered(CodeEditor control, string insertText)
 {
   switch (insertText)
   {
     case "\\":
       ShowCompletions(control);
       break;
   }
 }
 public void HandleTextEntered(CodeEditor control, string insertText)
 {
   switch (insertText)
   {
     case " ":
     case ",":
     case "(":
     case ".":
       _sql.CurrentTextArea = control.Editor.TextArea;
       ShowCompletions(control);
       break;
   }
 }
 public override void HandleTextEntered(CodeEditor control, string insertText)
 {
   if (_isInitialized)
   {
     switch (insertText)
     {
       case "'":
       case "\"":
       case " ":
       case "<":
       case ",":
       case "(":
       case ".":
       case "!":
         _sql.CurrentTextArea = control.Editor.TextArea;
         ShowCompletions(control)
           .Done(data =>
           {
             if (data != null && data.IsXmlTag && !data.Items.Any()
               && control.Editor.CaretOffset < control.Editor.Document.TextLength)
             {
               var doc = control.Editor.TextArea.Document;
               var quote = doc.GetCharAt(doc.LastIndexOf('=', 0, control.Editor.CaretOffset) + 1);
               if (insertText[0] == quote && quote == doc.GetCharAt(control.Editor.CaretOffset))
               {
                 doc.Remove(control.Editor.CaretOffset, 1);
               }
             }
           });
         break;
       case ">":
         var endTag = this.LastOpenTag(control.Document.CreateSnapshot(0, control.Editor.CaretOffset));
         if (!string.IsNullOrEmpty(endTag))
         {
           var insert = "</" + endTag + ">";
           if (!control.Editor.Text.Substring(control.Editor.CaretOffset).StartsWith(insert))
           {
             control.Editor.Document.Insert(control.Editor.CaretOffset, insert, AnchorMovementType.BeforeInsertion);
             control.HideCompletionWindow();
           }
         }
         ShowCompletions(control);
         break;
     }
   }
 }
    public override Innovator.Client.IPromise<CompletionContext> ShowCompletions(CodeEditor control)
    {
      var length = control.Editor.Document.TextLength;
      var caret = control.Editor.CaretOffset;
      var data = new CompletionContext();

      if (caret > 0)
      {
        string[][] completions = null;
        if (control.Editor.Document.GetCharAt(caret - 1) == '\\')
          completions = _completionInfo;
        else if (control.Editor.Document.GetCharAt(caret - 1) == '$')
          completions = _replacementTypes;

        if (completions != null)
        {
          data.Items = completions
            .OrderBy(i => i[0].ToLowerInvariant())
            .ThenBy(i => i[1])
            .Select(i => new BasicCompletionData() {
              Content = GetSpan(new Run(i[0] + " "), new Run(i[1])
              {
                Foreground = Brushes.Gray
              }),
              Text = i[0],
              Action = () => i[0]
            });
        }
      }

      if (data.Items.Any())
      {
        var items = data.Items.ToArray();
        var contextItems = items.OfType<IContextCompletions>();
        foreach (var contextItem in contextItems)
        {
          contextItem.SetContext(this, control);
        }

        control.ShowCompletionWindow(items, data.Overlap);
      }

      return Promises.Resolved(data);
    }
 public void SetContext(IEditorHelper parent, CodeEditor control)
 {
   _parent = parent;
   _control = control;
 }
 public virtual Innovator.Client.IPromise<CompletionContext> ShowCompletions(CodeEditor control)
 {
   return Innovator.Client.Promises.Resolved(new CompletionContext());
 }
 public virtual void HandleTextEntered(CodeEditor control, string insertText)
 {
   // Do nothing
 }
 public override void HandleTextEntered(CodeEditor control, string insertText)
 {
   switch (insertText)
   {
     case ">":
       var doc = control.Editor.Document;
       var caret = control.Editor.CaretOffset;
       var text = doc.GetText(0, caret);
       var elementName = XmlParser.GetOpenElement(text);
       if (!string.IsNullOrEmpty(elementName))
       {
         var insert = "</" + elementName + ">";
         if (!doc.GetText(caret, doc.TextLength - caret).Trim().StartsWith(insert))
         {
           doc.Insert(caret, insert, AnchorMovementType.BeforeInsertion);
         }
       }
       break;
     default:
       var result = HandleTextEntered(control.Editor.Document, control.Editor.CaretOffset, insertText);
       if (result.Any())
       {
         control.ShowCompletionWindow(result, 0);
       }
       break;
   }
 }
    public override Innovator.Client.IPromise<CompletionContext> ShowCompletions(CodeEditor control)
    {
      var length = control.Editor.Document.TextLength;
      var caret = control.Editor.CaretOffset;
      var data = new CompletionContext();

      if (caret > 0 && control.Editor.Document.GetCharAt(caret - 1) == '\\')
      {
        data.Items = _completionInfo
          .OrderBy(i => i[0].ToLowerInvariant())
          .ThenBy(i => i[1])
          .Select(i => new BasicCompletionData() {
            Content = FormatText.Span(FormatText.Text(i[0] + " "), FormatText.MutedText(i[1])),
            Text = i[0],
            Action = () => i[0]
          });
      }

      if (data.Items.Any())
      {
        var items = data.Items.ToArray();
        var contextItems = items.OfType<IContextCompletions>();
        foreach (var contextItem in contextItems)
        {
          contextItem.SetContext(this, control);
        }

        control.ShowCompletionWindow(items, data.Overlap);
      }

      return Promises.Resolved(data);
    }
    public Innovator.Client.IPromise<CompletionContext> ShowCompletions(CodeEditor control)
    {
      var length = control.Editor.Document.TextLength;
      var caret = control.Editor.CaretOffset;

      var text = control.Editor.Text;

      return _sql.Completions(text.Substring(0, caret), control.Document, caret, null)
        .UiPromise(control)
        .Convert(data =>
        {
          if (length != control.Editor.Document.TextLength
            || caret != control.Editor.CaretOffset)
          {
            ShowCompletions(control);
            return null;
          }

          if (data.Items.Any())
          {
            var items = data.Items.ToArray();
            var contextItems = items.OfType<IContextCompletions>();
            foreach (var contextItem in contextItems)
            {
              contextItem.SetContext(this, control);
            }

            control.ShowCompletionWindow(items, data.Overlap);
          }

          return data;
        });
    }