public void HandlesInlineAddition2Successful()
{
var source = new[]
{
" public SomeClass(IOtherService otherService)",
" {",
" }",
};
var merge = new[]
{
"public SomeClass(/*{[{*/ISomeService someService/*}]}*/)",
"{",
"//{[{",
" _someService = someService;",
"//}]}",
"}",
};
var expected = new[]
{
" public SomeClass(IOtherService otherService, ISomeService someService)",
" {",
" _someService = someService;",
" }",
};
var mergeHandler = new MergeHandler(new CSharpStyleProvider());
var result = mergeHandler.Merge(source, merge);
Assert.Equal(expected, result.Result);
}
/// <summary>
/// Invokes merge process
/// </summary>
/// <param name="schemaName">Schema name.</param>
/// <param name="groupId">Identifier of the group of search results</param>
/// <param name="deduplicateRecordIds">Unique identifiers.</param>
/// <param name="resolvedConflicts">Config for resolving conflicts.</param>
/// <returns>Instance <see cref="DuplicatesMergeResponse"/> results for merge process execution.</returns>
public virtual DuplicatesMergeResponse MergeEntityDuplicatesAsync(string schemaName, int groupId,
List <Guid> duplicateRecordIds, Dictionary <string, string> resolvedConflicts = null)
{
DuplicatesMergeResponse result = new DuplicatesMergeResponse();
if (!Locker.CanExecute(DeduplicationConsts.SearchOperationId, schemaName))
{
return(result);
}
ValidateDuplicatesResponse response = MergeHandler.ValidateDuplicates(schemaName, duplicateRecordIds, resolvedConflicts);
if (response.ConflictsExists)
{
result.Conflicts = response.Conflicts;
return(result);
}
MergeHandler.ExcludeSearchResultGroup(schemaName, groupId);
string jobName = string.Format(MergeDuplicatesJobNamePattern, schemaName, Guid.NewGuid());
var parameters = new Dictionary <string, object>()
{
{ "SchemaName", schemaName },
{ "OperationId", DeduplicationConsts.MergeOperationId },
{ "DuplicateGroupId", groupId },
{ "DuplicateRecordIds", duplicateRecordIds },
{ "ResolvedConflicts", resolvedConflicts }
};
AppScheduler.ScheduleImmediateProcessJob(jobName, "Dedublication", MergeDuplicatesProcessName,
_userConnection.Workspace.Name, _userConnection.CurrentUser.Name, parameters);
result.Success = true;
return(result);
}
public void NothingToRemoveVB()
{
var source = new[]
{
"Public Sub SomeMethod()",
" Exit Sub",
"End Sub",
};
var merge = new[]
{
"Public Sub SomeOtherMethod()",
" ' Something unrelated to deletion",
"End Sub",
};
var expected = new[]
{
"Public Sub SomeMethod()",
" Exit Sub",
"End Sub",
};
var mergeHandler = new MergeHandler(new VBStyleProvider());
var result = mergeHandler.Merge(source, merge);
Assert.Equal(expected, result.Result);
}
public void AlreadyRemovedVB()
{
var source = new[]
{
"Public Sub SomeMethod()",
"End Sub",
};
var merge = new[]
{
"Public Sub SomeMethod()",
"'{--{",
" Exit Sub",
"'}--}",
"End Sub",
};
var expected = new[]
{
"Public Sub SomeMethod()",
"End Sub",
};
var mergeHandler = new MergeHandler(new VBStyleProvider());
var result = mergeHandler.Merge(source, merge);
Assert.Equal(expected, result.Result);
Assert.True(result.Success);
Assert.Equal(string.Empty, result.ErrorLine);
}
public void SingleRemovalAndMergeVB()
{
var source = new[]
{
"Public Sub SomeMethod()",
" Exit Sub",
"End Sub",
};
var merge1 = new[]
{
"Public Sub SomeMethod()",
" '{[{",
" ' Merge1",
" '}]}",
"'{--{",
" Exit Sub",
"'}--}",
"End Sub",
};
var expected = new[]
{
"Public Sub SomeMethod()",
" ' Merge1",
"End Sub",
};
var mergeHandler = new MergeHandler(new VBStyleProvider());
var result = mergeHandler.Merge(source, merge1);
Assert.Equal(expected, result.Result);
}
public void HandlesAdditionSuccessful()
{
var source = new[]
{
"public void SomeMethod()",
"{",
"}",
};
var merge = new[]
{
"public void SomeMethod()",
"{",
"//{[{",
" AddSomeInstructions()",
"//}]}",
"}",
};
var expected = new[]
{
"public void SomeMethod()",
"{",
" AddSomeInstructions()",
"}",
};
var mergeHandler = new MergeHandler(new CSharpStyleProvider());
var result = mergeHandler.Merge(source, merge);
Assert.Equal(expected, result.Result);
}
public void HandlesInlineAddition2SuccessfulVB()
{
var source = new[]
{
" Public Sub New(otherService As IOtherService)",
" End Sub",
};
var merge = new[]
{
"Public Sub New(/*{[{*/someService As ISomeService/*}]}*/)",
"'{[{",
" _someService = someService",
"'}]}",
"End Sub",
};
var expected = new[]
{
" Public Sub New(otherService As IOtherService, someService As ISomeService)",
" _someService = someService",
" End Sub",
};
var mergeHandler = new MergeHandler(new VBStyleProvider());
var result = mergeHandler.Merge(source, merge);
Assert.Equal(expected, result.Result);
}
public void HandlesSuccessfulVB()
{
var source = new[]
{
"Public Sub SomeMethod()",
" Exit Sub",
"End Sub",
};
var merge = new[]
{
"Public Sub SomeMethod()",
"'{--{",
" Exit Sub",
"'}--}",
"End Sub",
};
var expected = new[]
{
"Public Sub SomeMethod()",
"End Sub",
};
var mergeHandler = new MergeHandler(new VBStyleProvider());
var result = mergeHandler.Merge(source, merge);
Assert.Equal(expected, result.Result);
}
public void AlreadyRemoved()
{
var source = new[]
{
"public void SomeMethod()",
"{",
"}",
};
var merge = new[]
{
"public void SomeMethod()",
"{",
"//{--{",
" yield break;",
"//}--}",
"}",
};
var expected = new[]
{
"public void SomeMethod()",
"{",
"}",
};
var mergeHandler = new MergeHandler(new CSharpStyleProvider());
var result = mergeHandler.Merge(source, merge);
Assert.Equal(expected, result.Result);
}
public void HandlesAdditionSuccessfulVB()
{
var source = new[]
{
"Public Sub SomeMethod()",
"End Sub",
};
var merge = new[]
{
"Public Sub SomeMethod()",
"'{[{",
" AddSomeInstructions()",
"'}]}",
"End Sub",
};
var expected = new[]
{
"Public Sub SomeMethod()",
" AddSomeInstructions()",
"End Sub",
};
var mergeHandler = new MergeHandler(new VBStyleProvider());
var result = mergeHandler.Merge(source, merge);
Assert.Equal(expected, result.Result);
}
public void AlreadyAdded()
{
var source = new[]
{
"public void SomeMethod()",
"{",
" TestMethod();",
"}",
};
var merge = new[]
{
"public void SomeMethod()",
"{",
"//{[{",
" TestMethod();",
"//}]}",
"}",
};
var expected = new[]
{
"public void SomeMethod()",
"{",
" TestMethod();",
"}",
};
var mergeHandler = new MergeHandler(new CSharpStyleProvider());
var result = mergeHandler.Merge(source, merge);
Assert.Equal(expected, result.Result);
}
public void NothingToRemove()
{
var source = new[]
{
"public void SomeMethod()",
"{",
" yield break;",
"}",
};
var merge = new[]
{
"public void SomeOtherMethod()",
"{",
" // Something unrelated to deletion",
"}",
};
var expected = new[]
{
"public void SomeMethod()",
"{",
" yield break;",
"}",
};
var mergeHandler = new MergeHandler(new CSharpStyleProvider());
var result = mergeHandler.Merge(source, merge);
Assert.Equal(expected, result.Result);
}
public void MultipleRemovalsAndMerges()
{
var source = new[]
{
"public void SomeMethod()",
"{",
" yield break;",
"}",
};
var merge1 = new[]
{
"public void SomeMethod()",
"{",
" //{[{",
" // Merge1",
" //}]}",
"//{--{",
" yield break;",
"//}--}",
"}",
};
var merge2 = new[]
{
"public void SomeMethod()",
"{",
" //{[{",
" // Merge2",
" //}]}",
"//{--{",
" yield break;",
"//}--}",
"}",
};
var expected = new List <string>()
{
"public void SomeMethod()",
"{",
" // Merge2",
string.Empty,
" // Merge1",
"}",
};
var mergeHandler = new MergeHandler(new CSharpStyleProvider());
var result = mergeHandler.Merge(source, merge1);
var mergeHandler2 = new MergeHandler(new CSharpStyleProvider());
result = mergeHandler2.Merge(result.Result, merge2);
Assert.Equal(expected, result.Result);
}
public void MultipleRemovalsAndMergesVB()
{
var source = new[]
{
"Public Sub SomeMethod()",
" Exit Sub",
"End Sub",
};
var merge1 = new[]
{
"Public Sub SomeMethod()",
" '{[{",
" ' Merge1",
" '}]}",
"'{--{",
" Exit Sub",
"'}--}",
"End Sub",
};
var merge2 = new[]
{
"Public Sub SomeMethod()",
" '{[{",
" ' Merge2",
" '}]}",
"'{--{",
" Exit Sub,",
"'}--}",
"End Sub",
};
var expected = new[]
{
"Public Sub SomeMethod()",
" ' Merge2",
string.Empty,
" ' Merge1",
"End Sub",
};
var mergeHandler = new MergeHandler(new VBStyleProvider());
var result = mergeHandler.Merge(source, merge1);
var mergeHandler2 = new MergeHandler(new VBStyleProvider());
result = mergeHandler2.Merge(result.Result, merge2);
Assert.Equal(expected, result.Result);
Assert.True(result.Success);
Assert.Equal(string.Empty, result.ErrorLine);
}
public void MergeWithOptionalContextLines()
{
var source = File.ReadAllLines(@".\TestData\Merge\SourceWithOptionalContextLines.cs");
var merge = File.ReadAllLines(@".\TestData\Merge\Source_postaction.cs");
var expected = File.ReadAllText(@".\TestData\Merge\Source_expectedWithOptionalContextLines.cs");
var mergeHandler = new MergeHandler(new CSharpStyleProvider());
var result = mergeHandler.Merge(source, merge);
// Remove all new line chars to avoid differentiation with the new line characters
expected = expected.Replace("\r\n", string.Empty).Replace("\n", string.Empty);
Assert.Equal(expected, string.Join(string.Empty, result.Result.ToArray()));
Assert.True(result.Success);
Assert.Equal(string.Empty, result.ErrorLine);
}
public WitConversation(string token, string conversationId, T initialContext,
MergeHandler merge, SayHandler say, ActionHandler action, StopHandler stop)
{
if (token == null || conversationId == null || merge == null || say == null || action == null)
{
throw new Exception("Please check WitConversation constructor parameters.");
}
client = new WitClient(token);
this.conversationId = conversationId;
_merge = merge;
_say = say;
_action = action;
_stop = stop;
context = initialContext;
}
//remove all the slides but keep the ones from slidesToKeep
//SlidesTokKeep indexed from 1
public static void UpdateFileKeepSlides(string presentationFile, List <int> slidesToKeep)
{
slidesToKeep.Sort();
var slideCount = new MergeHandler().GetTotalSlidesCount(presentationFile);
int index = 0;
var finalSlideCount = slidesToKeep.Count();
slidesToKeep = slidesToKeep.Select(x => { if (x != 0)
{
x = x - 1;
}
return(x); }).ToList();
using (PresentationDocument presentationDocument = PresentationDocument.Open(presentationFile, true))
{
while (slideCount != finalSlideCount)
{
if (!slidesToKeep.Contains(index))
{
DeleteSlide(presentationDocument, index);
slidesToKeep = slidesToKeep.Select(x => { if (x != 0)
{
x = x - 1;
}
return(x); }).ToList();
slideCount--;
}
else
{
index++;
}
}
}
/* using (PresentationDocument presentationDocument = PresentationDocument.Open(presentationFile, true))
* {
*
* // DeleteSlide(presentationDocument, 12); //deleted 11th slide
* DeleteSlide(presentationDocument, 9);
* DeleteSlide(presentationDocument, 10);
* }*/
}
public static bool ModifiedWithoutLock(this VersionControlStatus vcs)
{
return(vcs.fileStatus == VCFileStatus.Modified && vcs.lockStatus != VCLockStatus.LockedHere && !MergeHandler.IsMergableAsset(vcs.assetPath));
}
public static void CreateVCContextMenu(ref GenericMenu menu, string assetPath, Object instance = null)
{
if (VCUtility.ValidAssetPath(assetPath))
{
bool ready = VCCommands.Instance.Ready;
if (ready)
{
if (instance && ObjectUtilities.ChangesStoredInScene(instance))
{
assetPath = SceneManagerUtilities.GetCurrentScenePath();
}
var validActions = GetValidActions(assetPath, instance);
if ((validActions & ValidActions.Diff) != 0)
{
menu.AddItem(new GUIContent(Terminology.diff), false, () => MergeHandler.DiffWithBase(assetPath));
}
if ((validActions & ValidActions.Add) != 0)
{
menu.AddItem(new GUIContent(Terminology.add), false, () => VCCommands.Instance.Add(new[] { assetPath }));
}
if ((validActions & ValidActions.Open) != 0)
{
menu.AddItem(new GUIContent(Terminology.getlock), false, () => GetLock(assetPath, instance));
}
if ((validActions & ValidActions.OpenLocal) != 0)
{
menu.AddItem(new GUIContent(Terminology.allowLocalEdit), false, () => AllowLocalEdit(assetPath, instance));
}
if ((validActions & ValidActions.Commit) != 0)
{
menu.AddItem(new GUIContent(Terminology.commit), false, () => Commit(assetPath, instance));
}
if ((validActions & ValidActions.Unlock) != 0)
{
menu.AddItem(new GUIContent(Terminology.unlock), false, () => VCCommands.Instance.ReleaseLock(new[] { assetPath }));
}
if ((validActions & ValidActions.Delete) != 0)
{
menu.AddItem(new GUIContent(Terminology.delete), false, () => VCCommands.Instance.Delete(new[] { assetPath }));
}
if ((validActions & ValidActions.Revert) != 0)
{
menu.AddItem(new GUIContent(Terminology.revert), false, () => Revert(assetPath, instance));
}
if ((validActions & ValidActions.UseTheirs) != 0)
{
menu.AddItem(new GUIContent("Use Theirs"), false, () => VCCommands.Instance.Resolve(new [] { assetPath }, ConflictResolution.Theirs));
}
if ((validActions & ValidActions.UseMine) != 0)
{
menu.AddItem(new GUIContent("Use Mine"), false, () => VCCommands.Instance.Resolve(new [] { assetPath }, ConflictResolution.Mine));
}
if ((validActions & ValidActions.Merge) != 0)
{
menu.AddItem(new GUIContent("Merge"), false, () => MergeHandler.ResolveConflict(assetPath));
}
if ((validActions & ValidActions.AddChangeList) != 0)
{
menu.AddItem(new GUIContent("Add To " + Terminology.changelist), false, () => ChangeListWindow.Open(new [] { assetPath }));
}
if ((validActions & ValidActions.RemoveChangeList) != 0)
{
menu.AddItem(new GUIContent("Remove From " + Terminology.changelist), false, () => VCCommands.Instance.ChangeListRemove(new [] { assetPath }));
}
}
else
{
menu.AddDisabledItem(new GUIContent("..Busy.."));
}
}
}
public static ValidActions GetValidActions(string assetPath, Object instance = null)
{
using (sceneviewUpdateMarker.Auto())
{
if (!VCCommands.Active || string.IsNullOrEmpty(assetPath))
{
return(noAction);
}
var assetStatus = VCCommands.Instance.GetAssetStatus(assetPath);
bool isPrefab = instance != null && PrefabHelper.IsPrefab(instance);
bool isPrefabParent = isPrefab && PrefabHelper.IsPrefabParent(instance);
bool isFolder = AssetDatabase.IsValidFolder(assetPath);
bool diffableAsset = MergeHandler.IsDiffableAsset(assetPath);
bool mergableAsset = MergeHandler.IsMergableAsset(assetPath);
bool modifiedDiffableAsset = diffableAsset && assetStatus.fileStatus != VCFileStatus.Normal;
bool modifiedMeta = assetStatus.MetaStatus().fileStatus != VCFileStatus.Normal;
bool lockedMeta = assetStatus.MetaStatus().lockStatus == VCLockStatus.LockedHere;
bool modified = assetStatus.fileStatus == VCFileStatus.Modified;
bool localOnly = assetStatus.localOnly;
bool deleted = assetStatus.fileStatus == VCFileStatus.Deleted;
bool added = assetStatus.fileStatus == VCFileStatus.Added;
bool unversioned = assetStatus.fileStatus == VCFileStatus.Unversioned;
bool ignored = assetStatus.fileStatus == VCFileStatus.Ignored;
bool replaced = assetStatus.fileStatus == VCFileStatus.Replaced;
bool lockedByOther = assetStatus.lockStatus == VCLockStatus.LockedOther;
bool managedByRep = VCUtility.ManagedByRepository(assetStatus);
bool haveControl = VCUtility.HaveAssetControl(assetStatus);
bool haveLock = VCUtility.HaveVCLock(assetStatus);
bool allowLocalEdit = assetStatus.LocalEditAllowed();
bool pending = assetStatus.reflectionLevel == VCReflectionLevel.Pending;
bool mergeinfo = assetStatus.property == VCProperty.Modified;
bool conflicted = assetStatus.fileStatus == VCFileStatus.Conflicted;
bool hasChangeSet = !ComposedString.IsNullOrEmpty(assetStatus.changelist);
bool showAdd = !pending && !ignored && unversioned;
bool showOpen = !pending && !showAdd && !added && !haveLock && !deleted && !isFolder && !mergableAsset && ((!lockedByOther && !localOnly) || allowLocalEdit);
bool showDiff = !pending && !ignored && !deleted && modifiedDiffableAsset && managedByRep;
bool showCommit = !pending && !ignored && !allowLocalEdit && !localOnly && (haveLock || added || deleted || modifiedDiffableAsset || modifiedMeta || mergeinfo);
bool showRevert = !pending && !ignored && !unversioned &&
(haveControl || modified || added || deleted || replaced || modifiedDiffableAsset || modifiedMeta || lockedMeta || mergeinfo);
bool showDelete = !pending && !ignored && !deleted && !lockedByOther;
bool showOpenLocal = !pending && !ignored && !deleted && !isFolder && !allowLocalEdit && !unversioned && !added && !haveLock && !mergableAsset && !localOnly;
bool showUnlock = !pending && !ignored && !allowLocalEdit && haveLock;
bool showUpdate = !pending && !ignored && !added && managedByRep && instance != null;
bool showUseTheirs = !pending && !ignored && conflicted;
bool showUseMine = !pending && !ignored && conflicted;
bool showMerge = !pending && !ignored && conflicted && mergableAsset;
bool showAddChangeList = !pending && !ignored && !unversioned;
bool showRemoveChangeList = !pending && !ignored && hasChangeSet;
ValidActions validActions = 0;
if (showAdd)
{
validActions |= ValidActions.Add;
}
if (showOpen)
{
validActions |= ValidActions.Open;
}
if (showDiff)
{
validActions |= ValidActions.Diff;
}
if (showCommit)
{
validActions |= ValidActions.Commit;
}
if (showRevert)
{
validActions |= ValidActions.Revert;
}
if (showDelete)
{
validActions |= ValidActions.Delete;
}
if (showOpenLocal)
{
validActions |= ValidActions.OpenLocal;
}
if (showUnlock)
{
validActions |= ValidActions.Unlock;
}
if (showUpdate)
{
validActions |= ValidActions.Update;
}
if (showUseTheirs)
{
validActions |= ValidActions.UseTheirs;
}
if (showUseMine)
{
validActions |= ValidActions.UseMine;
}
if (showMerge)
{
validActions |= ValidActions.Merge;
}
if (showAddChangeList)
{
validActions |= ValidActions.AddChangeList;
}
if (showRemoveChangeList)
{
validActions |= ValidActions.RemoveChangeList;
}
return(validActions);
}
}
private void Initialize()
{
baseFilter = s => false;
guiFilter = s => true;
columnSelection = new MultiColumnState.Column(new GUIContent("[]"), data => new GUIContent(masterSelection.Contains(data) ? " ☑" : " ☐"));
columnAssetPath = new MultiColumnState.Column(new GUIContent("AssetPath"), data => new GUIContent(data.assetPath.Compose()));
columnOwner = new MultiColumnState.Column(new GUIContent("Owner"), data => new GUIContent(data.owner, data.lockToken));
columnFileStatus = new MultiColumnState.Column(new GUIContent("Status"), GetFileStatusContent);
columnMetaStatus = new MultiColumnState.Column(new GUIContent("Meta"), data => GetFileStatusContent(data.MetaStatus()));
columnFileType = new MultiColumnState.Column(new GUIContent("Type"), data => new GUIContent(GetFileType(data.assetPath.Compose())));
columnConflict = new MultiColumnState.Column(new GUIContent("Conflict"), data => new GUIContent(data.treeConflictStatus.ToString()));
columnChangelist = new MultiColumnState.Column(new GUIContent("ChangeList"), data => new GUIContent(data.changelist.Compose()));
var guiSkin = EditorGUIUtility.GetBuiltinSkin(EditorGUIUtility.isProSkin ? EditorSkin.Scene : EditorSkin.Inspector);
multiColumnState = new MultiColumnState();
multiColumnState.Comparer = (r1, r2, c) =>
{
var r1Text = c.GetContent(r1.data).text;
var r2Text = c.GetContent(r2.data).text;
if (r1Text == null)
{
r1Text = "";
}
if (r2Text == null)
{
r2Text = "";
}
//D.Log("Comparing: " + r1Text + " with " + r2Text + " : " + r1Text.CompareTo(r2Text));
return(String.CompareOrdinal(r1Text, r2Text));
};
Func <MultiColumnState.Row, MultiColumnState.Column, GenericMenu> rowRightClickMenu = (row, column) =>
{
var selected = multiColumnState.GetSelected().Select(status => status.assetPath.Compose()).ToList();
if (!selected.Any())
{
return(new GenericMenu());
}
GenericMenu menu = new GenericMenu();
if (selected.Count() == 1)
{
VCGUIControls.CreateVCContextMenu(ref menu, selected.First());
}
else
{
VCGUIControls.CreateVCContextMenu(ref menu, selected);
}
var selectedObjs = selected.Select(a => AssetDatabase.LoadMainAssetAtPath(a)).ToArray();
menu.AddSeparator("");
menu.AddItem(new GUIContent("Show in Project"), false, () =>
{
Selection.objects = selectedObjs;
EditorGUIUtility.PingObject(Selection.activeObject);
});
menu.AddItem(new GUIContent("Show on Harddisk"), false, () =>
{
foreach (string item in selected)
{
EditorUtility.RevealInFinder(item);
}
});
return(menu);
};
Func <MultiColumnState.Column, GenericMenu> headerRightClickMenu = column =>
{
var menu = new GenericMenu();
//menu.AddItem(new GUIContent("Remove"), false, () => { ToggleColumn(column); });
return(menu);
};
// Return value of true steals the click from normal selection, false does not.
Func <MultiColumnState.Row, MultiColumnState.Column, bool> cellClickAction = (row, column) =>
{
GUI.FocusControl("");
if (column == columnSelection)
{
var currentSelection = multiColumnState.GetSelected();
if (currentSelection.Contains(row.data))
{
bool currentRowSelection = masterSelection.Contains(row.data);
foreach (var selectionIt in currentSelection)
{
if (currentRowSelection)
{
masterSelection.Remove(selectionIt);
}
else
{
masterSelection.Add(selectionIt);
}
}
}
else
{
if (masterSelection.Contains(row.data))
{
masterSelection.Remove(row.data);
}
else
{
masterSelection.Add(row.data);
}
}
return(true);
}
return(false);
//D.Log(row.data.assetPath.Compose() + " : " + column.GetContent(row.data).text);
};
options = new MultiColumnViewOption
{
headerStyle = new GUIStyle(guiSkin.button),
rowStyle = new GUIStyle(guiSkin.label),
rowRightClickMenu = rowRightClickMenu,
headerRightClickMenu = headerRightClickMenu,
cellClickAction = cellClickAction,
widths = new float[] { 200 },
doubleClickAction = status =>
{
if (MergeHandler.IsDiffableAsset(status.assetPath) && VCUtility.ManagedByRepository(status) && status.fileStatus == VCFileStatus.Conflicted)
{
var assetPath = status.assetPath.Compose();
VCCommands.Instance.GetConflict(assetPath, out var basePath, out var yours, out var theirs);
MergeHandler.ResolveConflict(assetPath, basePath, theirs, yours);
}
else if (MergeHandler.IsDiffableAsset(status.assetPath) && VCUtility.ManagedByRepository(status) && status.fileStatus == VCFileStatus.Modified)
{
MergeHandler.DiffWithBase(status.assetPath.Compose());
}
else
{
string path = status.assetPath.Compose();
var obj = AssetDatabase.LoadMainAssetAtPath(path);
if (path.StartsWith("Assets"))
{
if (AssetDatabase.IsValidFolder(path) || obj == null)
{
EditorUtility.RevealInFinder(path);
}
else
{
bool result = AssetDatabase.OpenAsset(obj);
if (!result)
{
EditorUtility.RevealInFinder(path);
}
}
}
else
{
EditorUtility.RevealInFinder(path);
}
}
}
};
options.headerStyle.fixedHeight = 20.0f;
options.rowStyle.onNormal.background = IconUtils.CreateSquareTexture(4, 1, new Color(0.24f, 0.5f, 0.87f, 0.75f));
options.rowStyle.margin = new RectOffset(2, 2, 2, 1);
options.rowStyle.border = new RectOffset(0, 0, 0, 0);
options.rowStyle.padding = new RectOffset(0, 0, 0, 0);
if (showMasterSelection)
{
multiColumnState.AddColumn(columnSelection);
options.widthTable.Add(columnSelection.GetHeader().text, 25);
}
multiColumnState.AddColumn(columnAssetPath);
options.widthTable.Add(columnAssetPath.GetHeader().text, 500);
multiColumnState.AddColumn(columnFileStatus);
options.widthTable.Add(columnFileStatus.GetHeader().text, 90);
multiColumnState.AddColumn(columnMetaStatus);
options.widthTable.Add(columnMetaStatus.GetHeader().text, 100);
multiColumnState.AddColumn(columnFileType);
options.widthTable.Add(columnFileType.GetHeader().text, 80);
multiColumnState.AddColumn(columnOwner);
options.widthTable.Add(columnOwner.GetHeader().text, 60);
multiColumnState.AddColumn(columnChangelist);
options.widthTable.Add(columnChangelist.GetHeader().text, 120);
//columnConflictState.AddColumn(columnConflict);
options.widthTable.Add(columnConflict.GetHeader().text, 80);
}
