/// <summary>
/// Deletes the name space using statements.
/// </summary>
/// <param name="instance">The instance.</param>
public static void DeleteNameSpaceUsingStatements(this ProjectItem instance)
{
bool continueLoop = true;
do
{
CodeElement codeElement = instance.FileCodeModel.CodeElements.Item(1);
if (codeElement != null)
{
if (codeElement.Kind == vsCMElement.vsCMElementImportStmt)
{
EditPoint editPoint = codeElement.GetStartPoint().CreateEditPoint();
TextPoint textPoint = codeElement.GetEndPoint();
editPoint.Delete(textPoint);
//// should get rid of the blank line!
editPoint.Delete(1);
}
else
{
continueLoop = false;
}
}
else
{
continueLoop = false;
}
}while (continueLoop);
}
public override void UiBtnCommandAction(Object param)
{
if (string.IsNullOrWhiteSpace(UiCommandProppertyName))
{
return;
}
if (SelectedCodeElement == null)
{
return;
}
if (SelectedCodeElement.CodeElementRef == null)
{
return;
}
CodeClass cc = SelectedCodeElement.CodeElementRef as CodeClass;
if (SelectedViewModel != null)
{
SolutionProject prj = ComboItemsSourceProjects.Where(p => string.Equals(p.ProjectUniqueName, SelectedViewModel.RootNodeProjectName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
if (prj != null)
{
if (!string.Equals(SelectedProject.ProjectUniqueName, prj.ProjectUniqueName, StringComparison.OrdinalIgnoreCase))
{
if (SelectedProject.ProjectRef.Object is VSProject)
{
(SelectedProject.ProjectRef.Object as VSProject).References.AddProject(prj.ProjectRef);
SelectedProject.ProjectRef.Save();
}
}
}
}
//cc.AddProperty(UiCommandProppertyName , UiCommandProppertyName, "System.Data.Entity.DbSet<" + SelectedViewModelRootClass + ">", -1, vsCMAccess.vsCMAccessPublic, null);
CodeProperty codeProperty =
cc.AddProperty(UiCommandProppertyName, UiCommandProppertyName, "DbSet<" + SelectedViewModelRootClass + ">", -1, vsCMAccess.vsCMAccessPublic, null);
EditPoint editPoint = codeProperty.Getter.StartPoint.CreateEditPoint();
editPoint.Delete(codeProperty.Getter.EndPoint);
editPoint.Insert("get ;");
editPoint = codeProperty.Setter.StartPoint.CreateEditPoint();
editPoint.Delete(codeProperty.Setter.EndPoint);
editPoint.Insert("set ;");
if (cc.ProjectItem != null)
{
if (cc.ProjectItem.IsDirty)
{
cc.ProjectItem.Save();
}
}
DoAnaliseDbContext();
}
private static async Task RemoveCommentsAsync(EditPoint objEditPt)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var template = GetTemplate();
int index = 0;
while (index < template.Count)
{
var line = string.Empty;
if (!objEditPt.AtEndOfDocument)
{
line = objEditPt.GetText(objEditPt.LineLength);
}
if (string.Equals(line, template[index]))
{
var newPoint = objEditPt.CreateEditPoint();
newPoint.LineDown();
if (!newPoint.AtEndOfDocument)
{
newPoint.StartOfLine();
}
objEditPt.Delete(newPoint);
index++;
}
else
{
break;
}
}
}
private void codeTemplateCmdEvent_Click(object CommandBarControl, ref bool Handled, ref bool CancelDefault)
{
CommandBarControl ctrl = CommandBarControl as CommandBarControl;
string content = CodeTemplateManager.Instance.GetTemplateContent(ctrl.Caption);
int indexOfSelectedParam = CodeTemplateManager.Instance.IndexOfSelectedParam(content);
bool surroundSelectedText = (indexOfSelectedParam >= 0);
TextSelection selected = _applicationObject.ActiveDocument.Selection as TextSelection;
EditPoint topPoint = selected.TopPoint.CreateEditPoint();
EditPoint bottomPoint = selected.BottomPoint.CreateEditPoint();
if (surroundSelectedText)
{
string beforeSelectedParam =
CodeTemplateManager.Instance.GetTextBeforeSelectedParam(content);
string afterSelectedParam =
CodeTemplateManager.Instance.GetTextAfterSelectedParam(content);
topPoint.LineUp(1);
topPoint.EndOfLine();
topPoint.Insert(Environment.NewLine);
topPoint.Insert(beforeSelectedParam);
bottomPoint.EndOfLine();
bottomPoint.Insert(Environment.NewLine);
bottomPoint.Insert(afterSelectedParam);
}
else
{
topPoint.Delete(bottomPoint);
topPoint.Insert(content);
}
}
/// <summary>
/// Adds the property.
/// </summary>
/// <param name="codeClass">The code class.</param>
/// <param name="var">The var.</param>
/// <returns></returns>
public static CodeProperty AddProperty(CodeClass codeClass, CodeVariable var)
{
CodeProperty prop = null;
try
{
prop = codeClass.AddProperty(
FormatPropertyName(var.Name),
FormatPropertyName(var.Name),
var.Type.AsFullName, -1,
vsCMAccess.vsCMAccessPublic, null);
EditPoint editPoint = prop.Getter.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint();
//Delete return default(int); added by codeClass.AddProperty
editPoint.Delete(editPoint.LineLength);
editPoint.Indent(null, 4);
editPoint.Insert(string.Format(CultureInfo.InvariantCulture, "return {0};", var.Name));
editPoint = prop.Setter.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint();
editPoint.Indent(null, 1);
editPoint.Insert(string.Format(CultureInfo.InvariantCulture, "{0} = value;", var.Name));
editPoint.SmartFormat(editPoint);
return(prop);
}
catch
{
//Property already exists
return(null);
}
}
public void SetContent(string content)
{
EditPoint start = _document.CreateEditPoint(_document.StartPoint);
start.Delete(_document.EndPoint);
start.Insert(content);
}
/// <summary>
/// Performs the style task.
/// </summary>
/// <param name="projectItem">The project Item</param>
/// <param name="ideWindow">The IDE window.</param>
protected override void DoWork(ProjectItem projectItem, EnvDTE.Window ideWindow)
{
if (projectItem.Name.EndsWith(".cs") && !projectItem.Name.EndsWith("Designer.cs"))
{
Debug.WriteLine("Moving Usings on: " + projectItem.Name);
TextDocument objTextDoc = (TextDocument)ideWindow.Document.Object("TextDocument");
EditPoint startPoint = objTextDoc.StartPoint.CreateEditPoint();
string backupText = startPoint.GetText(objTextDoc.EndPoint);
try
{
List <EditPoint> namespaceInsertionPoints = GetInsertionPoints(projectItem.FileCodeModel);
if (namespaceInsertionPoints != null && namespaceInsertionPoints.Count > 0)
{
MoveUsingStatements(projectItem.FileCodeModel, namespaceInsertionPoints);
}
}
catch (Exception exc)
{
Debug.WriteLine(exc.ToString());
Debug.WriteLine("Attempting to Revert...");
startPoint.Delete(objTextDoc.EndPoint);
startPoint.Insert(backupText);
Debug.WriteLine("Reverted.");
}
}
}
public sealed override void Undo()
{
EditPoint ep = _codeMethod.StartPoint.CreateEditPoint();
ep.LineDown(1);
ep.Delete(_codeMethod.EndPoint);
ep.Insert("{\r\n}");
}
/// <summary>
/// Removes the specified range of text.
/// </summary>
/// <param name="start">Index of removal.</param>
/// <param name="count">Count of chars to remove.</param>
public void RemoveRange(int start, int count)
{
EditPoint ep = Document.CreateEditPoint(new LuaTextPoint(Document, 1, start + 1));
for (int i = 0; i < count; i++)
{
ep.Delete(ep.LineLength + 1);
}
}
/// <summary>
/// add a default constructor.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="moveToCorrectPosition">if set to <c>true</c> [move to correct position].</param>
/// <returns>The constructor.</returns>
public static CodeFunction AddDefaultConstructor(
this CodeClass instance,
bool moveToCorrectPosition)
{
TraceService.WriteLine("CodeClassExtensions::AddDefaultConstructor file=" + instance.Name);
CodeFunction codeFunction = instance.AddFunction(
instance.Name,
vsCMFunction.vsCMFunctionConstructor,
vsCMTypeRef.vsCMTypeRefVoid,
0,
vsCMAccess.vsCMAccessPublic,
null);
codeFunction.GetEndPoint().CreateEditPoint().InsertNewLine();
string comment = "<doc><summary>\r\nInitializes a new instance of the " + instance.Name + " class.\r\n</summary></doc>\r\n";
codeFunction.DocComment = comment;
if (moveToCorrectPosition)
{
TraceService.WriteLine("Move to correct position");
IEnumerable <CodeVariable> variables = instance.GetVariables();
CodeVariable lastVariable = variables.LastOrDefault();
if (lastVariable != null)
{
EditPoint startPoint = codeFunction.StartPoint.CreateEditPoint();
EditPoint endPoint = codeFunction.EndPoint.CreateEditPoint();
string text = startPoint.GetText(endPoint);
//// remove current code Function text
instance.RemoveMember(codeFunction);
if (endPoint.GetText(1) == Environment.NewLine)
{
TraceService.WriteLine("Delete line");
endPoint.Delete(1);
}
EditPoint editPoint = lastVariable.EndPoint.CreateEditPoint();
editPoint.Insert(string.Format("{0}{1}{2}", Environment.NewLine, Environment.NewLine, text));
//// we need to re find the function as we have deleted this one!
codeFunction = instance.GetFunction(instance.Name);
codeFunction.DocComment = comment;
}
}
return(codeFunction);
}
/// <summary>
/// 删除指定位置的文字，从(0,0)开始
/// </summary>
/// <param name="startLine"></param>
/// <param name="startCol"></param>
/// <param name="endLine"></param>
/// <param name="endCol"></param>
public void DeleteText(int startLine, int startCol, int endLine, int endCol)
{
EditPoint editPoint = GetEditPoint(startLine, startCol);
if (editPoint != null)
{
object tp;
TextLines.CreateTextPoint(endLine, endCol, out tp);
editPoint.Delete(tp as TextPoint);
}
}
private void InsertGeneratedCode(ProjectItem projectItem, string generatedContent)
{
projectItem.Open(Constants.vsViewKindCode);
projectItem.Document.ActiveWindow.Activate();
TextDocument textDocument = (TextDocument)projectItem.Document.Object("TextDocument");
EditPoint editPoint = textDocument.StartPoint.CreateEditPoint();
editPoint.Delete(textDocument.EndPoint);
editPoint.Insert(generatedContent);
projectItem.Save(Helper.GetFilePath(projectItem));
}
private void EditMigrations(CodeType migration, string updateMethod)
{
var cc = migration as CodeClass;
// get functions
var members = cc.Members;
// list of ints
List <int> migrations = new List <int>();
// iterate through functions
foreach (CodeElement member in members)
{
var func = member as CodeFunction;
if (func == null)
{
continue;
}
// TODO: investigate use of CodeFunction
var createIndex = member.Name == "Create";
if (createIndex)
{
migrations.Add(0);
continue;
}
var index = member.Name.IndexOf("UpdateFrom");
if (index == -1)
{
continue;
}
migrations.Add(Int32.Parse(member.Name.Last().ToString()));
}
// sort numbers, just in case
migrations.Sort();
// get new update number
var update = migrations.Count == 0 ? 0 : migrations.Last() + 1;
// create method, either update or create
var methodName = update == 0 ? "Create" : "UpdateFrom" + update;
CodeFunction cf = cc.AddFunction(methodName, vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefInt, -1, vsCMAccess.vsCMAccessPublic);
// access new method
TextPoint tp = cf.GetStartPoint(vsCMPart.vsCMPartBody);
TextPoint end = cf.GetEndPoint(vsCMPart.vsCMPartBody);
EditPoint ep = tp.CreateEditPoint();
// delete auto generated code
ep.Delete(end);
var returnVal = update + 1;
ep.Insert(updateMethod + Environment.NewLine + Environment.NewLine + "return " + returnVal + ";");
tp.CreateEditPoint().SmartFormat(ep);
}
private static void MakeAutoProperty(CodeProperty2 newProp)
{
EditPoint setter = newProp.Setter.StartPoint.CreateEditPoint();
setter.Delete(newProp.Setter.EndPoint);
setter.Insert("set;");
EditPoint getter = newProp.Getter.StartPoint.CreateEditPoint();
getter.Delete(newProp.Getter.EndPoint);
getter.Insert("get;");
}
/// <summary>
/// Replaces the code.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="newCode">The new code.</param>
public static void ReplaceCode(
this CodeFunction instance,
string newCode)
{
TraceService.WriteLine("CodeFunctionExtensions::ReplaceCode codeFunction=" + instance.Name);
EditPoint startPoint = instance.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint();
EditPoint endPoint = instance.GetEndPoint(vsCMPart.vsCMPartBody).CreateEditPoint();
startPoint.Delete(endPoint);
startPoint.Insert(newCode);
}
/***************************************************************************
* exec */
/**
* Retrieves the selected block of text and replaces it with the result of a
* call to <c>convertBlock</c>.
*
* @param sender Command object.
***************************************************************************/
public override void exec(object sender, EventArgs e)
{
/*----------------------------------------*/
/* Get the document and selection. Indent */
/* offset is current caret position. */
/*----------------------------------------*/
Document doc = app.ActiveDocument;
TextSelection select = (TextSelection)doc.Selection;
VirtualPoint top = select.TopPoint;
VirtualPoint bottom = select.BottomPoint;
int indent = select.CurrentColumn - 1;
/*--------------------------------------------*/
/* Set edit points at the start and end of */
/* the lines where selection starts and ends. */
/*--------------------------------------------*/
EditPoint ep1 = top.CreateEditPoint();
EditPoint ep2 = bottom.CreateEditPoint();
ep1.MoveToLineAndOffset(top.Line, 1);
ep2.MoveToLineAndOffset(bottom.Line, bottom.LineLength + 1);
/*---------------------------------------*/
/* Convert the block from the content of */
/* the start and end line of selection. */
/*---------------------------------------*/
string block = convertBlock(ep1.GetText(ep2), indent);
if (block != null)
{
/*------------------------------------*/
/* Open an undo context if none open. */
/*------------------------------------*/
UndoContext undo = app.UndoContext;
if (!undo.IsOpen)
{
undo.Open(GetType().Name, false);
}
/*----------------------------------------------------------*/
/* Replace the selected block, move the caret to the indent */
/* position on the last line, and close the Undo Context. */
/*----------------------------------------------------------*/
ep1.Delete(ep2);
ep1.Insert(block);
select.MoveToLineAndOffset(ep1.Line, indent + 1, false);
undo.Close();
}
}
public void PasteCode(EditPoint objEditPt, string code, PasteOptions pasteOption)
{
switch (pasteOption)
{
case PasteOptions.Overwrite:
objEditPt.Delete(code.Length);
break;
case PasteOptions.Append:
objEditPt.EndOfDocument();
break;
}
objEditPt.Insert(code);
}
/// <summary>
/// Delete the file contents.
/// </summary>
/// <param name="instance">The instance.</param>
public static void DeleteFileContents(this ProjectItem instance)
{
TraceService.WriteLine("ProjectItemExtensions::DeleteFileContents");
Document document = instance.Document;
TextDocument textDoc = (TextDocument)document.Object("TextDocument");
EditPoint editPoint = textDoc.StartPoint.CreateEditPoint();
EditPoint endPoint = textDoc.EndPoint.CreateEditPoint();
editPoint.Delete(endPoint);
}
public static void AddStatementsToFunctionBody(this CodeFunction codeFunction, string statements, string className, bool insertAtEnd)
{
if (string.IsNullOrEmpty(className) || string.IsNullOrEmpty(statements) || (codeFunction == null))
{
return;
}
EditPoint editPoint = codeFunction.StartPoint.CreateEditPoint();
string buff = editPoint.GetText(codeFunction.EndPoint);
SyntaxTree tree = CSharpSyntaxTree.ParseText(buff);
SyntaxNode root = tree.GetRoot();
if (root == null)
{
return;
}
MethodDeclarationSyntax methodDeclaration =
root.GetOnModelCreatingParameterName("DbModelBuilder", "ModelBuilder", out string parameterName);
if ((methodDeclaration == null) || string.IsNullOrEmpty(parameterName))
{
return;
}
if (methodDeclaration.Body == null)
{
return;
}
string strToInsert = //Environment.NewLine +
parameterName + ".Entity<" + className + ">()" + statements;
if (insertAtEnd)
{
buff = buff.Insert(methodDeclaration.Body.Span.End - 1, strToInsert);
}
else
{
buff = buff.Insert(methodDeclaration.Body.Span.Start + 1, strToInsert);
}
editPoint = codeFunction.StartPoint.CreateEditPoint();
editPoint.Delete(codeFunction.EndPoint);
editPoint.Insert(buff);
if (codeFunction.ProjectItem != null)
{
codeFunction.ProjectItem.Save();
}
}
public void ApplyComposer(TextDocument document, ComposerStrings composer)
{
/* get document bounds */
EditPoint startEdit = document.CreateEditPoint(document.StartPoint);
EditPoint endEdit = document.EndPoint.CreateEditPoint();
/* run composer */
string text = startEdit.GetText(document.EndPoint);
composer.Compose(text);
if (composer.EnumModels != null && composer.EnumModels.Count > 0)
{
/* get new file*/
text = composer.GetResultFile();
/* delete and re-insert full document */
startEdit.Delete(endEdit);
startEdit.Insert(text);
}
}
protected void AddOneLineImpl(string NewLine, CodeFunction Target, bool ReplaceExisingLine)
{
//Target.GetEndPoint(EnvDTE.vsCMPart.vsCMPartBody);
EditPoint startOfLastLine = Target.GetEndPoint(EnvDTE.vsCMPart.vsCMPartBodyWithDelimiter).CreateEditPoint();
startOfLastLine.LineUp(1);
startOfLastLine.StartOfLine();
EditPoint endOfLastLine = Target.GetEndPoint(EnvDTE.vsCMPart.vsCMPartBodyWithDelimiter).CreateEditPoint();
endOfLastLine.LineUp(1);
endOfLastLine.EndOfLine();
if (ReplaceExisingLine)
{
startOfLastLine.Delete(endOfLastLine);
}
else
{
startOfLastLine.EndOfLine();
}
startOfLastLine.Insert(NewLine);
}
/// <summary>
/// Moves using statements to a given set of insertion points.
/// </summary>
/// <param name="fileCodeModel">The code model to search.</param>
/// <param name="insertionPoints">The insertion points to use.</param>
private void MoveUsingStatements(FileCodeModel fileCodeModel, List <EditPoint> insertionPoints)
{
List <string> usingStatements = new List <string>();
for (int i = 1; i <= fileCodeModel.CodeElements.Count; i++)
{
CodeElement element = fileCodeModel.CodeElements.Item(i);
if (element.Kind == vsCMElement.vsCMElementImportStmt)
{
EditPoint usingStart = element.StartPoint.CreateEditPoint();
string statement = usingStart.GetText(element.EndPoint);
usingStatements.Add(statement);
usingStart.Delete(element.EndPoint);
usingStart.DeleteWhitespace(vsWhitespaceOptions.vsWhitespaceOptionsVertical);
i--;
}
}
for (int i = 0; i < insertionPoints.Count; i++)
{
EditPoint origin = insertionPoints[i].CreateEditPoint();
if (usingStatements.Count > 0)
{
origin.Insert("\r\n");
for (int j = 0; j < usingStatements.Count; j++)
{
origin.Insert(usingStatements[j] + "\r\n");
}
}
origin.DeleteWhitespace(vsWhitespaceOptions.vsWhitespaceOptionsVertical);
if (usingStatements.Count > 0)
{
origin.Insert("\r\n");
}
}
}
private void DoExpand(TextSelection selection)
{
if (_delegateStart == null)
{
return;
}
var point = selection.BottomPoint.CreateEditPoint();
point.EndOfLine();
var point2 = selection.BottomPoint.CreateEditPoint();
string line = point2.GetText(point);
if (line.Trim() == "throw new NotImplementedException();")
{
var delPoint = _delegateStart.CreateEditPoint();
delPoint.GetText(-1);
delPoint.WordLeft(3);
delPoint.Delete(_delegateStart);
_delegateStart.WordRight();
_delegateStart.Delete(1);
}
_delegateStart = null;
}
protected bool AddSynchWrapperMember(CodeClass synch, CodeFunction cf)
{
if (cf != null && (cf.FunctionKind & FunctionsThatCantBeAnnotatedAsVirtual) == 0 &&
cf.CanOverride == true && cf.IsShared == false)
{
//add prototype and parameters
CodeFunction synchFunction = synch.AddFunction(cf.Name, cf.FunctionKind, cf.Type, -1, cf.Access, null);
foreach (CodeParameter param in cf.Parameters)
{
synchFunction.AddParameter(param.Name, param.Type, -1);
}
synchFunction.CanOverride = true;
EditPoint replaceVirtual = synchFunction.StartPoint.CreateEditPoint();
TextRanges tr = null;
replaceVirtual.ReplacePattern(synchFunction.EndPoint, "virtual", "override",
(int)EnvDTE.vsFindOptions.vsFindOptionsMatchWholeWord, ref tr);
//remove default return
EditPoint editPt = synchFunction.EndPoint.CreateEditPoint();
editPt.LineUp(1);
editPt.StartOfLine();
string returnType = cf.Type.AsString;
if (returnType != "void")
{
EditPoint startOfLastLine = synchFunction.EndPoint.CreateEditPoint();
startOfLastLine.LineUp(1);
startOfLastLine.EndOfLine();
editPt.Delete(startOfLastLine);
}
//generate method body
System.Text.StringBuilder methodBody = new System.Text.StringBuilder(100);
if (returnType != "void")
{
methodBody.Append(cf.Type.AsString + " ret;\n");
}
methodBody.Append(
"System.Threading.Monitor.Enter(_root);" +
"\ntry{");
if (returnType != "void")
{
methodBody.Append("\nret = _parent." + cf.Name + "(");
}
else
{
methodBody.Append("\n_parent." + cf.Name + "(");
}
bool first = true;
foreach (CodeParameter p in cf.Parameters)
{
if (!first)
{
methodBody.Append(", ");
}
first = false;
int typeSpaceLocation = p.Type.AsString.IndexOf(' ');
if (typeSpaceLocation != -1) //append out or ref to parameter
{
methodBody.Append(p.Type.AsString.Substring(0, typeSpaceLocation + 1));
}
methodBody.Append(p.Name);
}
methodBody.Append(");");
methodBody.Append(
"\n}" +
"\nfinally{System.Threading.Monitor.Exit(_root);}");
if (returnType != "void")
{
methodBody.Append("\nreturn ret;");
}
//add new body to method
editPt.Insert(methodBody.ToString());
editPt.MoveToPoint(synchFunction.StartPoint);
editPt.SmartFormat(synchFunction.EndPoint);
}
return(true);
}
public static bool DeleteCodeSite(this CodeFunction value, bool bDelete = true)
{
if (bDelete && !value.ExistsCodeSite())
{
return(true);
}
EditPoint epStart = value.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint();
EditPoint epEnd = value.GetEndPoint(vsCMPart.vsCMPartBody).CreateEditPoint();
EditPoint epFind = null, epFindStart = null;
bool Find(string text, bool start)
{
string[] textSplit;
if (start)
{
epFind = epStart.CreateEditPoint();
textSplit = text.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
}
else
{
epFind = epEnd.CreateEditPoint();
textSplit = text.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).Reverse().ToArray();
}
int iLine = 0;
foreach (var item in textSplit)
{
int i = item.IndexOfAny(new char[] { '(', ' ' });
string s = i == -1 ? item : item.Substring(0, i + 1);
if ((start ? epFind.FindPattern(s) : epFind.FindPattern(s, (int)vsFindOptions.vsFindOptionsBackwards)) &&
(start ? epFind.LessThan(epEnd) : epFind.GreaterThan(epStart)) &&
(iLine == 0 || iLine == epFind.Line - (start ? 1 : -1)))
{
if (iLine == 0)
{
epFindStart = epFind.CreateEditPoint();
}
iLine = epFind.Line;
if (start)
{
epFind.EndOfLine();
}
}
else
{
return(false);
}
}
return(true);
}
void Delete()
{
if (epFind.GreaterThan(epFindStart))
{
epFind.LineDown(1);
}
else
{
epFindStart.LineDown(1);
}
epFind.StartOfLine();
epFindStart.StartOfLine();
epFindStart.Delete(epFind);
}
if (!Find(value.CSEnterText(), true))
{
return(false);
}
else if (bDelete)
{
Delete();
}
if (!Find(value.CSExitText(), false))
{
return(false);
}
else if (bDelete)
{
Delete();
}
else
{
return(true);
}
if (Find(value.CSCatchText(), false) && bDelete)
{
Delete();
}
//格式化指定范围内的文本
value.StartPoint.CreateEditPoint().SmartFormat(value.EndPoint);
return(true);
}
public static void DoRemoveInvocationWithFilter(this CodeFunction codeFunction, string[] classNames, List <FluentAPIEntityNode> filter)
{
if (classNames == null)
{
return;
}
if (codeFunction == null)
{
return;
}
EditPoint editPoint = codeFunction.StartPoint.CreateEditPoint();
editPoint.SmartFormat(codeFunction.EndPoint);
editPoint = codeFunction.StartPoint.CreateEditPoint();
string buff = editPoint.GetText(codeFunction.EndPoint);
SyntaxTree tree = CSharpSyntaxTree.ParseText(buff);
SyntaxNode root = tree.GetRoot();
if (root == null)
{
return;
}
MethodDeclarationSyntax methodDeclaration =
root.GetOnModelCreatingParameterName("DbModelBuilder", "ModelBuilder", out string parameterName);
if ((methodDeclaration == null) || string.IsNullOrEmpty(parameterName))
{
return;
}
if (methodDeclaration.Body == null)
{
return;
}
List <TextSpan> spans = new List <TextSpan>();
foreach (StatementSyntax ss in methodDeclaration.Body.Statements)
{
if (ss.Kind() != SyntaxKind.ExpressionStatement)
{
continue;
}
ExpressionStatementSyntax expressionStatementSyntax = ss as ExpressionStatementSyntax;
if (expressionStatementSyntax.Expression == null)
{
continue;
}
if (expressionStatementSyntax.Expression.Kind() != SyntaxKind.InvocationExpression)
{
continue;
}
InvocationExpressionSyntax invocationExpressionSyntax = expressionStatementSyntax.Expression as InvocationExpressionSyntax;
if (!parameterName.Equals(invocationExpressionSyntax.InvocationExpressionRootName(classNames)))
{
continue;
}
FluentAPIEntityNode faen = expressionStatementSyntax.Expression.InvocationExpressionMethods(null);
if (faen == null)
{
continue;
}
if (faen.Methods == null)
{
continue;
}
if (faen.IsSatisfiedTheFilter(filter))
{
spans.Insert(0, expressionStatementSyntax.Span);
}
}
foreach (TextSpan ts in spans)
{
buff = buff.Remove(ts.Start, ts.Length);
//
// the commented code does not work : ts.Start does not correctly point to begining of the operator
//editPoint.CharRight(ts.Start);
//editPoint.Delete(ts.Length);
//editPoint.CharLeft(ts.Start);
//if (codeFunction.ProjectItem != null)
//{
// codeFunction.ProjectItem.Save();
//}
}
buff = buff.Replace(Environment.NewLine + Environment.NewLine, Environment.NewLine);
editPoint = codeFunction.StartPoint.CreateEditPoint();
editPoint.Delete(codeFunction.EndPoint);
editPoint.Insert(buff);
if (codeFunction.ProjectItem != null)
{
codeFunction.ProjectItem.Save();
}
}
private void EditMigrations(Dictionary <string, string> properties)
{
// Edit migrations
var migration = _viewModel.SelectedMigration.CodeType;
var cc = migration as CodeClass;
// get functions
var members = cc.Members;
// list of ints
List <int> migrations = new List <int>();
// iterate through functions
foreach (CodeElement member in members)
{
var func = member as CodeFunction;
if (func == null)
{
continue;
}
// TODO: investigate use of CodeFunction
var createIndex = member.Name == "Create";
if (createIndex)
{
migrations.Add(0);
continue;
}
var index = member.Name.IndexOf("UpdateFrom");
if (index == -1)
{
continue;
}
migrations.Add(Int32.Parse(member.Name.Last().ToString()));
}
// sort numbers, just in case
migrations.Sort();
// get new update number
var update = migrations.Count == 0 ? 0 : migrations.Last() + 1;
// create method, either update or create
var methodName = update == 0 ? "Create" : "UpdateFrom" + update;
CodeFunction cf = cc.AddFunction(methodName, vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefInt, -1, vsCMAccess.vsCMAccessPublic);
// access new method
TextPoint tp = cf.GetStartPoint(vsCMPart.vsCMPartBody);
TextPoint end = cf.GetEndPoint(vsCMPart.vsCMPartBody);
EditPoint ep = tp.CreateEditPoint();
// delete auto generated code
ep.Delete(end);
var partName = _viewModel.PartName.Trim();
// add part bits and bobs
if (_viewModel.Attachable)
{
ep.Insert(String.Format(@"ContentDefinitionManager.AlterPartDefinition(""{0}"", builder => builder", partName) + Environment.NewLine);
// make attachable
ep.Insert(".Attachable()");
// add description
if (!String.IsNullOrEmpty(_viewModel.HelpText))
{
ep.Insert(Environment.NewLine + @".WithDescription(""" + _viewModel.HelpText + @""")");
}
ep.Insert(");" + Environment.NewLine + Environment.NewLine);
}
// add record migration
if (_viewModel.Storage.Contains("Record Storage"))
{
ep.Insert(String.Format(@"SchemaBuilder.CreateTable(""{0}Record"", table => table", partName) +
Environment.NewLine +
".ContentPartRecord()");
foreach (var prop in properties)
{
ep.Insert(Environment.NewLine + ".Column<" + prop.Value + @">(""" + prop.Key + @""")");
}
ep.Insert(");" + Environment.NewLine + Environment.NewLine);
}
// create widget
if (_viewModel.CreateWidget)
{
ep.Insert(String.Format(@"ContentDefinitionManager.AlterTypeDefinition(""{0}"", widget => widget", (_viewModel.WidgetName ?? partName + "Widget").Trim()) +
Environment.NewLine +
@".WithPart(""CommonPart"")" +
Environment.NewLine +
@".WithPart(""WidgetPart"")" +
Environment.NewLine +
@".WithPart(""" + partName + @""")" +
Environment.NewLine +
@".WithSetting(""Stereotype"", ""Widget"")"
);
ep.Insert(");" + Environment.NewLine + Environment.NewLine);
}
var returnVal = update + 1;
ep.Insert(string.Format("return {0};", returnVal));
// format document
tp.CreateEditPoint().SmartFormat(ep);
}
/// <summary>
/// Help method to modify KeyinCommands.cs or KeyinCommands.vb.
/// </summary>
/// <param name="projectItem"></param>
/// <param name="keyinCommandFunctionCS"></param>
/// <param name="keyinCommandFunctionvb"></param>
private void ModifyKeyinsCommands(ProjectItem projectItem,
string keyinCommandFunctionCS,
string keyinCommandFunctionvb,
string keyinCommandFunctionCPP)
{
Document activeDoc = projectItem.Document;
if (activeDoc == null)
{
return;
}
ProjectItem activeDocumentProjectItem = activeDoc.ProjectItem;
if (activeDocumentProjectItem == null)
{
return;
}
FileCodeModel fileCodeModel = activeDocumentProjectItem.FileCodeModel;
if (fileCodeModel == null)
{
return;
}
CodeElements codeElements = fileCodeModel.CodeElements;
CodeClass codeClass = null;
// look for the namespace in the active document
CodeNamespace codeNamespace = null;
foreach (CodeElement codeElement in codeElements)
{
if (codeElement.Kind == vsCMElement.vsCMElementNamespace)
{
codeNamespace = codeElement as CodeNamespace;
break;
}
}
if (codeNamespace == null)
{
if (IsVBProject)
{
codeElements = fileCodeModel.CodeElements;
}
else
{
return;
}
}
else
{
codeElements = codeNamespace.Members;
}
if (codeElements == null)
{
return;
}
// look for the first class
foreach (CodeElement codeElement in codeElements)
{
if (codeElement.Kind == vsCMElement.vsCMElementClass)
{
codeClass = codeElement as CodeClass;
break;
}
}
if (codeClass == null)
{
return;
}
if (IsCSProject)
{
CodeFunction codeFunction = codeClass.AddFunction(FunctionName + "Keyin", vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefVoid, -1, vsCMAccess.vsCMAccessPublic);
codeFunction.AddParameter("unparsed", vsCMTypeRef.vsCMTypeRefString, -1);
TextPoint textPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartBody);
EditPoint editPoint = textPoint.CreateEditPoint();
EditPoint objMovePt = textPoint.CreateEditPoint();
EditPoint UtilEditPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartHeader).CreateEditPoint();
UtilEditPoint.ReplaceText(6, "public static", 0);
editPoint.Insert
(
keyinCommandFunctionCS
);
editPoint.StartOfDocument();
objMovePt.EndOfDocument();
editPoint.SmartFormat(objMovePt);
}
else if (IsVBProject)
{
CodeFunction codeFunction = codeClass.AddFunction(FunctionName + "Keyin", vsCMFunction.vsCMFunctionSub, vsCMTypeRef.vsCMTypeRefVoid, -1, vsCMAccess.vsCMAccessPublic);
codeFunction.AddParameter("unparsed", vsCMTypeRef.vsCMTypeRefString, -1);
TextPoint textPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartBody);
EditPoint editPoint = textPoint.CreateEditPoint();
EditPoint objMovePt = textPoint.CreateEditPoint();
EditPoint UtilEditPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartHeader).CreateEditPoint();
UtilEditPoint.ReplaceText(6, "Public Shared", 0);
editPoint.Insert
(
keyinCommandFunctionvb
);
editPoint.StartOfDocument();
objMovePt.EndOfDocument();
editPoint.SmartFormat(objMovePt);
}
else if (IsVCProject)
{
TextDocument editDoc = (TextDocument)activeDoc.Object("TextDocument");
EditPoint objEditPt = editDoc.CreateEditPoint();
EditPoint objMovePt = editDoc.EndPoint.CreateEditPoint();
objEditPt.StartOfDocument();
activeDoc.ReadOnly = false;
if (objEditPt.FindPattern("#include"))
{
objEditPt.LineDown(1);
objEditPt.Insert("#include \"" + FunctionName + ".h\"\n");
}
else if ((objEditPt.FindPattern("#using")))
{
objEditPt.LineUp(1);
objEditPt.Insert("#include \"" + FunctionName + ".h\"\n");
}
else
{
objEditPt.FindPattern("namespace");
objEditPt.LineUp(1);
objEditPt.Insert("#include \"" + FunctionName + ".h\"\n");
}
CodeFunction codeFunction = codeClass.AddFunction(FunctionName + "Keyin", vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefVoid, -1, vsCMAccess.vsCMAccessPublic);
codeFunction.AddParameter("unparsed", "System::String^", -1);
TextPoint textPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartBody);
EditPoint editPoint = textPoint.CreateEditPoint();
objMovePt = textPoint.CreateEditPoint();
EditPoint UtilEditPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartHeader).CreateEditPoint();
UtilEditPoint.ReplaceText(4, "public:static", 0);
editPoint.Insert(keyinCommandFunctionCPP);
if (objEditPt.FindPattern("throw gcnew System::NotImplementedException();"))
{
editPoint.Delete(52);
}
editPoint.StartOfDocument();
objMovePt.EndOfDocument();
editPoint.SmartFormat(objMovePt);
}
}
/// <summary>
/// Performs the style task.
/// </summary>
/// <param name="projectItem">The project Item</param>
/// <param name="ideWindow">The IDE window.</param>
protected override void DoWork(ProjectItem projectItem, EnvDTE.Window ideWindow)
{
if (projectItem.Name.EndsWith(".cs"))
{
Debug.WriteLine("Formatting Spacing Around Comments: " + projectItem.Name);
try
{
TextDocument objTextDoc = (TextDocument)ideWindow.Document.Object("TextDocument");
EditPoint objEditPoint = objTextDoc.CreateEditPoint(objTextDoc.StartPoint);
EditPoint commentPoint = objEditPoint.CreateEditPoint();
TextRanges trs = null;
while (objEditPoint.FindPattern("//", (int)vsFindOptions.vsFindOptionsMatchCase, ref commentPoint, ref trs))
{
bool previousBlank = false;
bool isNotInline = true;
EditPoint beginningLineEditPoint = objEditPoint.CreateEditPoint();
beginningLineEditPoint.StartOfLine();
if (beginningLineEditPoint.GetText(objEditPoint).Trim() != string.Empty)
{
isNotInline = false;
}
if (isNotInline)
{
EditPoint previousCheckPoint = objEditPoint.CreateEditPoint();
previousCheckPoint.LineUp(1);
if (previousCheckPoint.GetText(objEditPoint).Trim() == string.Empty)
{
previousBlank = true;
}
commentPoint.CharRight(1);
string comment = objEditPoint.GetText(commentPoint);
while (!comment.EndsWith(" ") && !commentPoint.AtEndOfLine)
{
if (comment.EndsWith("/"))
{
commentPoint.CharRight(1);
}
else
{
commentPoint.CharLeft(1);
commentPoint.Insert(" ");
}
comment = objEditPoint.GetText(commentPoint);
}
commentPoint.CharRight(1);
comment = objEditPoint.GetText(commentPoint);
if (comment.EndsWith(" "))
{
commentPoint.CharLeft(1);
commentPoint.DeleteWhitespace(vsWhitespaceOptions.vsWhitespaceOptionsHorizontal);
commentPoint.Insert(" ");
}
if (commentPoint.Line > objEditPoint.Line)
{
commentPoint.LineUp(1);
commentPoint.EndOfLine();
}
if (commentPoint.AtEndOfLine)
{
objEditPoint.Delete(commentPoint);
}
else
{
EditPoint endComment = commentPoint.CreateEditPoint();
endComment.EndOfLine();
if (commentPoint.GetText(endComment).Trim() == string.Empty)
{
objEditPoint.Delete(endComment);
}
else
{
objEditPoint.LineDown(1);
previousBlank = false;
}
}
objEditPoint.StartOfLine();
commentPoint = objEditPoint.CreateEditPoint();
commentPoint.EndOfLine();
if (objEditPoint.GetText(commentPoint).Trim() == string.Empty)
{
objEditPoint.DeleteWhitespace(vsWhitespaceOptions.vsWhitespaceOptionsVertical);
if (previousBlank)
{
objEditPoint.Insert("\r\n");
}
}
}
objEditPoint.EndOfLine();
}
}
catch (Exception exc)
{
Debug.WriteLine(exc.ToString());
Debug.WriteLine("Formatting Spacing Around Comments failed, skipping");
}
}
}
/// <summary>
/// Updates the #endregion directives to match the names of the matching #region directive
/// and cleans up any unnecessary white space.
/// </summary>
/// <remarks>
/// This code is very similar to the Common region retrieval function, but since it
/// manipulates the cursors during processing the logic is different enough to warrant a
/// separate copy of the code.
/// </remarks>
/// <param name="textDocument">The text document to cleanup.</param>
internal void UpdateEndRegionDirectives(TextDocument textDocument)
{
if (!Settings.Default.Cleaning_UpdateEndRegionDirectives)
{
return;
}
var regionStack = new Stack <string>();
EditPoint cursor = textDocument.StartPoint.CreateEditPoint();
TextRanges subGroupMatches = null; // Not used - required for FindPattern.
const string pattern = @"^[ \t]*#";
// Keep pushing cursor forwards (note ref cursor parameter) until finished.
while (cursor != null &&
cursor.FindPattern(pattern, TextDocumentHelper.StandardFindOptions, ref cursor, ref subGroupMatches))
{
// Create a pointer to capture the text for this line.
EditPoint eolCursor = cursor.CreateEditPoint();
eolCursor.EndOfLine();
string regionText = cursor.GetText(eolCursor);
if (regionText.StartsWith("region ")) // Space required by compiler.
{
// Cleanup any whitespace in the region name.
string regionName = regionText.Substring(7);
string regionNameTrimmed = regionName.Trim();
if (regionName != regionNameTrimmed)
{
cursor.CharRight(7);
cursor.Delete(eolCursor);
cursor.Insert(regionNameTrimmed);
}
// Push the parsed region name onto the top of the stack.
regionStack.Push(regionNameTrimmed);
}
else if (regionText.StartsWith("endregion")) // Space may or may not be present.
{
if (regionStack.Count > 0)
{
// Do not trim the endRegionName in order to catch whitespace differences.
string endRegionName = regionText.Length > 9 ?
regionText.Substring(10) : String.Empty;
string matchingRegion = regionStack.Pop();
// Update if the strings do not match.
if (matchingRegion != endRegionName)
{
cursor.CharRight(9);
cursor.Delete(eolCursor);
cursor.Insert(" " + matchingRegion);
}
}
else
{
// This document is improperly formatted, abort.
return;
}
}
// Note: eolCursor may be outdated now if changes have been made.
cursor.EndOfLine();
}
}
/// <summary>
/// Sorts functions within a class.
/// </summary>
/// <param name="codeElement">The code element that represents the class.</param>
private void SortFunctionsWithinClass(CodeElement codeElement)
{
EditPoint classPoint = codeElement.StartPoint.CreateEditPoint();
TextRanges trs = null;
string classBackup = classPoint.GetText(codeElement.EndPoint);
try
{
if (classPoint.FindPattern("{", (int)vsFindOptions.vsFindOptionsMatchCase, ref classPoint, ref trs))
{
classPoint.Insert("\r\n");
List <CodeBlock> blocks = new List <CodeBlock>();
Array accessLevels = Enum.GetValues(typeof(vsCMAccess));
for (int i = 1; i <= codeElement.Children.Count; i++)
{
CodeElement element = codeElement.Children.Item(i);
if (element.Kind != vsCMElement.vsCMElementAttribute)
{
EditPoint startBlock = element.GetStartPoint(vsCMPart.vsCMPartWholeWithAttributes).CreateEditPoint();
EditPoint newStartPoint = startBlock.CreateEditPoint();
CodeBlock block = EvaluateBlock(codeElement, element, ref newStartPoint);
if (block != null)
{
blocks.Add(block);
newStartPoint.Delete(element.EndPoint);
newStartPoint.DeleteWhitespace(vsWhitespaceOptions.vsWhitespaceOptionsVertical);
i--;
}
}
}
blocks.Sort(delegate(CodeBlock c1, CodeBlock c2)
{
int comparison = 0;
if (c1.Placement != c2.Placement)
{
comparison = c1.Placement.CompareTo(c2.Placement);
}
else if (c1.Access != c2.Access)
{
comparison = c1.Access.CompareTo(c2.Access);
}
else if (c1.Name != c2.Name)
{
comparison = c1.Name.CompareTo(c2.Name);
}
else
{
comparison = c1.Weight.CompareTo(c2.Weight);
}
return(comparison);
});
classPoint.DeleteWhitespace(vsWhitespaceOptions.vsWhitespaceOptionsVertical);
classPoint.Insert("\r\n");
for (int i = 0; i < blocks.Count; i++)
{
classPoint.Insert(blocks[i].Body + "\r\n\r\n");
}
classPoint.LineUp(1);
classPoint.DeleteWhitespace(vsWhitespaceOptions.vsWhitespaceOptionsVertical);
for (int i = 1; i <= codeElement.Children.Count; i++)
{
CodeElement element = codeElement.Children.Item(i);
if (element.Kind == vsCMElement.vsCMElementClass || element.Kind == vsCMElement.vsCMElementInterface || element.Kind == vsCMElement.vsCMElementStruct)
{
SortFunctionsWithinClass(element);
}
}
}
}
catch (Exception exc)
{
Debug.WriteLine(exc.ToString());
EditPoint startBackup = codeElement.StartPoint.CreateEditPoint();
startBackup.Delete(codeElement.EndPoint);
startBackup.Insert(classBackup);
Debug.WriteLine("-- Class Reverted --");
}
}
