void ResolveDirectoryConflict(MergeChangeInfo conflict)
{
ConflictResolutionState state;
if (!mConflictResolutionStates.TryGetValue(conflict.DirectoryConflict, out state))
{
return;
}
List <DirectoryConflictResolutionData> conflictResolutions =
new List <DirectoryConflictResolutionData>();
AddConflictResolution(
conflict,
state.ResolveAction,
state.RenameValue,
conflictResolutions);
MergeChangeInfo metaConflict =
mIncomingChangesTreeView.GetMetaChange(conflict);
if (metaConflict != null)
{
AddConflictResolution(
metaConflict,
state.ResolveAction,
MetaPath.GetMetaPath(state.RenameValue),
conflictResolutions);
}
if (state.IsApplyActionsForNextConflictsChecked)
{
foreach (MergeChangeInfo otherConflict in mIncomingChangesTreeView.GetSelectedIncomingChanges())
{
AddConflictResolution(
otherConflict,
state.ResolveAction,
state.RenameValue,
conflictResolutions);
}
}
mMergeViewLogic.ResolveDirectoryConflicts(conflictResolutions);
}
public void IsFileConflictWithMetaResolved()
{
long itemId = 55;
long metaItemId = 66;
MountPointId mountPointId = MountPointId.WORKSPACE_ROOT;
MergeChangeInfo fileConflict = BuildFileConflict(mountPointId, itemId);
MergeChangeInfo metaFileConflict = BuildFileConflict(mountPointId, metaItemId);
MergeSolvedFileConflicts solvedFileConflicts = new MergeSolvedFileConflicts();
solvedFileConflicts.AddResolveFile(mountPointId, itemId, "foo.c");
solvedFileConflicts.AddResolveFile(mountPointId, metaItemId, "foo.c.meta");
Assert.IsTrue(
IsSolved.Conflict(fileConflict, metaFileConflict, solvedFileConflicts),
"Conflict should be resolved");
}
static Texture GetIcon(
string wkPath,
MergeChangeInfo incomingChange)
{
RevisionInfo revInfo = incomingChange.GetRevision();
bool isDirectory = revInfo.
Type == EnumRevisionType.enDirectory;
if (isDirectory || incomingChange.IsXLink())
{
return(Images.GetDirectoryIcon());
}
string fullPath = WorkspacePath.GetWorkspacePathFromCmPath(
wkPath,
incomingChange.GetPath(),
Path.DirectorySeparatorChar);
return(Images.GetFileIcon(fullPath));
}
static void DiffIncomingChanges(
MergeChangeInfo incomingChange,
WorkspaceInfo wkInfo)
{
if (LaunchTool.ShowDownloadPlasticExeWindow(false))
{
return;
}
DiffOperation.DiffRevisions(
wkInfo,
incomingChange.GetMount().RepSpec,
incomingChange.GetBaseRevision(),
incomingChange.GetRevision(),
incomingChange.GetPath(),
incomingChange.GetPath(),
true,
xDiffLauncher: null,
imageDiffLauncher: null);
}
internal static bool Conflict(
MergeChangeInfo changeInfo,
MergeChangeInfo metaChangeInfo,
MergeSolvedFileConflicts solvedFileConflicts)
{
if (solvedFileConflicts == null)
{
return(false);
}
MergeSolvedFileConflicts.CurrentConflict currentConflict;
if (!solvedFileConflicts.TryGetCurrentConflict(out currentConflict))
{
return(false);
}
return(IsSameConflict(currentConflict, changeInfo) ||
IsSameConflict(currentConflict, metaChangeInfo));
}
public void CurrentConflictWithMetaCurrentIsTheMeta()
{
long itemId = 55;
long metaItemId = 66;
MountPointId mountPointId = MountPointId.WORKSPACE_ROOT;
MergeChangeInfo changeInfo = BuildChangeInfo(mountPointId, itemId);
MergeChangeInfo metaChangeInfo = BuildChangeInfo(mountPointId, metaItemId);
MergeSolvedFileConflicts solvedFileConflicts = new MergeSolvedFileConflicts();
MergeSolvedFileConflicts.CurrentConflict currentConflict = new MergeSolvedFileConflicts.CurrentConflict(
mountPointId, metaItemId, 0);
solvedFileConflicts.SetCurrentConflict(currentConflict);
Assert.IsTrue(
IsCurrent.Conflict(changeInfo, metaChangeInfo, solvedFileConflicts),
"Should return true");
}
public void TestChangedWithDeletedMeta()
{
MergeTreeResult conflicts = new MergeTreeResult();
MountPointWithPath rootMountPointWithPath = BuildRootMountPointWithPath();
FileConflict modified =
BuildMergeTreeResult.CreateModifiedDifference("/foo/bar.c");
Difference deletedMeta =
BuildMergeTreeResult.CreateDeletedDifference("/foo/bar.c.meta");
conflicts.FilesModifiedOnSource.Add(modified);
conflicts.DeletesToApply.Add(deletedMeta);
UnityIncomingChangesTree tree = UnityIncomingChangesTree.BuildIncomingChangeCategories(
MergeChangesTree.BuildForIncomingChangesView(
conflicts,
new GetConflictResolutionMock(),
rootMountPointWithPath));
MergeChangeInfo changeInfo = FindChangeInfo.FromFileConflict(
modified, tree);
MergeChangeInfo deleteInfo = FindChangeInfo.FromDifference(
deletedMeta, tree);
Assert.IsNotNull(
changeInfo,
"ChangeInfo not found");
Assert.IsNotNull(
deleteInfo,
"DeleteInfo not found");
Assert.IsNull(
tree.GetMetaChange(changeInfo),
"Meta change should be null");
}
static void DoDirectoryConflictResolutionPanel(
List <MergeChangeInfo> selectedChangeInfos,
Action <MergeChangeInfo> resolveDirectoryConflictAction,
Dictionary <DirectoryConflict, ConflictResolutionState> conflictResolutionStates)
{
MergeChangeInfo selectedDirectoryConflict = selectedChangeInfos[0];
if (selectedDirectoryConflict.DirectoryConflict.IsResolved())
{
return;
}
DirectoryConflictUserInfo conflictUserInfo;
DirectoryConflictAction[] conflictActions;
DirectoryConflictResolutionInfo.FromDirectoryConflict(
selectedDirectoryConflict.GetMount(),
selectedDirectoryConflict.DirectoryConflict,
out conflictUserInfo,
out conflictActions);
ConflictResolutionState conflictResolutionState = GetConflictResolutionState(
selectedDirectoryConflict.DirectoryConflict,
conflictActions,
conflictResolutionStates);
int pendingSelectedConflictsCount = GetPendingConflictsCount(
selectedChangeInfos);
DrawDirectoryResolutionPanel.ForConflict(
selectedDirectoryConflict,
(pendingSelectedConflictsCount <= 1) ? 0 : pendingSelectedConflictsCount - 1,
conflictUserInfo,
conflictActions,
resolveDirectoryConflictAction,
ref conflictResolutionState);
}
static void DiffYoursWithIncoming(
MergeChangeInfo incomingChange,
WorkspaceInfo wkInfo)
{
if (LaunchTool.ShowDownloadPlasticExeWindow(
wkInfo,
false,
TrackFeatureUseEvent.Features.InstallPlasticCloudFromDiffYoursWithIncoming,
TrackFeatureUseEvent.Features.InstallPlasticEnterpriseFromDiffYoursWithIncoming,
TrackFeatureUseEvent.Features.CancelPlasticInstallationFromDiffYoursWithIncoming))
{
return;
}
DiffOperation.DiffYoursWithIncoming(
wkInfo,
incomingChange.GetMount(),
incomingChange.GetRevision(),
incomingChange.GetPath(),
xDiffLauncher: null,
imageDiffLauncher: null);
}
internal bool ContainsMeta(MergeChangeInfo changeInfo)
{
string key = BuildKey.ForMetaChange(changeInfo);
return(mCache.ContainsKey(key));
}
internal MergeChangeInfo GetMetaChange(MergeChangeInfo change)
{
return(mMetaCache.GetExistingMeta(change));
}
internal bool HasMeta(MergeChangeInfo changeInfo)
{
return(mMetaCache.ContainsMeta(changeInfo));
}
static void IncomingChangeTreeViewItemCellGUI(
string wkPath,
Rect rect,
float rowHeight,
UnityIncomingChangesTree incomingChangesTree,
IncomingChangesTreeView treeView,
ChangeTreeViewItem item,
IncomingChangesTreeColumn column,
bool isSelected,
bool isFocused,
bool isCurrentConflict,
bool isSolvedConflict)
{
MergeChangeInfo incomingChange = item.ChangeInfo;
string label = incomingChange.GetColumnText(
IncomingChangesTreeHeaderState.GetColumnName(column));
if (column == IncomingChangesTreeColumn.Path)
{
if (incomingChangesTree.HasMeta(item.ChangeInfo))
{
label = string.Concat(label, UnityConstants.TREEVIEW_META_LABEL);
}
Texture icon = GetIcon(wkPath, incomingChange);
Texture overlayIcon =
GetChangesOverlayIcon.ForPlasticIncomingChange(
incomingChange, isSolvedConflict);
DrawTreeViewItem.ForItemCell(
rect,
rowHeight,
item.depth,
icon,
overlayIcon,
label,
isSelected,
isFocused,
isCurrentConflict,
false);
return;
}
if (column == IncomingChangesTreeColumn.Size)
{
// If there is a meta file, add the meta file to the file size so that it is consistent
// with the Incoming Changes overview
if (incomingChangesTree.HasMeta(item.ChangeInfo))
{
MergeChangeInfo metaFileInfo = incomingChangesTree.GetMetaChange(incomingChange);
long metaFileSize = metaFileInfo.GetSize();
long fileSize = incomingChange.GetSize();
label = SizeConverter.ConvertToSizeString(fileSize + metaFileSize);
}
DrawTreeViewItem.ForSecondaryLabelRightAligned(
rect, label, isSelected, isFocused, isCurrentConflict);
return;
}
DrawTreeViewItem.ForSecondaryLabel(
rect, label, isSelected, isFocused, isCurrentConflict);
}
static bool IsDirectoryConflict(MergeChangeInfo changeInfo)
{
return(changeInfo.DirectoryConflict != null);
}
static bool IsDirectoryConflictResolved(MergeChangeInfo changeInfo)
{
return(changeInfo.DirectoryConflict.IsResolved());
}
