/// ------------------------------------------------------------------------------------
/// <summary>
/// Moves the up before comment.
/// </summary>
/// <param name="sel">The sel.</param>
/// ------------------------------------------------------------------------------------
private void MoveUpBeforeComment(TextSelection sel)
{
TextRanges textRanges = null;
for (; true;)
{
if (sel.FindPattern("\\<summary\\>|/// ---", (int)(vsFindOptions.vsFindOptionsBackwards | vsFindOptions.vsFindOptionsRegularExpression),
ref textRanges))
{
// GhostDoc messes up dashed lines from inherited comments from base class,
// so delete those
if (sel.Text.StartsWith("/// ---"))
{
sel.EndOfLine(true);
sel.WordRight(true, 1);
sel.Delete(1);
}
else if (sel.Text.StartsWith("<summary>"))
{
while (true)
{
sel.MoveToLineAndOffset(sel.ActivePoint.Line - 1, 1, false);
sel.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstText, false);
sel.EndOfLine(true);
if (!sel.Text.StartsWith("///"))
{
if (sel.Text.Length > 0)
{
// there is a non-empty comment line. We want to start at the end
// of it
sel.EndOfLine(false);
}
else
{
sel.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstText, false);
}
break;
}
// GhostDoc messes up dashed lines from inherited comments from base class,
// so delete those
if (sel.Text.StartsWith("/// -----"))
{
sel.WordRight(true, 1);
sel.Delete(1);
}
}
return;
}
}
else
{
return;
}
}
}
private void JoinLine(TextSelection textSelection)
{
// If the selection has no length, try to pick up the next line.
if (textSelection.IsEmpty)
{
textSelection.LineDown(true);
textSelection.EndOfLine(true);
}
const string fluentPattern = @"[ \t]*\r?\n[ \t]*\.";
const string pattern = @"[ \t]*\r?\n[ \t]*";
var selection = textSelection.Text;
// do regex replace for fluent style
selection = Regex.Replace(selection, fluentPattern, ".");
// do regex replace for everything else
selection = Regex.Replace(selection, pattern, " ");
textSelection.Text = selection;
// Move the cursor forward, clearing the selection.
textSelection.CharRight();
}
/// <summary>Implements the Exec method of the IDTCommandTarget interface. This is called when the command is invoked.</summary>
/// <param term='commandName'>The name of the command to execute.</param>
/// <param term='executeOption'>Describes how the command should be run.</param>
/// <param term='varIn'>Parameters passed from the caller to the command handler.</param>
/// <param term='varOut'>Parameters passed from the command handler to the caller.</param>
/// <param term='handled'>Informs the caller if the command was handled or not.</param>
/// <seealso class='Exec' />
public void Exec(string commandName, vsCommandExecOption executeOption, ref object varIn, ref object varOut, ref bool handled)
{
handled = false;
if (executeOption == vsCommandExecOption.vsCommandExecOptionDoDefault)
{
if (commandName == "FormatVariableDefine.Connect.FormatVariableDefine" ||
commandName == "FormatVariableDefine.Connect.FormatVariableDefineRightClick")
{
TextSelection select = ((TextSelection)_applicationObject.ActiveDocument.Selection);
int nTopLine = select.TopLine;
int nBottomLine = select.BottomLine;
bool bLastLineEmpty = select.BottomPoint.AtStartOfLine;
select.GotoLine(nTopLine, true);
select.LineDown(true, nBottomLine - nTopLine);
select.EndOfLine(true);
if (bLastLineEmpty)
{
select.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstColumn, true);
}
string selectedCode = select.Text;
string outCode = CodeSmart.AlignText(selectedCode); //对齐选中文本
select.Insert(outCode, (int)vsInsertFlags.vsInsertFlagsCollapseToEnd);
handled = true;
return;
}
}
}
/// <summary>
/// 選択中の行を行選択状態にします。
/// </summary>
private static void SelectLines(TextSelection selection)
{
var bottom = selection.BottomLine;
selection.MoveToDisplayColumn(selection.TopLine, 1, false);
selection.MoveToDisplayColumn(bottom, 0, true);
selection.EndOfLine(true);
}
private string GetLineText(TextSelection objTextSelection)
{
try
{
VirtualPoint objActive = objTextSelection.ActivePoint;
objTextSelection.StartOfLine((EnvDTE.vsStartOfLineOptions)(0), true);
string text = objTextSelection.Text;
objTextSelection.EndOfLine(true);
var result = text + objTextSelection.Text;
objTextSelection.EndOfLine(false);
return(result);
}
catch (Exception ex)
{
ShowMessageBox("GetLineText()", ex.Message);
}
return(string.Empty);
}
/// <summary>
/// Joins the text within the specified text selection.
/// </summary>
/// <param name="textSelection">The text selection.</param>
private void JoinText(TextSelection textSelection)
{
// If the selection has no length, try to pick up the next line.
if (textSelection.IsEmpty)
{
textSelection.LineDown(true);
textSelection.EndOfLine(true);
}
const string pattern = @"[ \t]*\r?\n[ \t]*";
const string replacement = @" ";
// Substitute all new lines (and optional surrounding whitespace) with a single space.
TextDocumentHelper.SubstituteAllStringMatches(textSelection, pattern, replacement);
// Move the cursor forward, clearing the selection.
textSelection.CharRight();
}
/// <summary>
/// Joins the text within the specified text selection.
/// </summary>
/// <param name="textSelection">The text selection.</param>
private void JoinText(TextSelection textSelection)
{
// If the selection has no length, try to pick up the next line.
if (textSelection.IsEmpty)
{
textSelection.LineDown(true);
textSelection.EndOfLine(true);
}
const string pattern = @"[ \t]*\r?\n[ \t]*";
const string replacement = @" ";
// Substitute all new lines (and optional surrounding whitespace) with a single space.
TextDocumentHelper.SubstituteAllStringMatches(textSelection, pattern, replacement);
// Move the cursor forward, clearing the selection.
textSelection.CharRight();
}
/// <summary>
/// 选择当前行
/// </summary>
public void SelectLine()
{
try
{
// Retrieve document selection
TextSelection sel = (TextSelection)_dte.ActiveWindow.Document.Selection;
// Move to line
sel.MoveToDisplayColumn(sel.CurrentLine, 1, false);
// Select from start to end
sel.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstText, false);
sel.EndOfLine(true);
}
catch (ArgumentException)
{
}
}
/// <summary>
/// 智能分号：
/// * 如果在一行的中间任何位置按下分号，则跳到行结尾添加分号，如果行未已经有一个分号则不重复添加
/// * 再按一次分号，则删除在行尾添加的分号，回到刚才的位置插入一个分号
/// </summary>
/// <param name="keypress"></param>
/// <param name="selection"></param>
/// <param name="inStatementCompletion"></param>
/// <param name="cancelKeypress"></param>
public bool BeforeKeyPress(string keypress, TextSelection selection, bool inStatementCompletion, ref bool cancelKeypress)
{
if (!selection.IsEmpty || keypress != ";")
{
_smartSemicolonFallback = false;
return(false);
}
if (_smartSemicolonFallback && selection.CurrentLine == _smartSemicolonLine &&
selection.ActivePoint.AtEndOfLine && selection.ActivePoint.CreateEditPoint().GetText(-1) == ";")
{
// 重复输入分号, 删除原来行尾的分号，并退回到原位置插入分号
if (_smartSemicolonDeleteLineEnd)
{
selection.DeleteLeft(1);
}
selection.MoveTo(_smartSemicolonLine, _smartSemicolonColumn, false);
_smartSemicolonFallback = false;
cancelKeypress = false;
}
else
{
// 智能分号，记录位置并移动到行尾插入分号
_smartSemicolonFallback = true;
_smartSemicolonLine = selection.ActivePoint.Line;
_smartSemicolonColumn = selection.ActivePoint.DisplayColumn;
selection.EndOfLine();
var caret = selection.ActivePoint.CreateEditPoint();
if (caret.GetText(-1) == ";")
{
cancelKeypress = true;
_smartSemicolonDeleteLineEnd = false;
}
else
{
cancelKeypress = false;
_smartSemicolonDeleteLineEnd = true;
}
}
return(true);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Moves the down after comment.
/// </summary>
/// <param name="sel">The sel.</param>
/// ------------------------------------------------------------------------------------
private void MoveDownAfterComment(TextSelection sel)
{
// Go to the beginning of the line and move down until we find a line that doesn't
// start with ///.
while (true)
{
sel.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstText, false);
sel.EndOfLine(true);
if (!sel.Text.StartsWith("///"))
{
break;
}
// GhostDoc messes up dashed lines from inherited comments from base class,
// so delete those
if (sel.Text.StartsWith("/// -----"))
{
sel.WordRight(true, 1);
sel.Delete(1);
sel.LineUp(false, 1);
}
sel.MoveToLineAndOffset(sel.ActivePoint.Line + 1, 1, false);
}
}
private void UpdateComment(CodeFunction function, string oldDoc, int docLine, TextSelection ts, int oldLine, int offset, string lineEnding)
{
ThreadHelper.ThrowIfNotOnUIThread();
// Get the old parameters and return valus
var _oldParameters = GetDocLinesOfType(lineEnding, oldDoc, DocLineType._params);
var oldParameters = _oldParameters.Keys.Except(new[] { "__default__" }).ToList();
var oldReturns = GetDocLinesOfType(lineEnding, oldDoc, DocLineType._return);
string oldReturn = null;
if (oldReturns.ContainsKey("return"))
{
oldReturn = oldReturns["return"];
}
// Get all new function parameters and return value
var updatedParams = GetFunctionParams(function);
var updatedType = function.Type.AsString;
// Create new comment step by step...
string newDoc = oldDoc;
// Remove all old parameters
foreach (var param in oldParameters)
{
// Delete the line(s)
var pattern = Regex.Escape(_oldParameters[param]) + "( .*" + lineEnding + "|" + lineEnding + ")";
newDoc = Regex.Replace(newDoc, pattern, "");
}
// Remove old return statement
if (oldReturn != null)
{
// Delete the line(s)
var pattern = Regex.Escape(oldReturns["return"]) + "( .*" + lineEnding + "|" + lineEnding + ")";
newDoc = Regex.Replace(newDoc, pattern, "");
}
// Then add all parameters of the new function
var _oldParams = oldParameters.ToList();
var _uncertainNewParams = new List <string>();
var newParams = new Dictionary <string, string>();
foreach (var param in updatedParams)
{
// If there was the exact same parameter, add it again
if (_oldParams.Contains(param))
{
_oldParams.Remove(param);
newParams.Add(param, _oldParameters[param]);
}
else
{
newParams.Add(param, null);
_uncertainNewParams.Add(param);
}
}
// Check for special cases
if (_uncertainNewParams.Count > 0 && _oldParams.Count == 0)
{
_uncertainNewParams.Clear();
}
// If there are no special cases, but still open issues, ask the user
else if (_uncertainNewParams.Count > 0)
{
var dialog = new UpdateDoxygenCommentDialog(_oldParams, _uncertainNewParams);
if (dialog.ShowDialog() == DialogResult.OK)
{
// Add the selected parameters to the new parameter list
var selectedParams = dialog.finalParams;
foreach (var param in _uncertainNewParams)
{
var oldParam = selectedParams[param];
if (oldParam != null)
{
newParams[param] = _oldParameters[oldParam].Replace(oldParam, param);
}
}
}
}
// Add the new params to the documentation
foreach (var param in newParams)
{
newDoc = AddParamToDoc(lineEnding, newDoc, param.Key, param.Value, _oldParameters);
}
// Then add the return statement
if (!updatedType.Equals("void"))
{
newDoc = AddReturnToDoc(lineEnding, newDoc, oldReturn, oldReturns);
}
var oldDocLines = oldDoc.Split('\n');
var lineDiff = newDoc.Split('\n').Length - oldDocLines.Length;
ts.MoveToLineAndOffset(docLine + 1, 1);
ts.MoveToLineAndOffset(docLine + oldDocLines.Length - 1, 1, true);
ts.EndOfLine(true);
ts.Insert(newDoc.TrimSuffix(lineEnding));
ts.MoveToLineAndOffset(oldLine + lineDiff, offset);
}
private bool CheckIfInDocumentetFunction(TextSelection ts, int currentLine, int currentOffset, out CodeFunction codeFunction, out int functionLine)
{
ThreadHelper.ThrowIfNotOnUIThread();
// Get comment beginnings
string commentFormat = m_settings.FunctionFormat;
string[] formatLines = commentFormat.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
string commentStart = formatLines.First().Trim().Split(' ').First().Trim();
string commentMiddle = formatLines[1].Trim().Split(' ').First().Trim();
string commentEnd = formatLines.Last().Trim().Split(' ').First().Trim();
// Check if in comment
bool isComment = false;
functionLine = currentLine;
string line = m_textView.TextSnapshot.GetLineFromPosition(m_textView.Caret.Position.BufferPosition.Position).GetText().Trim();
if (line.StartsWith(commentStart) || line.StartsWith(commentMiddle) || line.StartsWith(commentEnd))
{
while (!ts.ActivePoint.AtEndOfDocument)
{
// Get the line of the curser
string _line = m_textView.TextSnapshot.GetLineFromLineNumber(ts.ActivePoint.Line - 1).GetText();
// Check if the comment ends
if (_line.Contains(commentEnd))
{
functionLine = ts.ActivePoint.Line + 1;
isComment = true;
break;
}
// If the end of the comment was not there, go one line down
ts.LineDown();
}
// If there is a comment start, but no correct ending, this is not a doxygen documentation
if (functionLine == currentLine)
{
codeFunction = null;
return(false);
}
}
codeFunction = null;
CodeElement codeElement = null;
FileCodeModel fcm = m_dte.ActiveDocument.ProjectItem.FileCodeModel;
if (fcm != null)
{
// Move to end of the current line
ts.MoveToLineAndOffset(functionLine, 1);
ts.EndOfLine();
// Check if there is a function
for (int lineNumber = functionLine; lineNumber <= functionLine + 3; lineNumber++)
{
codeElement = fcm.CodeElementFromPoint(ts.ActivePoint, vsCMElement.vsCMElementFunction);
if (codeElement != null && codeElement.Kind == vsCMElement.vsCMElementFunction)
{
functionLine = lineNumber;
break;
}
// Only search in the next line if the cursor was in the documentation
if (!isComment)
{
break;
}
string _line = m_textView.TextSnapshot.GetLineFromLineNumber(lineNumber - 1).GetText().Trim();
// If there was an empty line, check next one
if (_line.Length == 0)
{
ts.LineDown();
ts.EndOfLine();
}
// Otherwise the comment is not for a function
else
{
return(false);
}
}
}
bool isFunction = codeElement != null && codeElement.Kind == vsCMElement.vsCMElementFunction;
if (isFunction)
{
codeFunction = codeElement as CodeFunction;
return(codeFunction != null);
}
// Return if the line containes a function or not
return(isFunction);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Moves the up before comment.
/// </summary>
/// <param name="sel">The sel.</param>
/// ------------------------------------------------------------------------------------
private void MoveUpBeforeComment(TextSelection sel)
{
TextRanges textRanges = null;
for (; true; )
{
if (sel.FindPattern("\\<summary\\>|/// ---", (int)(vsFindOptions.vsFindOptionsBackwards | vsFindOptions.vsFindOptionsRegularExpression),
ref textRanges))
{
// GhostDoc messes up dashed lines from inherited comments from base class,
// so delete those
if (sel.Text.StartsWith("/// ---"))
{
sel.EndOfLine(true);
sel.WordRight(true, 1);
sel.Delete(1);
}
else if (sel.Text.StartsWith("<summary>"))
{
while (true)
{
sel.MoveToLineAndOffset(sel.ActivePoint.Line - 1, 1, false);
sel.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstText, false);
sel.EndOfLine(true);
if (!sel.Text.StartsWith("///"))
{
if (sel.Text.Length > 0)
{
// there is a non-empty comment line. We want to start at the end
// of it
sel.EndOfLine(false);
}
else
sel.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstText, false);
break;
}
// GhostDoc messes up dashed lines from inherited comments from base class,
// so delete those
if (sel.Text.StartsWith("/// -----"))
{
sel.WordRight(true, 1);
sel.Delete(1);
}
}
return;
}
}
else
return;
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Moves the down after comment.
/// </summary>
/// <param name="sel">The sel.</param>
/// ------------------------------------------------------------------------------------
private void MoveDownAfterComment(TextSelection sel)
{
// Go to the beginning of the line and move down until we find a line that doesn't
// start with ///.
while (true)
{
sel.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstText, false);
sel.EndOfLine(true);
if (!sel.Text.StartsWith("///"))
break;
// GhostDoc messes up dashed lines from inherited comments from base class,
// so delete those
if (sel.Text.StartsWith("/// -----"))
{
sel.WordRight(true, 1);
sel.Delete(1);
sel.LineUp(false, 1);
}
sel.MoveToLineAndOffset(sel.ActivePoint.Line + 1, 1, false);
}
}
/// <summary>
/// This function is the callback used to execute the command when the menu item is clicked.
/// See the constructor to see how the menu item is associated with this function using
/// OleMenuCommandService service and MenuCommand class.
/// </summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Event args.</param>
private void Execute(object sender, EventArgs e)
{
ThreadHelper.ThrowIfNotOnUIThread();
var dte = Package.GetGlobalService(typeof(DTE)) as DTE;
if (dte == null || dte.ActiveDocument == null)
{
return;
}
TextSelection ts = dte.ActiveDocument.Selection as TextSelection;
// Check if we're at the beginning of the document and should generate a file comment.
if (ts.ActivePoint.Line == 1)
{
string fileComment = m_generator.GenerateFileComment(dte, out int selectedLine);
ts.DeleteLeft(2); // Removing the // part here.
ts.Insert(fileComment);
// Move the caret.
ts.MoveToLineAndOffset(selectedLine + 1, 1);
ts.EndOfLine();
return;
}
ts.EndOfLine();
// Scroll down until we find a non-comment line.
if (!ScrollToCodeStart(ts))
{
return;
}
// Save the position so that we know where to place the comment.
ts.StartOfLine();
var funcPoint = ts.ActivePoint.CreateEditPoint();
int oldLine = ts.ActivePoint.Line;
int oldOffset = ts.ActivePoint.LineCharOffset;
ts.EndOfLine();
// Determine indentation level.
string currentLine = ts.ActivePoint.CreateEditPoint().GetLines(ts.ActivePoint.Line, ts.ActivePoint.Line + 1);
string spaces = currentLine.Replace(currentLine.TrimStart(), "");
// Search for the associated code element.
CodeElement codeElement = null;
FileCodeModel fcm = dte.ActiveDocument.ProjectItem.FileCodeModel;
if (fcm != null)
{
while (codeElement == null)
{
codeElement = fcm.CodeElementFromPoint(ts.ActivePoint, vsCMElement.vsCMElementFunction);
if (ts.ActivePoint.AtEndOfDocument)
{
break;
}
if (codeElement == null || !(codeElement is CodeFunction))
{
codeElement = null;
ts.LineDown();
ts.EndOfLine();
}
}
}
// Extract existing comment if found.
ts.MoveToLineAndOffset(oldLine, oldOffset);
int startLine = ExtractComment(ts, out string existingDoxyComment);
// Delete old comment from the text.
if (startLine >= 0)
{
ts.ActivePoint.CreateEditPoint().Delete(funcPoint);
oldLine = ts.ActivePoint.Line;
oldOffset = ts.ActivePoint.LineCharOffset;
}
// Generate new comment.
string doxyComment = m_generator.GenerateComment(spaces, codeElement, existingDoxyComment);
// Write the doxygen comment to the correct position.
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.LineUp();
// If the upper line is empty, we should go to the start of the line. Otherwise go to the end of the line.
currentLine = ts.ActivePoint.CreateEditPoint().GetLines(ts.ActivePoint.Line, ts.ActivePoint.Line + 1);
if (currentLine.Trim().Length == 0)
{
ts.StartOfLine();
}
else
{
ts.EndOfLine();
}
ts.Insert("\r\n" + spaces + doxyComment);
// If this is a new comment, move to the main comment position immediately.
if (startLine < 0)
{
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.LineDown();
ts.EndOfLine();
}
}
private static void addContentToProject(SolutionData solutionData, Project project, DTE2 dte2)
{
#region CPP Writing
if (solutionData.projectType == ProjectType.CppEmpty) //CPP Example
{
Directory.CreateDirectory(solutionData.directoryPath + "\\Source Files");
Directory.CreateDirectory(solutionData.directoryPath + "\\Header Files");
foreach (ClassData classData in solutionData.classes)
{
#region Class
if (classData.classType == ClassType.Class)
{
Document doc = dte2.ItemOperations.NewFile("General\\Text File", classData.className).Document;
TextSelection txtsel = (TextSelection)doc.Selection;
txtsel.Text = "";
txtsel.Insert("#include \"" + classData.className + ".h\"\n\n" + classData.className + "::" + classData.className + "()\n{\n}\n\n" + classData.className + "::~" + classData.className + "()\n{\n}");
doc.Save(solutionData.directoryPath + "\\Source Files\\" + classData.className + ".cpp");
project.ProjectItems.AddFromFile(solutionData.directoryPath + "\\Source Files\\" + classData.className + ".cpp");
Document doc2 = dte2.ItemOperations.NewFile("General\\Text File", classData.className).Document;
TextSelection txtsel2 = (TextSelection)doc2.Selection;
txtsel2.Text = "";
txtsel2.Insert("#pragma once");
if (classData.superClassName != "")
{
txtsel2.Insert("\n#include \"" + classData.superClassName + "\"");
}
foreach (string interfaceName in classData.interfaceNames)
{
txtsel2.Insert("\n#include \"" + interfaceName + "\"");
}
txtsel2.Insert("\n\nclass " + classData.className);
if (classData.superClassName != "")
{
txtsel2.Insert(" : public " + classData.superClassName);
foreach (string interfaceName in classData.interfaceNames)
{
txtsel2.Insert(", " + interfaceName);
}
}
else if (classData.interfaceNames.Count != 0)
{
txtsel2.Insert(" : " + classData.interfaceNames[0]);
for (int i = 1; i < classData.interfaceNames.Count; ++i)
{
txtsel2.Insert(", " + classData.interfaceNames[i]);
}
}
txtsel2.Insert("\n{\npublic:\n\t" + classData.className + "();\n\t~" + classData.className + "();\n\nprivate:\n\n};");
doc2.Save(solutionData.directoryPath + "\\Header Files\\" + classData.className + ".h");
project.ProjectItems.AddFromFile(solutionData.directoryPath + "\\Header Files\\" + classData.className + ".h");
}
#endregion
#region Enum
else if (classData.classType == ClassType.Enum)
{
EnvDTE.Document doc2 = dte2.ItemOperations.NewFile("General\\Text File", classData.className).Document;
TextSelection txtsel2 = (TextSelection)doc2.Selection;
txtsel2.Text = "";
txtsel2.Insert("#pragma once\n\nenum " + classData.className + "\n{\n\n};");
doc2.Save(solutionData.directoryPath + "\\Header Files\\" + classData.className + ".h");
project.ProjectItems.AddFromFile(solutionData.directoryPath + "\\Header Files\\" + classData.className + ".h");
}
#endregion
}
}
#endregion
#region C# Writing
else //C# Example
{
foreach (ProjectItem pItem in project.ProjectItems)
{
if (pItem.Name == "Form1.cs")
{
pItem.Remove();
}
}
foreach (ClassData classData in solutionData.classes)
{
if (classData.classType == ClassType.Enum || classData.classType == ClassType.Class || classData.classType == ClassType.Interface)
{
project.ProjectItems.AddFromTemplate(@"C:\Program Files (x86)\Microsoft Visual Studio " + dte2.Version + @"\Common7\IDE\ItemTemplates\CSharp\Code\1033\Class\Class.vstemplate", classData.className + ".cs");
}
else if (classData.classType == ClassType.Form)
{
project.ProjectItems.AddFromTemplate(@"c:\Program Files (x86)\Microsoft Visual Studio " + dte2.Version + @"\Common7\IDE\ItemTemplates\CSharp\Windows Forms\1033\Form\windowsform.vstemplate", classData.className + ".cs");
}
ProjectItem projectItem = null;
foreach (ProjectItem pItem in project.ProjectItems)
{
if (pItem.Name == classData.className + ".cs")
{
projectItem = pItem;
break;
}
}
projectItem.Save();
TextSelection txtsel = (TextSelection)projectItem.Document.Selection;
#region Class
if (classData.classType == ClassType.Class)
{
txtsel.GotoLine(9);
txtsel.EndOfLine();
if (classData.superClassName != "")
{
txtsel.Insert(" : " + classData.superClassName);
foreach (string interfaceName in classData.interfaceNames)
{
txtsel.Insert(", " + interfaceName);
}
}
else if (classData.interfaceNames.Count != 0)
{
txtsel.Insert(" : " + classData.interfaceNames[0]);
for (int i = 1; i < classData.interfaceNames.Count; ++i)
{
txtsel.Insert(", " + classData.interfaceNames[i]);
}
}
}
#endregion
#region Enum
else if (classData.classType == ClassType.Enum)
{
txtsel.GotoLine(9);
txtsel.StartOfLine();
txtsel.CharRight(false, 4);
txtsel.DestructiveInsert("enum");
txtsel.Delete();
}
#endregion
#region Interface
else if (classData.classType == ClassType.Interface)
{
txtsel.GotoLine(9);
txtsel.StartOfLine();
txtsel.CharRight(false, 4);
txtsel.Insert("interface");
txtsel.Delete(5);
}
#endregion
}
}
#endregion
}
/// <summary>
/// Creates and adds documentation comment blocks when the user types a triple slash.
/// </summary>
private void HandleTripleSlash()
{
ThreadHelper.ThrowIfNotOnUIThread();
// Get the original placement of the cursor in the code editor
TextSelection ts = (TextSelection)Dte.ActiveDocument.Selection;
int oldLine = ts.ActivePoint.Line;
int oldOffset = ts.ActivePoint.LineCharOffset;
// Check to see if the previous line starts with a triple-slash; if it does, we should probably
// just return because there's most likely a docstring already in place.
ts.LineUp();
ts.StartOfLine();
string previousLine = TextView.TextSnapshot.GetLineFromPosition(
TextView.Caret.Position.BufferPosition.Position).GetText();
if (previousLine.TrimStart().StartsWith("///"))
{
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.Insert("/"); // Add the slash that the user just typed
return;
}
// Get the contents of the next line (the one following the original line)
ts.LineDown();
ts.LineDown();
ts.StartOfLine();
int currentCharIndex = TextView.Caret.Position.BufferPosition.Position;
string fullText = TextView.TextSnapshot.GetText();
// Check if we just triple-slashed a method (a function or an operation)
Match methodMatch = GetMethodSignatureMatch(currentCharIndex, fullText);
if (methodMatch != null)
{
Logger.Debug($"Found a potential method match: [{methodMatch.Value}]");
string signatureString = methodMatch.Groups["Signature"].Value;
string leadingSpaces = methodMatch.Groups["Spaces"].Value;
// Build the summary section, which is going to go in no matter what
StringBuilder commentBuilder = new StringBuilder();
commentBuilder.AppendLine("/ # Summary");
commentBuilder.Append(leadingSpaces + "/// ");
// Ask the Q# parser application to pull out all of the method details so we know what to
// put into the documentation comments, and add them if parsing succeeded
Logger.Debug("Sending a parse request to the Q# parser...");
try
{
MethodSignatureResponse signature = Messenger.RequestMethodSignatureParse(signatureString);
if (signature != null)
{
Logger.Debug($"Parsing succeeded, method name = [{signature.Name}], " +
$"{signature.ParameterNames.Count} parameters, returns something = {signature.HasReturnType}.");
BuildMethodCommentBlock(signature, commentBuilder, leadingSpaces);
}
}
catch (Exception ex)
{
Logger.Error($"Error during method signature request: {ex.GetType().Name} - {ex.Message}");
Logger.Trace(ex.StackTrace);
}
// Move to the original cursor position and add the comment block to the code
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.Insert(commentBuilder.ToString());
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.LineDown();
ts.EndOfLine();
return;
}
// Check if we just triple-slashed a new type
Match newtypeMatch = GetNewTypeMatch(currentCharIndex, fullText);
if (newtypeMatch != null)
{
Logger.Debug($"Found a newtype match: [{newtypeMatch.Value}]");
string leadingSpaces = newtypeMatch.Groups["Spaces"].Value;
// Build the summary section
StringBuilder commentBuilder = new StringBuilder();
commentBuilder.AppendLine("/ # Summary");
commentBuilder.Append(leadingSpaces + "/// ");
// Move to the original cursor position and add the comment block to the code
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.Insert(commentBuilder.ToString());
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.LineDown();
ts.EndOfLine();
return;
}
// If this was a triple slash on something else, just add the slash and return.
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.Insert("/");
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Inserts the method header.
/// </summary>
/// ------------------------------------------------------------------------------------
public void InsertMethodHeader()
{
TextSelection sel = (TextSelection)m_applicationObject.ActiveDocument.Selection;
CodeElement codeElement = GetMethodOrProperty(sel);
if (codeElement == null)
{
codeElement = sel.ActivePoint.get_CodeElement(vsCMElement.vsCMElementClass);
if (codeElement == null)
{
codeElement = sel.ActivePoint.get_CodeElement(vsCMElement.vsCMElementInterface);
}
if (codeElement == null || codeElement.StartPoint.Line != sel.ActivePoint.Line)
{
// not a function or property, so just insert /// <summary/>
sel.LineUp(false, 1);
if (!IsXmlCommentLine)
{
sel.EndOfLine(false);
sel.NewLine(1);
sel.Text = "///";
sel.LineDown(true, 1);
sel.Delete(1);
sel.LineUp(false, 1);
sel.EndOfLine(false);
sel.WordRight(true, 2);
sel.Delete(1);
}
else
{
sel.LineDown(false, 1);
}
return;
}
}
sel.MoveToPoint(codeElement.StartPoint, false);
// Figure out indentation and build dashed line
sel.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstColumn, false);
sel.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstText, true);
string indent = sel.Text;
sel.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstText, false);
string dashedLine = indent + "/// " +
new string('-', kLineLen - sel.ActivePoint.VirtualDisplayColumn - 4);
bool fGhostDoc = true;
try
{
// Use GhostDoc if available
string addinName = string.Empty;
foreach (AddIn addin in m_applicationObject.AddIns)
{
if (addin.Name == "GhostDoc")
{
addinName = (addin.ProgID == "SubMain.GhostDoc.Connect") ?
"Tools.SubMain.GhostDoc.DocumentThis" : "Weigelt.GhostDoc.AddIn.DocumentThis";
break;
}
}
if (addinName != string.Empty)
{
m_applicationObject.ExecuteCommand(addinName, string.Empty);
}
else
{
fGhostDoc = false;
}
}
catch
{
fGhostDoc = false;
}
if (fGhostDoc)
{
int nLine = sel.ActivePoint.Line;
int nLineOffset = sel.ActivePoint.LineCharOffset;
// Check to see if we're in the middle of the comment or at the beginning of
// the method.
sel.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstText, false);
if (GetMethodOrProperty(sel) == null)
{
// we're in the middle of the comment - move to the end of the comment
MoveDownAfterComment(sel);
// we're inserting one line (//---) above
nLine++;
}
else
{
// We are at the beginning of the method.
// Check to see if the line above the current line is an attribute. If it is we want to
// start there, otherwise we start at the current line.
sel.LineUp(false, 1);
sel.CharRight(false, 1);
if (sel.ActivePoint.get_CodeElement(vsCMElement.vsCMElementAttribute) == null)
{
sel.MoveToLineAndOffset(nLine, 1, false);
}
// we're inserting two lines above
nLine += 2;
}
// In case the line is wrapped, we want to go to the real beginning of the line
sel.MoveToLineAndOffset(sel.ActivePoint.Line, 1, false);
sel.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstColumn, false);
// Insert a new line and then insert our dashed line.
sel.Insert(dashedLine + Environment.NewLine, (int)vsInsertFlags.vsInsertFlagsCollapseToEnd);
sel.LineUp(false, 1);
sel.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstText, false);
MoveUpBeforeComment(sel);
sel.Insert(Environment.NewLine + dashedLine, (int)vsInsertFlags.vsInsertFlagsCollapseToEnd);
sel.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstText, false);
// put IP at previous location
sel.MoveToLineAndOffset(nLine, nLineOffset, false);
}
else
{
// check if we already have a comment
sel.LineUp(false, 1);
if (!IsXmlCommentLine)
{
// Insert comment
sel.EndOfLine(false);
sel.NewLine(1);
sel.Text = "///";
}
// Insert line above
MoveUpBeforeComment(sel);
sel.EndOfLine(false);
sel.NewLine(1);
sel.Text = dashedLine;
int upperLine = sel.ActivePoint.Line;
sel.LineDown(false, 1);
// reformat text
for (; IsXmlCommentLine;)
{
int curLine = sel.CurrentLine;
// go through all words in this line
for (; sel.CurrentLine == curLine; sel.WordRight(false, 1))
{
if (sel.ActivePoint.VirtualDisplayColumn > kLineLen)
{
// we have to break before this word
sel.WordLeft(true, 1);
// skip all punctuation characters
for (; sel.Text.Length == 1 && char.IsPunctuation(sel.Text[0]);)
{
sel.CharLeft(false, 1); // removes selection
sel.WordLeft(true, 1);
}
sel.CharLeft(false, 1); // removes selection
// break the line
sel.NewLine(1);
// join next line with remainder of current line
sel.EndOfLine(false);
sel.LineDown(true, 1);
sel.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstText, true);
sel.WordRight(true, 1);
sel.Delete(1);
// insert a space between the two lines
sel.Text = " ";
}
}
}
// Insert line below
sel.GotoLine(upperLine + 1, false);
MoveDownAfterComment(sel);
sel.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstText, false);
sel.NewLine(1);
sel.LineUp(false, 1);
sel.Text = dashedLine;
sel.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstText, false);
sel.LineDown(false, 1);
}
}
private void GetTypeAndNameForOperatorCompletion(ref TextSelection ts, out String typeName, out String varName)
{
ts.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstColumn, false);
ts.EndOfLine(true);
String lineText = SPTrim(ts.Text);
int lastGtPos = lineText.IndexOf('>');
if(lastGtPos == -1) {
// non-template
int lastSpPos = lineText.IndexOf(' ');
typeName = SPTrim(lineText.Substring(0, lastSpPos));
lineText = SPTrim(lineText.Substring(lastSpPos + 1));
} else {
// template code
int prevGtPos;
do {
prevGtPos = lastGtPos;
lastGtPos = lineText.IndexOf('>', lastGtPos + 1);
} while(lastGtPos >= 0);
typeName = SPTrim(lineText.Substring(0, prevGtPos + 1));
lineText = SPTrim(lineText.Substring(prevGtPos + 1));
}
int spPos = lineText.IndexOf(' ');
if(spPos < 0) {
varName = SPTrim(lineText);
} else {
varName = SPTrim(lineText.Substring(0, spPos));
}
}
/// <summary>
/// Generates a Doxygen comment block to the current caret location.
/// </summary>
private void GenerateComment()
{
var currentILine = m_textView.TextSnapshot.GetLineFromPosition(m_textView.Caret.Position.BufferPosition.Position);
int len = m_textView.Caret.Position.BufferPosition.Position - currentILine.Start.Position;
string currentLine = m_textView.TextSnapshot.GetText(currentILine.Start.Position, len);
string spaces = currentLine.Replace(currentLine.TrimStart(), "");
ThreadHelper.ThrowIfNotOnUIThread();
TextSelection ts = m_dte.ActiveDocument.Selection as TextSelection;
// Save current care position.
int oldLine = ts.ActivePoint.Line;
int oldOffset = ts.ActivePoint.LineCharOffset;
// Check if we're at the beginning of the document and should generate a file comment.
if (oldLine == 1)
{
string fileComment = m_generator.GenerateFileComment(m_dte, out int selectedLine);
ts.DeleteLeft(2); // Removing the // part here.
ts.Insert(fileComment);
// Move the caret.
ts.MoveToLineAndOffset(selectedLine + 1, 1);
ts.EndOfLine();
return;
}
// Search for the associated code element for which to generate the comment.
CodeElement codeElement = null;
ts.LineDown();
ts.EndOfLine();
FileCodeModel fcm = m_dte.ActiveDocument.ProjectItem.FileCodeModel;
if (fcm != null)
{
while (codeElement == null)
{
codeElement = fcm.CodeElementFromPoint(ts.ActivePoint, vsCMElement.vsCMElementFunction);
if (ts.ActivePoint.AtEndOfDocument)
{
break;
}
if (codeElement == null)
{
ts.LineDown();
}
}
}
// Generate the comment and add it to the document.
string doxyComment = m_generator.GenerateComment(spaces, codeElement, "");
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.DeleteLeft(2); // Removing the // part here.
ts.Insert(doxyComment);
// Move caret to the position where the main comment will be written.
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.LineDown();
ts.EndOfLine();
}
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
{
try
{
if (VsShellUtilities.IsInAutomationFunction(m_provider.ServiceProvider))
{
return(m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut));
}
// make a copy of this so we can look at it after forwarding some commands
uint commandID = nCmdID;
char typedChar = char.MinValue;
// make sure the input is a char before getting it
if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR)
{
typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn);
}
// check for the triple slash
if (typedChar == '/' && m_dte != null)
{
string currentLine = m_textView.TextSnapshot.GetLineFromPosition(
m_textView.Caret.Position.BufferPosition.Position).GetText();
if ((currentLine + "/").Trim() == "///")
{
// Calculate how many spaces
string spaces = currentLine.Replace(currentLine.TrimStart(), "");
TextSelection ts = m_dte.ActiveDocument.Selection as TextSelection;
int oldLine = ts.ActivePoint.Line;
int oldOffset = ts.ActivePoint.LineCharOffset;
ts.LineDown();
ts.EndOfLine();
CodeElement codeElement = null;
FileCodeModel fcm = m_dte.ActiveDocument.ProjectItem.FileCodeModel;
if (fcm != null)
{
codeElement = fcm.CodeElementFromPoint(ts.ActivePoint, vsCMElement.vsCMElementFunction);
}
if (codeElement != null && codeElement is CodeFunction)
{
CodeFunction function = codeElement as CodeFunction;
StringBuilder sb = new StringBuilder("/ <summary>\r\n" + spaces + "/// \r\n" + spaces + "/// </summary>");
foreach (CodeElement child in codeElement.Children)
{
CodeParameter parameter = child as CodeParameter;
if (parameter != null)
{
sb.AppendFormat("\r\n" + spaces + "/// <param name=\"{0}\"></param>", parameter.Name);
}
}
if (function.Type.AsString != "void")
{
sb.AppendFormat("\r\n" + spaces + "/// <returns></returns>");
}
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.Insert(sb.ToString());
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.LineDown();
ts.EndOfLine();
return(VSConstants.S_OK);
}
else
{
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.Insert("/ <summary>\r\n" + spaces + "/// \r\n" + spaces + "/// </summary>");
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.LineDown();
ts.EndOfLine();
return(VSConstants.S_OK);
}
}
}
if (m_session != null && !m_session.IsDismissed)
{
// check for a commit character
if (nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN ||
nCmdID == (uint)VSConstants.VSStd2KCmdID.TAB ||
typedChar == '>')
{
// check for a selection
// if the selection is fully selected, commit the current session
if (m_session.SelectedCompletionSet.SelectionStatus.IsSelected)
{
string selectedCompletion = m_session.SelectedCompletionSet.SelectionStatus.Completion.DisplayText;
m_session.Commit();
TextSelection ts = m_dte.ActiveDocument.Selection as TextSelection;
switch (selectedCompletion)
{
case "<!-->":
ts.CharLeft(false, 3);
break;
case "<![CDATA[>":
ts.CharLeft(false, 3);
break;
case "<c>":
ts.CharLeft(false, 4);
break;
case "<code>":
ts.CharLeft(false, 7);
break;
case "<example>":
ts.CharLeft(false, 10);
break;
case "<exception>":
ts.CharLeft(false, 14);
break;
case "<include>":
ts.CharLeft(false, 21);
break;
case "<list>":
ts.CharLeft(false, 7);
break;
case "<para>":
ts.CharLeft(false, 7);
break;
case "<param>":
ts.CharLeft(false, 10);
break;
case "<paramref>":
ts.CharLeft(false, 13);
break;
case "<permission>":
ts.CharLeft(false, 15);
break;
case "<remarks>":
ts.CharLeft(false, 10);
break;
case "<returns>":
ts.CharLeft(false, 10);
break;
case "<see>":
ts.CharLeft(false, 3);
break;
case "<seealso>":
ts.CharLeft(false, 3);
break;
case "<typeparam>":
ts.CharLeft(false, 14);
break;
case "<typeparamref>":
ts.CharLeft(false, 3);
break;
case "<value>":
ts.CharLeft(false, 8);
break;
default:
break;
}
// also, don't add the character to the buffer
return(VSConstants.S_OK);
}
else
{
// if there is no selection, dismiss the session
m_session.Dismiss();
}
}
}
else
{
if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN)
{
string currentLine = m_textView.TextSnapshot.GetLineFromPosition(
m_textView.Caret.Position.BufferPosition.Position).GetText();
if (currentLine.TrimStart().StartsWith("///"))
{
TextSelection ts = m_dte.ActiveDocument.Selection as TextSelection;
string spaces = currentLine.Replace(currentLine.TrimStart(), "");
ts.Insert("\r\n" + spaces + "/// ");
return(VSConstants.S_OK);
}
}
}
// pass along the command so the char is added to the buffer
int retVal = m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
if (typedChar == '<')
{
string currentLine = m_textView.TextSnapshot.GetLineFromPosition(
m_textView.Caret.Position.BufferPosition.Position).GetText();
if (currentLine.TrimStart().StartsWith("///"))
{
if (m_session == null || m_session.IsDismissed) // If there is no active session, bring up completion
{
if (this.TriggerCompletion())
{
m_session.SelectedCompletionSet.SelectBestMatch();
m_session.SelectedCompletionSet.Recalculate();
return(VSConstants.S_OK);
}
}
}
}
else if (
commandID == (uint)VSConstants.VSStd2KCmdID.BACKSPACE ||
commandID == (uint)VSConstants.VSStd2KCmdID.DELETE ||
char.IsLetter(typedChar))
{
if (m_session != null && !m_session.IsDismissed) // the completion session is already active, so just filter
{
m_session.SelectedCompletionSet.SelectBestMatch();
m_session.SelectedCompletionSet.Recalculate();
return(VSConstants.S_OK);
}
}
return(retVal);
}
catch
{
}
return(VSConstants.E_FAIL);
}
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
{
try
{
ThreadHelper.ThrowIfNotOnUIThread();
if (VsShellUtilities.IsInAutomationFunction(m_provider.ServiceProvider))
{
return(m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut));
}
// make a copy of this so we can look at it after forwarding some commands
uint commandID = nCmdID;
char typedChar = char.MinValue;
// make sure the input is a char before getting it
if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR)
{
typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn);
}
// Check if it is a commit character, to generate a multiline comment
bool isCommitChar = nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN ||
nCmdID == (uint)VSConstants.VSStd2KCmdID.TAB;
bool showCompletion = nCmdID == (uint)VSConstants.VSStd2KCmdID.COMPLETEWORD;
// Handle only typed characters or in case of an active completion also deletions
if (typedChar == '\0' && !isCommitChar && !showCompletion)
{
return(m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut));
}
// check if the last character of one of the supported shortcuts is typed
if (!m_provider.CompletionBroker.IsCompletionActive(m_textView) &&
m_dte != null &&
(typedChar == m_header_char || isCommitChar || typedChar == '!'))
{
var currentILine = m_textView.TextSnapshot.GetLineFromPosition(
m_textView.Caret.Position.BufferPosition.Position);
int len = m_textView.Caret.Position.BufferPosition.Position - currentILine.Start.Position;
string currentLine = m_textView.TextSnapshot.GetText(currentILine.Start.Position, len);
string currentLineFull = currentILine.GetText();
string typed_shortcut = (currentLine + typedChar).Trim();
if (typed_shortcut.Trim().Length >= 3)
{
// Get the current text properties
TextSelection ts = m_dte.ActiveDocument.Selection as TextSelection;
int oldLine = ts.ActivePoint.Line;
int oldOffset = ts.ActivePoint.LineCharOffset;
string lineEnding = GetLineEnding();
// First use only single line comment
// Single line comments are not supported in the first line, because of the header comment
if (typedChar == '*' && typed_shortcut == "/**" && oldLine > 1)
{
ts.Insert(typedChar + " ");
if (!currentLineFull.Contains("*/"))
{
ts.Insert("*/");
}
ts.MoveToLineAndOffset(oldLine, oldOffset + 2);
return(VSConstants.S_OK);
}
// If it is a commit character check if there is a comment to expand
if (isCommitChar &&
ShouldExpand(ts, currentLineFull, oldLine, oldOffset, out var commentFormat, out var codeElement, out var shortcut))
{
// Replace all possible comment characters to get the raw brief
string currentText = Regex.Replace(currentLineFull.Replace(shortcut, ""), @"\/\*+|\*+\/|\/\/+", "").Trim();
// Delete current comment
int lenToDelete = Regex.Replace(currentLineFull, @".*\/\*|^[^\/]*\/\/", "").Length;
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.EndOfLine();
ts.DeleteLeft(lenToDelete);
// Create new multiline comment
currentLine = currentLineFull.Substring(0, currentLineFull.Length - lenToDelete);
currentLineFull = currentLine;
oldOffset = ts.ActivePoint.LineCharOffset;
return(InsertMultilineComment(commentFormat, codeElement, ts, currentLine, lineEnding,
oldLine, oldOffset, currentText));
}
// The header can be used without single line format
else if (oldLine == 1)
{
var headerShortcut = m_settings.HeaderFormat.Substring(0, 3);
if (typed_shortcut == headerShortcut || typed_shortcut == "/**" || typed_shortcut == "/*!" || typed_shortcut == "///")
{
// Delete current end comment chars
ts.EndOfLine();
int lenToDelete = ts.ActivePoint.LineCharOffset - oldOffset;
ts.DeleteLeft(lenToDelete);
return(InsertMultilineComment(CommentFormat.header, null, ts, currentLine, lineEnding,
oldLine, oldOffset, ""));
}
}
// '/*!' is a always active shortcut without single line
// This is for an eseaier beginning and for the same workflow as older versions
else if (typed_shortcut == "/*!")
{
var _commentFormat = GetCommentFormat(ts, oldLine, oldOffset, out var _codeElement);
// Delete current end comment chars
ts.EndOfLine();
int lenToDelete = ts.ActivePoint.LineCharOffset - oldOffset;
ts.DeleteLeft(lenToDelete);
return(InsertMultilineComment(_commentFormat, _codeElement, ts, currentLine, lineEnding,
oldLine, oldOffset, ""));
}
}
}
if (m_session != null && !m_session.IsDismissed)
{
// check for a commit character
if (nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN ||
nCmdID == (uint)VSConstants.VSStd2KCmdID.TAB)
{
// check for a selection
// if the selection is fully selected, commit the current session
if (m_session.SelectedCompletionSet.SelectionStatus.IsSelected)
{
m_session.Commit();
// also, don't add the character to the buffer
return(VSConstants.S_OK);
}
else
{
// if there is no selection, dismiss the session
m_session.Dismiss();
}
}
}
else if (!m_provider.CompletionBroker.IsCompletionActive(m_textView))
{
if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN)
{
ITextSnapshotLine currentILine = m_textView.TextSnapshot.GetLineFromPosition(
m_textView.Caret.Position.BufferPosition.Position);
string currentLine = currentILine.GetText();
// TODO: check for being inside a comment block
// Insert a '*' when creating a new line in a mutline comment
if (currentLine.TrimStart().StartsWith("*") && !currentLine.Contains("*/"))
{
TextSelection ts = m_dte.ActiveDocument.Selection as TextSelection;
string spaces = currentLine.Replace(currentLine.TrimStart(), "");
string lineEnding = GetLineEnding();
ts.Insert(lineEnding + spaces + "* ");
return(VSConstants.S_OK);
}
// Insert a '///' when creating a new line in a mutline comment
if (currentLine.TrimStart().StartsWith("///"))
{
TextSelection ts = m_dte.ActiveDocument.Selection as TextSelection;
string spaces = currentLine.Replace(currentLine.TrimStart(), "");
string lineEnding = GetLineEnding();
ts.Insert(lineEnding + spaces + "/// ");
return(VSConstants.S_OK);
}
}
}
// pass along the command so the char is added to the buffer
int retVal = m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
if (typedChar == '\\' || typedChar == '@' || showCompletion)
{
string currentLine = m_textView.TextSnapshot.GetLineFromPosition(
m_textView.Caret.Position.BufferPosition.Position).GetText();
if (currentLine.TrimStart().StartsWith("*") || currentLine.TrimStart().StartsWith("///"))
{
if (m_session == null || m_session.IsDismissed) // If there is no active session, bring up completion
{
if (this.TriggerCompletion())
{
m_session.SelectedCompletionSet.SelectBestMatch();
m_session.SelectedCompletionSet.Recalculate();
return(VSConstants.S_OK);
}
}
}
}
else if (
commandID == (uint)VSConstants.VSStd2KCmdID.BACKSPACE ||
commandID == (uint)VSConstants.VSStd2KCmdID.DELETE ||
char.IsLetter(typedChar))
{
if (m_session != null && !m_session.IsDismissed) // the completion session is already active, so just filter
{
m_session.SelectedCompletionSet.SelectBestMatch();
m_session.SelectedCompletionSet.Recalculate();
return(VSConstants.S_OK);
}
}
return(retVal);
}
/// <summary>
/// Tries to detect the top level function declaration and adds comment if it was a function.
/// </summary>
/// <param name="textSelection">The <see cref="TextSelection"/>.</param>
/// <returns>True if successful; otherwise false.</returns>
private bool TryAddCommentForTopLevelFunctionDeclaration(TextSelection textSelection, string lineBreak, string indent, int lineNum, int offset)
{
// Create an edit point
var editPoint = textSelection.ActivePoint.CreateEditPoint();
// Get the function declaration
string functionLine = editPoint.GetLines(editPoint.Line, editPoint.Line + 1);
// Check if it's empty or there is no left parentheses
if (String.IsNullOrEmpty(functionLine) || functionLine.IndexOf('(') < 0)
{
return(false);
}
// If there is no semi-colon, then find the semi-colon
if (functionLine.TrimEnd().EndsWith(";"))
{
editPoint.EndOfLine();
editPoint.CharLeft();
}
else
{
editPoint.EndOfLine();
editPoint = this.FindFirstMatch(editPoint, ";");
}
if (editPoint == null)
{
return(false);
}
// Get the end of the text
var endPoint = editPoint.CreateEditPoint();
endPoint.EndOfLine();
string text = editPoint.GetText(endPoint);
// Remove the text and append {}
editPoint.Delete(endPoint);
editPoint.Insert("{}");
var codeElement = editPoint.CodeElement[vsCMElement.vsCMElementFunction];
if (codeElement == null || !(codeElement is CodeFunction))
{
// Remove the text and append original text
editPoint.CharLeft(2);
editPoint.Delete(2);
editPoint.Insert(text);
textSelection.MoveToLineAndOffset(lineNum, offset);
return(false);
}
// Generate comment for function
StringBuilder sb = new StringBuilder("/ <summary>" + lineBreak + indent + "/// " + lineBreak + indent + "/// </summary>");
foreach (CodeElement child in codeElement.Children)
{
CodeParameter parameter = child as CodeParameter;
if (parameter != null)
{
sb.AppendFormat("{0}{1}/// <param name=\"{2}\"></param>", lineBreak, indent, parameter.Name);
}
}
// If there is the return type is not void, generate a returns element
var function = codeElement as CodeFunction;
if (function.Type.AsString != "void")
{
sb.AppendFormat("{0}{1}/// <returns></returns>", lineBreak, indent);
}
// Insert comment
textSelection.MoveToLineAndOffset(lineNum, offset);
textSelection.Insert(sb.ToString());
// Remove the text and append original text
editPoint.CharLeft(2);
editPoint.Delete(2);
editPoint.Insert(text);
// Move the caret to the summary section
textSelection.MoveToLineAndOffset(lineNum + 1, offset);
textSelection.EndOfLine();
// Return success
return(true);
}
private void DoFormat(bool selected)
{
if (_dte == null || _dte.ActiveDocument == null)
{
return;
}
string text = "";
string initIndent = "";
EditPoint sp;
EditPoint sd;
if (selected)
{
TextSelection sel = (TextSelection)_dte.ActiveDocument.Selection;
sp = sel.TopPoint.CreateEditPoint();
sd = sel.BottomPoint.CreateEditPoint();
sel.MoveToLineAndOffset(sp.Line, 1);
sel.MoveToLineAndOffset(sd.Line, 1, true);
sel.EndOfLine(true);
sp = sel.TopPoint.CreateEditPoint();
sd = sel.BottomPoint.CreateEditPoint();
text = sel.Text;
foreach (var ch in text)
{
if (ch != ' ' && ch != '\t')
{
break;
}
initIndent += ch;
}
}
else
{
TextDocument doc = (TextDocument)_dte.ActiveDocument.Object("TextDocument");
sp = doc.StartPoint.CreateEditPoint();
sd = doc.EndPoint.CreateEditPoint();
text = sp.GetText(sd);
}
if (String.IsNullOrEmpty(text))
{
return;
}
string eol = GetEol(text);
int lang = GetLanguage();
int sizeOut = 0;
int sizeMsg = 0;
if (NativeMethods.DoFormatter(lang, text, null, ref sizeOut, null, ref sizeMsg, 0, eol, initIndent))
{
StringBuilder textOut = new StringBuilder(sizeOut);
StringBuilder textMsg = new StringBuilder(sizeMsg);
if (NativeMethods.DoFormatter(lang, text, textOut, ref sizeOut, textMsg, ref sizeMsg, 0, eol, initIndent))
{
ShowOutput(textMsg.ToString());
sp.ReplaceText(sd, textOut.ToString(), (int)vsEPReplaceTextOptions.vsEPReplaceTextKeepMarkers);
}
}
}
public static void ApplyPrefeence(DTE2 dte, string region, string controller, string field, string property, string preferredValue)
{
//string preferredValue = GetMostPreferredValue(region, controller, field, property);
List <PreviousPropertyValue> listDefault = new List <PreviousPropertyValue>();
foreach (ProjectItem pi in dte.Solution.Projects.Item(1).ProjectItems)
{
if (pi.ProjectItems != null)
{
foreach (ProjectItem p in pi.ProjectItems)
{
if (p.Name.EndsWith(".Designer.cs"))
{
p.Open(EnvDTE.Constants.vsViewKindCode);
p.Document.Activate();
TextSelection ts = (TextSelection)dte.ActiveDocument.Selection;
TextSelection ts2 = (TextSelection)dte.ActiveDocument.Selection;
string srchPattern1 = "new System.Windows.Forms.Button();";
EnvDTE.TextRanges textRanges = null;
ts.StartOfDocument(false);
int count = 0;
string nameLine = "";
string name = "";
string[] np = new string[50];
while (ts.FindPattern(srchPattern1, 0, ref textRanges))
{
ts.SelectLine();
nameLine = ts.Text;
count++;
string[] sp = nameLine.Split('.');
string spi = sp[1];
string[] sp2 = spi.Split('=');
name = sp2[0];
np[count] = name;
}
int i = 1;
while (ts2.FindPattern(".BackColor = System.Drawing.Color", 0, ref textRanges))
{
PreviousPropertyValue def = new PreviousPropertyValue();
ts2.SelectLine();
string codeLine = ts2.Text;
codeLine = codeLine.Trim();
foreach (string s in np)
{
string ss = s;
if (ss != null)
{
ss = ss.Trim();
if (codeLine.Contains(ss) == true)
{
ts2.ReplacePattern(codeLine, "this." + s + ".BackColor = System.Drawing.Color." + preferredValue + ";", 0, ref textRanges);
np = np.Where(w => w != s).ToArray();
def.FileName = p.Name;
def.ControllerType = controller;
def.Property = property;
def.ControllerName = ss;
def.DefaultValue = codeLine;
listDefault.Add(def);
}
//else
//{
// ts2.LineDown();
// ts2.NewLine();
// ts2.Insert("this." + np[i] + ".BackColor = System.Drawing.Color." + preferredValue + ";");
//}
//def.FileName = p.Name;
//def.ControllerType = controller;
//def.Property = property;
//def.ControllerName = ss;
//def.DefaultValue = codeLine;
//listDefault.Add(def);
}
}
//i++;
}
if (np != null)
{
foreach (string s in np)
{
if (s != null)
{
ts2.EndOfLine();
ts2.NewLine();
ts2.Insert("this." + np[i] + ".BackColor = System.Drawing.Color." + preferredValue + ";");
np = np.Where(w => w != s).ToArray();
}
}
}
SaveDefaultValues(listDefault);
dte.ActiveDocument.Save(p.Document.FullName);
dte.ActiveDocument.Close(vsSaveChanges.vsSaveChangesNo);
}
}
}
}
}
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
{
try
{
if (VsShellUtilities.IsInAutomationFunction(m_provider.ServiceProvider))
{
return(m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut));
}
// make a copy of this so we can look at it after forwarding some commands
uint commandID = nCmdID;
char typedChar = char.MinValue;
// make sure the input is a char before getting it
if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR)
{
typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn);
}
// check for the triple slash
if (typedChar == '!' && m_dte != null)
{
var currentILine = m_textView.TextSnapshot.GetLineFromPosition(
m_textView.Caret.Position.BufferPosition.Position);
int len = m_textView.Caret.Position.BufferPosition.Position - currentILine.Start.Position;
string currentLine = m_textView.TextSnapshot.GetText(currentILine.Start.Position, len);
string currentLineFull = currentILine.GetText();
if ((currentLine + typedChar).Trim() == "/*!")
{
// Calculate how many spaces
string spaces = currentLine.Replace(currentLine.TrimStart(), "");
TextSelection ts = m_dte.ActiveDocument.Selection as TextSelection;
int oldLine = ts.ActivePoint.Line;
int oldOffset = ts.ActivePoint.LineCharOffset;
if (!currentLineFull.Contains("*/"))
{
ts.Insert("*/");
}
ts.LineDown();
ts.EndOfLine();
CodeElement codeElement = null;
FileCodeModel fcm = m_dte.ActiveDocument.ProjectItem.FileCodeModel;
if (fcm != null)
{
while (codeElement == null)
{
codeElement = fcm.CodeElementFromPoint(ts.ActivePoint, vsCMElement.vsCMElementFunction);
if (codeElement == null)
{
ts.LineDown();
}
}
}
var cls = codeElement as VCCodeClass;
var cls2 = codeElement as CodeClass;
var fnc = codeElement as VCCodeFunction;
var kind = codeElement.Kind;
if (codeElement != null && codeElement is CodeFunction)
{
VCCodeFunction function = codeElement as VCCodeFunction;
StringBuilder sb = new StringBuilder("!\r\n" + spaces + " * \r\n" + spaces + " * ");
foreach (CodeElement child in codeElement.Children)
{
CodeParameter parameter = child as CodeParameter;
if (parameter != null)
{
sb.AppendFormat("\r\n" + spaces + " * \\param {0}", parameter.Name);
}
}
if (function.Type.AsString != "void")
{
sb.AppendFormat("\r\n" + spaces + " * \\return ");
}
sb.AppendFormat("\r\n" + spaces + " ");
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.Insert(sb.ToString());
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.LineDown();
ts.EndOfLine();
return(VSConstants.S_OK);
}
else if (codeElement != null && codeElement is VCCodeClass)
{
VCCodeClass function = codeElement as VCCodeClass;
StringBuilder sb = new StringBuilder("!\r\n" + spaces + " * \r\n" + spaces + " * ");
foreach (CodeElement child in function.TemplateParameters)
{
CodeParameter parameter = child as CodeParameter;
if (parameter != null)
{
sb.AppendFormat("\r\n" + spaces + " * \\tparam {0}", parameter.Name);
}
}
sb.AppendFormat("\r\n" + spaces + " ");
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.Insert(sb.ToString());
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.LineDown();
ts.EndOfLine();
return(VSConstants.S_OK);
}
else
{
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.Insert("!\r\n" + spaces + " * \r\n" + spaces + " * \r\n" + spaces + " ");
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.LineDown();
ts.EndOfLine();
return(VSConstants.S_OK);
}
}
}
if (m_session != null && !m_session.IsDismissed)
{
// check for a commit character
if (nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN ||
nCmdID == (uint)VSConstants.VSStd2KCmdID.TAB)
{
// check for a selection
// if the selection is fully selected, commit the current session
if (m_session.SelectedCompletionSet.SelectionStatus.IsSelected)
{
string selectedCompletion = m_session.SelectedCompletionSet.SelectionStatus.Completion.DisplayText;
m_session.Commit();
// also, don't add the character to the buffer
return(VSConstants.S_OK);
}
else
{
// if there is no selection, dismiss the session
m_session.Dismiss();
}
}
}
else
{
if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN)
{
string currentLine = m_textView.TextSnapshot.GetLineFromPosition(
m_textView.Caret.Position.BufferPosition.Position).GetText();
if (currentLine.TrimStart().StartsWith("*"))
{
TextSelection ts = m_dte.ActiveDocument.Selection as TextSelection;
string spaces = currentLine.Replace(currentLine.TrimStart(), "");
ts.Insert("\r\n" + spaces + "* ");
return(VSConstants.S_OK);
}
}
}
// pass along the command so the char is added to the buffer
int retVal = m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
if (typedChar == '\\')
{
string currentLine = m_textView.TextSnapshot.GetLineFromPosition(
m_textView.Caret.Position.BufferPosition.Position).GetText();
if (currentLine.TrimStart().StartsWith("*"))
{
if (m_session == null || m_session.IsDismissed) // If there is no active session, bring up completion
{
if (this.TriggerCompletion())
{
m_session.SelectedCompletionSet.SelectBestMatch();
m_session.SelectedCompletionSet.Recalculate();
return(VSConstants.S_OK);
}
}
}
}
else if (
commandID == (uint)VSConstants.VSStd2KCmdID.BACKSPACE ||
commandID == (uint)VSConstants.VSStd2KCmdID.DELETE ||
char.IsLetter(typedChar))
{
if (m_session != null && !m_session.IsDismissed) // the completion session is already active, so just filter
{
m_session.SelectedCompletionSet.SelectBestMatch();
m_session.SelectedCompletionSet.Recalculate();
return(VSConstants.S_OK);
}
}
return(retVal);
}
catch
{
}
return(VSConstants.E_FAIL);
}
/// <summary>
/// Generates a Doxygen comment block to the current caret location.
/// </summary>
private void GenerateComment()
{
var currentILine = m_textView.TextSnapshot.GetLineFromPosition(m_textView.Caret.Position.BufferPosition.Position);
int len = m_textView.Caret.Position.BufferPosition.Position - currentILine.Start.Position;
string currentLine = m_textView.TextSnapshot.GetText(currentILine.Start.Position, len);
string spaces = currentLine.Replace(currentLine.TrimStart(), "");
string next2char = m_textView.TextSnapshot.GetText(currentILine.Start.Position + len, 2);
ThreadHelper.ThrowIfNotOnUIThread();
TextSelection ts = m_dte.ActiveDocument.Selection as TextSelection;
// Save current care position.
int oldLine = ts.ActivePoint.Line;
int oldOffset = ts.ActivePoint.LineCharOffset;
// Removing the auto inserted "*/"
if (next2char == "*/")
{
ts.Delete(2);
}
// Check if we're at the beginning of the document and should generate a file comment.
if (oldLine == 1)
{
string fileComment = m_generator.GenerateFileComment(m_dte, out int selectedLine);
ts.DeleteLeft(2); // Removing the // part here.
ts.Insert(fileComment);
// Move the caret.
ts.MoveToLineAndOffset(selectedLine + 1, 1);
ts.EndOfLine();
return;
}
// Search for the associated code element for which to generate the comment.
CodeElement codeElement = null;
ts.LineDown();
ts.EndOfLine();
FileCodeModel fcm = this.GetFileCodeModel(m_dte.ActiveDocument);
if (fcm != null)
{
while (codeElement == null)
{
codeElement = CodeElementFromPoint(fcm, ts.ActivePoint,
vsCMElement.vsCMElementNamespace,
vsCMElement.vsCMElementClass,
vsCMElement.vsCMElementStruct,
vsCMElement.vsCMElementEnum,
vsCMElement.vsCMElementFunction,
vsCMElement.vsCMElementUnion);
if (ts.ActivePoint.AtEndOfDocument)
{
break;
}
if (codeElement == null)
{
ts.LineDown();
}
}
// if active line is in function body, set codeElement to null
if (codeElement is CodeFunction function && oldLine > codeElement.StartPoint.Line && oldLine < codeElement.EndPoint.Line)
{
codeElement = null;
}
}
// Generate the comment and add it to the document.
string doxyComment = m_generator.GenerateComment(spaces, codeElement, "");
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.DeleteLeft(2); // Removing the // part here.
ts.Insert(doxyComment);
if (!m_generator.UseSingleLineComment(codeElement))
{
// Move caret to the position where the main comment will be written.
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.LineDown();
ts.EndOfLine();
}
else
{
ts.MoveToLineAndOffset(oldLine, oldOffset + 2);
}
}
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
{
try
{
if (VsShellUtilities.IsInAutomationFunction(m_provider.ServiceProvider))
{
return(m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut));
}
// make a copy of this so we can look at it after forwarding some commands
uint commandID = nCmdID;
char typedChar = char.MinValue;
// make sure the input is a char before getting it
if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR)
{
typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn);
}
if (m_dte != null)
{
string currentLine = m_textView.TextSnapshot.GetLineFromPosition(
m_textView.Caret.Position.BufferPosition.Position).GetText();
// check for the Javadoc slash and two asterisk pattern while compensating for visual studio's block comment closing generation
if (typedChar == '*' && currentLine.Trim() == "/**/")
{
// Calculate how many spaces
string spaces = currentLine.Replace(currentLine.TrimStart(), "");
TextSelection ts = m_dte.ActiveDocument.Selection as TextSelection;
//Remember where the cursor was when command was triggered
int oldLine = ts.ActivePoint.Line;
int oldOffset = ts.ActivePoint.LineCharOffset;
ts.LineDown();
ts.EndOfLine();
ts.SelectLine();
//Detect and skip over Unreal Engine Function Macros
string trimmedFuncLine = ts.Text.Trim();
if (trimmedFuncLine != "" && trimmedFuncLine.StartsWith("UFUNCTION("))
{
ts.EndOfLine();
}
else
{
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.LineDown();
ts.EndOfLine();
}
CodeElement codeElement = null;
FileCodeModel fcm = m_dte.ActiveDocument.ProjectItem.FileCodeModel;
if (fcm != null)
{
codeElement = fcm.CodeElementFromPoint(ts.ActivePoint, vsCMElement.vsCMElementFunction);
}
if (codeElement != null && codeElement is CodeFunction)
{
CodeFunction function = codeElement as CodeFunction;
StringBuilder sb = new StringBuilder("*");
bool isNoArgsNoReturn = true;
foreach (CodeElement child in codeElement.Children)
{
CodeParameter parameter = child as CodeParameter;
if (parameter != null)
{
sb.AppendFormat("\r\n" + spaces + " * @param {0} ", parameter.Name);
isNoArgsNoReturn = false;
}
}
if (function.Type.AsString != "void")
{
isNoArgsNoReturn = false;
if (function.Type.AsString == "bool")
{
sb.AppendFormat("\r\n" + spaces + " * @return true \r\n" + spaces + " * @return false ");
}
else
{
sb.AppendFormat("\r\n" + spaces + " * @return ");
}
}
//If function has a return type or parameters then we generate them and return, otherwise we skip to generate a single line comment
if (!isNoArgsNoReturn)
{
sb.Insert(1, "\r\n" + spaces + " * ");
sb.AppendFormat("\r\n" + spaces + " ");
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.Insert(sb.ToString());
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.LineDown();
ts.EndOfLine();
return(VSConstants.S_OK);
}
}
//For variables and void functions with no parameters we can do a single line comment
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.Insert("* ");
ts.MoveToLineAndOffset(oldLine, oldOffset + 2);
return(VSConstants.S_OK);
}
else if (nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN)
{
//Get text on current line before and after cursor
TextSelection ts = m_dte.ActiveDocument.Selection as TextSelection;
int oldLine = ts.ActivePoint.Line;
int oldOffset = ts.ActivePoint.LineCharOffset;
ts.EndOfLine(true);
string afterCursor = ts.Text;
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstColumn, true);
string beforeCursor = ts.Text;
string beforeCursorTrimmed = beforeCursor.TrimStart();
ts.MoveToLineAndOffset(oldLine, oldOffset);
// Calculate how many spaces
string spaces = beforeCursorTrimmed == "" ? beforeCursor : beforeCursor.Replace(beforeCursorTrimmed, "");
bool hasAsteriskBeforeCursor = beforeCursorTrimmed == "" ? false : beforeCursorTrimmed.StartsWith("* ");
bool hasBlockTerminatorAfterCursor = afterCursor == "" ? false : afterCursor.EndsWith("*/");
bool hasBlockTerminatorDirectlyAfterCursor = hasBlockTerminatorAfterCursor && afterCursor.Trim() == "*/";
//Add a space to maintain correct asterisk alignment if needed
if (beforeCursorTrimmed != "" && beforeCursorTrimmed.StartsWith("/*"))
{
hasAsteriskBeforeCursor = true;
spaces += " ";
}
if (hasAsteriskBeforeCursor)
{
ts.Insert("\r\n" + spaces);
if (!hasBlockTerminatorAfterCursor)
{
ts.Insert("* ");
}
else if (hasBlockTerminatorDirectlyAfterCursor)
{
ts.Delete(afterCursor.Length);
ts.Insert("*/");
ts.MoveToLineAndOffset(ts.ActivePoint.Line, ts.ActivePoint.LineCharOffset - 2);
}
return(VSConstants.S_OK);
}
else if (hasBlockTerminatorAfterCursor)
{
ts.Insert("* \r\n" + spaces);
if (hasBlockTerminatorDirectlyAfterCursor)
{
ts.Delete(afterCursor.Length);
ts.Insert("*/");
ts.MoveToLineAndOffset(ts.ActivePoint.Line, ts.ActivePoint.LineCharOffset - 2);
}
return(VSConstants.S_OK);
}
}
}
// pass along the command so the char is added to the buffer
return(m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut));
}
catch
{
}
return(VSConstants.E_FAIL);
}
protected int ShowEventHandler(string document, string codeBehind, string codeBehindFile, string className, string objectTypeName, string eventName, string eventHandlerName)
{
var projectItem = GetProjectItem(document, codeBehind, codeBehindFile);
var binder = GetBinder(projectItem);
if (binder == null)
{
return(NativeMethods.E_FAIL);
}
projectItem.Open(EnvDTE.Constants.vsViewKindCode);
var function = binder.FindEventHandler(className, objectTypeName, eventName, eventHandlerName);
if (function != null)
{
bool prevLineIsEmpty = true;
EditPoint point = function.EndPoint.CreateEditPoint();
point.LineUp(1);
string lines = point.GetLines(point.Line, (int)(point.Line + 1));
for (int i = 0; i < lines.Length; i++)
{
if (!char.IsWhiteSpace(lines[i]))
{
prevLineIsEmpty = false;
break;
}
}
Document document2 = projectItem.Document;
if (document2 != null)
{
Window activeWindow = document2.ActiveWindow;
if (activeWindow != null)
{
TextSelection selection = activeWindow.Selection as TextSelection;
if (selection != null)
{
selection.MoveToPoint(function.EndPoint, false);
if (prevLineIsEmpty)
{
selection.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstText, false);
int virtualCharOffset = selection.AnchorPoint.VirtualCharOffset;
selection.LineUp(false, 1);
if (selection.AnchorPoint.VirtualCharOffset <= virtualCharOffset)
{
int indentSize = 4;
TextDocument document3 = document2 as TextDocument;
if (document3 != null)
{
indentSize = document3.IndentSize;
}
selection.MoveToLineAndOffset(selection.AnchorPoint.Line, (int)(virtualCharOffset + indentSize), false);
}
}
else
{
selection.LineUp(false, 1);
//selection.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstColumn, false);
selection.EndOfLine(false);
}
}
}
}
}
return(NativeMethods.S_OK);
}
