/// <summary> /// Accepts a key stroke. /// </summary> /// <param name="editor">Editor</param> /// <param name="key">Key</param> /// <returns>true if done, false if not.</returns> public void Accept(IOTASourceEditor editor) { if (TriggerKeys.ContainsKey(key)) { LoggingService.Info("invoke autocompletion"); TriggerKeys[key].KeyHandler(editor, new FireEventArgs(/*this.key*/)); } }
public void Execute(IOTASourceEditor editor) { if (!OtaUtils.GetCurrentLine(editor).TrimStart().StartsWith(@"//", StringComparison.Ordinal) && Char.IsWhiteSpace(OtaUtils.GetCharAfterCursor(editor))) { LoggingService.Debug(this); OtaUtils.InsertText(editor, this.complement, movement.X, movement.Y); } }
/// <summary> /// Verifies cursor is at end of line. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <returns></returns> /// <remarks>This function is not correctly implemented.</remarks> public static bool CursorIsAtEndOfLine(IOTASourceEditor sourceEditor) { IOTAEditView _EditView = GetEditView(sourceEditor); OTAEditPos _OriginalPos = _EditView.CursorPos; bool result = false; try { _EditView.Buffer.EditPosition.MoveEOL(); // Get the End of the Line OTAEditPos _EndEditPos = new OTAEditPos(); _EndEditPos.Col = _EditView.CursorPos.Col; _EndEditPos.Line = _EditView.CursorPos.Line; result = (_EndEditPos.Col == _OriginalPos.Col); } finally { _EditView.CursorPos = _OriginalPos; } return result; }
public void Execute(IOTASourceEditor editor) {}
private static bool IsValidForAutoCompletion(IOTAModule aModule, IOTASourceEditor aSourceEditor) { return (aSourceEditor != null) && (String.IsNullOrEmpty(OtaUtils.GetSelectedText(aModule))); }
/// <summary> /// Moves char position to edit position. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <param name="charPos">Char position</param> /// <returns>Edit position.</returns> public static OTAEditPos CharPosToEditPos(IOTASourceEditor sourceEditor, OTACharPos charPos) { IOTAEditView _EditView = GetEditView(sourceEditor); OTAEditPos _EditPos = new OTAEditPos(); if (_EditView != null) { _EditView.ConvertPos(false, ref _EditPos, ref charPos); } return _EditPos; }
/// <summary> /// Moves buffer position to char position. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <param name="bufferPos">Buffer position</param> /// <returns></returns> public static OTACharPos BufferPosToCharPos(IOTASourceEditor sourceEditor, int bufferPos) { IOTAEditView _EditView = GetEditView(sourceEditor); if (_EditView != null) { return _EditView.PosToCharPos(bufferPos); } return new OTACharPos(); }
/// <summary> /// Moves char position of source editor to buffer position. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <param name="charPos">Char position</param> /// <returns></returns> public static int CharPosToBufferPos(IOTASourceEditor sourceEditor, OTACharPos charPos) { IOTAEditView _EditView = GetEditView(sourceEditor); if (_EditView != null) { return _EditView.CharPosToPos(charPos); } return -1; }
/// <summary> /// Inserts text and moves cursor. /// </summary> /// <param name="editor">Source editor</param> /// <param name="text">Text</param> /// <param name="moveRow">Move row</param> /// <param name="moveColumn">Move column of cursor</param> public static void InsertText(IOTASourceEditor editor, string text, int moveRow, int moveColumn) { IOTAEditView view = OtaUtils.GetEditView(editor); if (view != null) { IOTAEditPosition pos = view.Position; LoggingService.Debug("before insert text, column is " + pos.Column + " and row is " + pos.Row); pos.Save(); // save original cursor pos.InsertText(text); pos.Restore();// back to original cursor bool canMove = pos.MoveRelative(moveRow, moveColumn); if (!canMove) { LoggingService.Error("cannot move cursor"); } view.Paint(); LoggingService.Debug("after insert text, column is " + pos.Column + " and row is " + pos.Row); } }
/// <summary> /// Inserts text. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <param name="text">Text</param> public static void InsertText(IOTASourceEditor sourceEditor, string text) { InsertText(sourceEditor, text, 0, 0); }
/// <summary> /// Goes to position. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <param name="lineNumber">Line number</param> /// <param name="colNumber">column number</param> /// <remarks>After calling this, EditView.MoveViewToCursor() and /// EditView.Paint() must be called to move the view.</remarks> public static void GoToPosition(IOTASourceEditor sourceEditor, int lineNumber, short colNumber) { if (sourceEditor != null) { IOTAEditView _EditView = GetEditView(sourceEditor); OTAEditPos _Pos = new OTAEditPos(); _Pos.Col = colNumber; _Pos.Line = lineNumber; _EditView.CursorPos = _Pos; } }
/// <summary> /// Gets source editor text position. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <returns>-1 if wrong.</returns> public static int GetSourceEditorTextPos(IOTASourceEditor sourceEditor) { IOTAEditView _EditView = GetEditView(sourceEditor); if (_EditView != null) { OTAEditPos _EditPos = _EditView.CursorPos; OTACharPos _CharPos = new OTACharPos(); _EditView.ConvertPos(true, ref _EditPos, ref _CharPos); return _EditView.CharPosToPos(_CharPos); } else { return -1; } }
/// <summary> /// Gets source editor text. All text. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <returns>String.Empty if wrong.</returns> public static string GetSourceEditorText(IOTASourceEditor sourceEditor) { if (sourceEditor == null) { return String.Empty; } IOTAFileReader _Reader = sourceEditor.CreateReader(); if (_Reader == null) { throw new Lextm.OpenTools.CoreException("No file reader"); } System.Text.UnicodeEncoding _Encoding = new System.Text.UnicodeEncoding(); StringBuilder _StringBuilder = new StringBuilder(); Byte[] _Source = _Reader.Read(1024, 0); while (_Source.Length != 0) { _StringBuilder.Append(_Encoding.GetString(_Source)); _Source = _Reader.Read(1024, 0); } //LoggingService.Info("the source is " + _StringBuilder.ToString()); return _StringBuilder.ToString(); }
/// <summary> /// Gets current edit position. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <returns>new object if wrong.</returns> public static OTAEditPos GetCurrentEditPos(IOTASourceEditor sourceEditor) { if (sourceEditor != null) { if (sourceEditor.EditViewCount > 0) { IOTAEditView _EditView = sourceEditor.GetEditView(0); return _EditView.CursorPos; } } return new OTAEditPos(); }
/// <summary> /// Gets current line. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <returns>String.Empty if no.</returns> /// <remarks> /// <para>Spaces are kept.</para> /// </remarks> public static string GetCurrentLine(IOTASourceEditor sourceEditor) { string _Source = GetSourceEditorText(sourceEditor); if (_Source.Length == 0) { return String.Empty; } IOTAEditView _EditView = GetEditView(sourceEditor); OTAEditPos _OriginalPos = _EditView.CursorPos; try { _EditView.Buffer.EditPosition.MoveEOL(); // Get the Begin of the Line OTAEditPos _BeginEditPos = new OTAEditPos(); _BeginEditPos.Col = 1; _BeginEditPos.Line = _EditView.CursorPos.Line; // Get the End of the Line OTAEditPos _EndEditPos = new OTAEditPos(); _EndEditPos.Col = _EditView.CursorPos.Col; _EndEditPos.Line = _EditView.CursorPos.Line; int _Begining = EditPosToBufferPos(sourceEditor, _BeginEditPos); int _End = EditPosToBufferPos(sourceEditor, _EndEditPos); return _Source.Substring(_Begining, _End - _Begining); } finally { _EditView.CursorPos = _OriginalPos; } }
// /// <summary> // /// Gets word before cursor. // /// </summary> // /// <param name="sourceEditor">Source editor</param> // /// <remarks> // /// <para>Special chars ahead are ignored. </para> // /// <para>If space is before cursor return String.Empty.</para> // /// <para>If there are some chars after cursor return String.Empty.</para> // /// </remarks> // /// <returns>String.Empty if wrong.</returns> // [] // public static string GetWordBeforeCursor2(IOTASourceEditor sourceEditor) { // string result = String.Empty; // if (sourceEditor != null) { // if (sourceEditor.EditViewCount > 0) { // IOTAEditView _EditView = sourceEditor.GetEditView(0); // // IOTAEditPosition _EditPos = _EditView.Position; // if (Char.IsWhiteSpace(_EditPos.Character)) { // int _ActualColumn = _EditPos.Column; // int _ActualRow = _EditPos.Row; // // int _WordLength = 0; // // bool canMove = _EditPos.MoveRelative(0, -1); // if (canMove) // no content // { // while (canMove && _EditView.Position.IsWordCharacter) { // _WordLength++; // canMove = _EditPos.MoveRelative(0, -1); // } // result = _EditView.Position.Read(_WordLength + 1).Trim(); // _EditView.Position.Move(_ActualRow, _ActualColumn); // } else { // LoggingService.Warn("no content"); // } // } else { // LoggingService.Warn("some char on the right"); // } // } else { // LoggingService.Warn("no view"); // } // } else { // LoggingService.Warn("null editor"); // } // return result; // } #endregion #region CSBuilder Goodies extensions /// <summary> /// Gets word before cursor. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <remarks>Special chars are included.</remarks> /// <returns>String.Empty if wrong.</returns> public static string GetWordBeforeCursor(IOTASourceEditor sourceEditor) { LoggingService.EnterMethod(); if (sourceEditor != null) { if (sourceEditor.EditViewCount > 0) { IOTAEditView _EditView = sourceEditor.GetEditView(0); IOTAEditPosition _EditPos = _EditView.Position; _EditPos.Save(); string _TheWord = String.Empty; int _WordLength = 0; if (!_EditPos.MoveRelative(0, -1)) // no content { _EditPos.Restore(); LoggingService.LeaveMethod(); return String.Empty; } while (_EditView.Position.IsWhitespace) { if (!_EditPos.MoveRelative(0, -1)) { _EditPos.Restore(); LoggingService.LeaveMethod(); return String.Empty; } } // slip all whitespaces while (_EditPos.IsWordCharacter || _EditPos.IsSpecialCharacter) { _WordLength++; if (!_EditPos.MoveRelative(0, -1)) { break; } } _TheWord = _EditPos.Read(_WordLength + 1).Trim(); _EditPos.Restore(); LoggingService.Info(_TheWord); LoggingService.LeaveMethod(); return _TheWord; } } LoggingService.LeaveMethod(); return String.Empty; }
/// <summary> /// Deletes backspace. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <param name="length">Length</param> public static void BackspaceDelete(IOTASourceEditor sourceEditor, int length) { if (sourceEditor != null) { if (sourceEditor.EditViewCount > 0) { IOTAEditView _EditView = sourceEditor.GetEditView(0); IOTAEditPosition _EditPos = _EditView.Position; _EditPos.BackspaceDelete(length); } } }
/// <summary> /// Replaces inclusive and exclusive. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <param name="editView">Edit view</param> /// <param name="isInclusive">Is inclusive flag</param> /// <param name="start">Start</param> /// <param name="after">After</param> /// <param name="text">Text</param> private static void ReplaceInclusiveExclusive(IOTASourceEditor sourceEditor, IOTAEditView editView, bool isInclusive, OTACharPos start, OTACharPos after, string text) { if (sourceEditor == null || editView == null) { return; } bool _FirstCharInLineDeleted; if (!isInclusive) { _FirstCharInLineDeleted = (after.CharIndex == 1); if (after.CharIndex > 0) { after.CharIndex -= 1; } } else { _FirstCharInLineDeleted = false; } int _StartPos = editView.CharPosToPos(start); int _AfterPos = editView.CharPosToPos(after); IOTAFileWriter _Writer = sourceEditor.CreateWriter(); _Writer.CopyTo(_StartPos); int _DeleteToPos = _AfterPos; if (after.CharIndex == 0 && ((after.Line - start.Line) == 1)) { _DeleteToPos -= 2; if (_FirstCharInLineDeleted) { _DeleteToPos = +3; } } else { if (_FirstCharInLineDeleted) { _DeleteToPos++; } else if (after.CharIndex > 0) { _DeleteToPos++; } } if (_DeleteToPos > _StartPos) { _Writer.DeleteTo(_DeleteToPos); } _Writer.Insert(text); _Writer.CopyTo(Int32.MaxValue); _Writer.Close(); }
/// <summary> /// Moves edit position to buffer position. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <param name="editPos">Edit position</param> /// <returns></returns> public static int EditPosToBufferPos(IOTASourceEditor sourceEditor, OTAEditPos editPos) { OTACharPos _CharPos = EditPosToCharPos(sourceEditor, editPos); return CharPosToBufferPos(sourceEditor, _CharPos); }
/// <summary> /// Replaces selected text. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <param name="lines">Lines</param> public static void ReplaceSelectedText(IOTASourceEditor sourceEditor, string lines) { IOTAEditView _EditView = OtaUtils.GetEditView(sourceEditor); if (_EditView != null) { if (_EditView.Block != null && !String.IsNullOrEmpty(_EditView.Block.Text)) { OTACharPos _Start = sourceEditor.BlockStart; OTACharPos _After = sourceEditor.BlockAfter; if (sourceEditor.BlockType == OTABlockType.btInclusive) { ReplaceInclusiveExclusive(sourceEditor, _EditView, true, _Start, _After, lines); } else if (sourceEditor.BlockType == OTABlockType.btNonInclusive) { ReplaceInclusiveExclusive(sourceEditor, _EditView, false, _Start, _After, lines); } else if (sourceEditor.BlockType == OTABlockType.btColumn) { // Column mode not supported //ReplaceColumns(TOTAEditPos(_Start), TOTAEditPos(_After), Text); } else if (sourceEditor.BlockType == OTABlockType.btLine) { _Start.CharIndex = 0; _After.CharIndex = 1023; // Max line length ReplaceInclusiveExclusive(sourceEditor, _EditView, true, _Start, _After, lines); } } else { InsertText(sourceEditor, lines); } } }
/// <summary> /// Moves edit position to char position. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <param name="editPos">Edit position</param> /// <returns></returns> public static OTACharPos EditPosToCharPos(IOTASourceEditor sourceEditor, OTAEditPos editPos) { IOTAEditView _EditView = GetEditView(sourceEditor); OTACharPos _CharPos = new OTACharPos(); if (_EditView != null) { _EditView.ConvertPos(true, ref editPos, ref _CharPos); } return _CharPos; }
/// <summary> /// Selects line. /// </summary> /// <param name="sourceEditor">Source editor</param> public static void SelectLine(IOTASourceEditor sourceEditor) { if (sourceEditor != null) { if (sourceEditor.EditViewCount > 0) { IOTAEditView _EditView = sourceEditor.GetEditView(0); OTAEditPos _EditPos = new OTAEditPos(); _EditPos.Line = _EditView.Position.Row; _EditPos.Col = 1; _EditView.CursorPos = _EditPos; _EditView.Block.BeginBlock(); _EditView.Block.Style = OTABlockType.btNonInclusive; if (_EditView.Position.MoveEOL()) { _EditView.MoveViewToCursor(); } _EditView.Block.EndBlock(); } } }
/// <summary> /// Creates file from buffer. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <param name="fileName">File name</param> public static void CreateFileFromBuffer(IOTASourceEditor sourceEditor, string fileName) { if (sourceEditor != null) { string content = GetSourceEditorText(sourceEditor); using (StreamWriter sw = new StreamWriter(File.OpenWrite(fileName), System.Text.Encoding.Unicode)) { // Add some text to the file. sw.Write(content); } } }
/// <summary> /// Selects text from position to position. /// </summary> /// <param name="sourceEditor">Source</param> /// <param name="startPos">Start position</param> /// <param name="endPos">End position</param> public static void SelectTextFromPosToPos(IOTASourceEditor sourceEditor, OTAEditPos startPos, OTAEditPos endPos) { if (sourceEditor != null) { if (sourceEditor.EditViewCount > 0) { IOTAEditView _EditView = sourceEditor.GetEditView(0); _EditView.CursorPos = startPos; _EditView.Block.BeginBlock(); _EditView.Block.Style = OTABlockType.btNonInclusive; _EditView.CursorPos = endPos; _EditView.MoveViewToCursor(); _EditView.Block.EndBlock(); } } }
/// <summary> /// Gets a line string of a certain line number. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <param name="number">Line number</param> /// <returns>null if wrong.</returns> public static string GetLineOf(IOTASourceEditor sourceEditor, int number) { if (sourceEditor == null || number < 0 || number >= sourceEditor.LinesInBuffer) { return null; } IOTAEditView view = sourceEditor.GetEditView(0); if (view == null) { return null; } IOTAEditPosition pos = view.Buffer.EditPosition; pos.Save(); pos.GotoLine(number); pos.MoveEOL(); int lastCol = pos.Column; pos.MoveBOL(); int firstCol = pos.Column; string result = pos.Read(lastCol - firstCol + 1); pos.Restore(); return result.Split(new char[] { '\r', '\n' })[0]; }
// /// <summary> // /// Gets current line. // /// </summary> // /// <param name="sourceEditor">Source editor</param> // /// <param name="lineNumber">Line number</param> // /// <returns>Current line.</returns> // /// <remarks> // /// <para>Ported from C#Builder Goodies.</para> // /// <para>Spaces are kept.</para> // /// </remarks> // [] // public static string GetCurrentLine(IOTASourceEditor sourceEditor, int lineNumber) { // //TODO : change it to getlineof // if (sourceEditor == null) { // return String.Empty; // } // string source = GetSourceEditorText(sourceEditor); // if (source.Length == 0 || lineNumber < 0 || lineNumber >= sourceEditor.LinesInBuffer) // {//GetTotalLines(sourceEditor)) { // return String.Empty; // } else { // string[] sourceLines = ShareUtils.GetLinesFromString(source); // //LoggingService.Info("There are " + sourceLines.Length.ToString() + " lines."); // //LoggingService.Info("the line is " + sourceLines[0]); // //string theLine = sourceLines[lineNumber - 1]; // return sourceLines[lineNumber - 1]; // } // } /// <summary> /// Gets total lines count. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <returns>Last row count or 0.</returns> public static int GetTotalLines(IOTASourceEditor sourceEditor) { Trace.Assert(sourceEditor != null); if (sourceEditor.EditViewCount > 0) { //IOTAEditView editView = sourceEditor.GetEditView(0); return sourceEditor.LinesInBuffer; // // IOTAEditPosition editPos = editView.Position; // return editPos.LastRow; } else { return 0; } }
/// <summary> /// Accepts an editor. /// </summary> /// <param name="editor">Editor</param> public void Accept(IOTASourceEditor editor) { Lextm.Diagnostics.LoggingService.Debug("This is an invalid key"); }
/// <summary> /// Gets char after cursor. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <returns>Char.MinValue if wrong.</returns> public static char GetCharAfterCursor(IOTASourceEditor sourceEditor) { LoggingService.EnterMethod(); char result = char.MinValue; if (sourceEditor != null) { if (sourceEditor.EditViewCount > 0) { IOTAEditView _EditView = sourceEditor.GetEditView(0); IOTAEditPosition _EditPos = _EditView.Position; //_EditPos.Save(); // bool canMove = _EditPos.MoveRelative(0, -1); // if (canMove) // no content // { result = _EditPos.Character; LoggingService.Info("get char result is " + result.ToString()); //} else { // LoggingService.Warn("cannot move, may it is the beginning of a line"); //} //_EditPos.Restore(); } else { LoggingService.Warn("no view"); } } else { LoggingService.Warn("null editor"); } LoggingService.LeaveMethod(); return result; }
/// <summary> /// Dispatcher for ending matching. /// </summary> /// <param name="editor">Source editor</param> /// <param name="lang">Language</param> internal static void DispatchKeywordIn( IOTASourceEditor editor, Language lang) { LoggingService.EnterMethod(); string text = OtaUtils.GetWordBeforeCursor(editor); GetKeyword(text, lang).Execute(editor); LoggingService.LeaveMethod(); }
/// <summary> /// Gets current word. /// </summary> /// <param name="sourceEditor">Source editor</param> /// <returns>String.Empty if no.</returns> public static string GetCurrentWord(IOTASourceEditor sourceEditor) { string _Source = GetSourceEditorText(sourceEditor); int _StartPos = GetSourceEditorTextPos(sourceEditor); if (_Source.Length == 0 || _StartPos < 0 || _StartPos >= _Source.Length) { return String.Empty; } if (IsWordCharacter(_Source[_StartPos])) { int _Begining = GoToBeginingOfWord(_Source, _StartPos); int _End = GoToEndOfWord(_Source, _StartPos); return _Source.Substring(_Begining, _End - _Begining); } else { return String.Empty; } }