Initial commit

This commit is contained in:
lethanhsonvsp
2025-11-17 15:02:30 +07:00
commit 0a84b9d75e
15481 changed files with 2009655 additions and 0 deletions

View File

@@ -0,0 +1,17 @@
using UnityEditor.IMGUI.Controls;
namespace Unity.PlasticSCM.Editor.Views.Changesets
{
class ChangesetListViewItem : TreeViewItem
{
internal object ObjectInfo { get; private set; }
internal ChangesetListViewItem(int id, object objectInfo)
: base(id, 1)
{
ObjectInfo = objectInfo;
displayName = id.ToString();
}
}
}

View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 6000865ce7fbfc643abdd3d085b4422e
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,161 @@
using System;
using System.Collections.Generic;
using UnityEditor.IMGUI.Controls;
using UnityEngine;
using PlasticGui;
using Unity.PlasticSCM.Editor.UI;
using Unity.PlasticSCM.Editor.UI.Tree;
namespace Unity.PlasticSCM.Editor.Views.Changesets
{
internal enum ChangesetsListColumn
{
Name,
CreationDate,
CreatedBy,
Comment,
Branch,
Repository,
Guid
}
[Serializable]
internal class ChangesetsListHeaderState : MultiColumnHeaderState, ISerializationCallbackReceiver
{
internal static ChangesetsListHeaderState GetDefault()
{
return new ChangesetsListHeaderState(BuildColumns());
}
internal static List<string> GetColumnNames()
{
List<string> result = new List<string>();
result.Add(PlasticLocalization.GetString(PlasticLocalization.Name.NameColumn));
result.Add(PlasticLocalization.GetString(PlasticLocalization.Name.CreationDateColumn));
result.Add(PlasticLocalization.GetString(PlasticLocalization.Name.CreatedByColumn));
result.Add(PlasticLocalization.GetString(PlasticLocalization.Name.CommentColumn));
result.Add(PlasticLocalization.GetString(PlasticLocalization.Name.BranchColumn));
result.Add(PlasticLocalization.GetString(PlasticLocalization.Name.RepositoryColumn));
result.Add(PlasticLocalization.GetString(PlasticLocalization.Name.GuidColumn));
return result;
}
internal static string GetColumnName(ChangesetsListColumn column)
{
switch (column)
{
case ChangesetsListColumn.Name:
return PlasticLocalization.GetString(PlasticLocalization.Name.NameColumn);
case ChangesetsListColumn.CreationDate:
return PlasticLocalization.GetString(PlasticLocalization.Name.CreationDateColumn);
case ChangesetsListColumn.CreatedBy:
return PlasticLocalization.GetString(PlasticLocalization.Name.CreatedByColumn);
case ChangesetsListColumn.Comment:
return PlasticLocalization.GetString(PlasticLocalization.Name.CommentColumn);
case ChangesetsListColumn.Branch:
return PlasticLocalization.GetString(PlasticLocalization.Name.BranchColumn);
case ChangesetsListColumn.Repository:
return PlasticLocalization.GetString(PlasticLocalization.Name.RepositoryColumn);
case ChangesetsListColumn.Guid:
return PlasticLocalization.GetString(PlasticLocalization.Name.GuidColumn);
default:
return null;
}
}
void ISerializationCallbackReceiver.OnAfterDeserialize()
{
if (mHeaderTitles != null)
TreeHeaderColumns.SetTitles(columns, mHeaderTitles);
if (mColumnsAllowedToggleVisibility != null)
TreeHeaderColumns.SetVisibilities(columns, mColumnsAllowedToggleVisibility);
}
void ISerializationCallbackReceiver.OnBeforeSerialize()
{
}
static Column[] BuildColumns()
{
return new Column[]
{
new Column()
{
width = UnityConstants.ChangesetsColumns.CHANGESET_NUMBER_WIDTH,
minWidth = UnityConstants.ChangesetsColumns.CHANGESET_NUMBER_MIN_WIDTH,
headerContent = new GUIContent(
GetColumnName(ChangesetsListColumn.Name)),
allowToggleVisibility = false,
sortingArrowAlignment = TextAlignment.Right
},
new Column()
{
width = UnityConstants.ChangesetsColumns.CREATION_DATE_WIDTH,
minWidth = UnityConstants.ChangesetsColumns.CREATION_DATE_MIN_WIDTH,
headerContent = new GUIContent(
GetColumnName(ChangesetsListColumn.CreationDate)),
sortingArrowAlignment = TextAlignment.Right
},
new Column()
{
width = UnityConstants.ChangesetsColumns.CREATED_BY_WIDTH,
minWidth = UnityConstants.ChangesetsColumns.CREATED_BY_MIN_WIDTH,
headerContent = new GUIContent(
GetColumnName(ChangesetsListColumn.CreatedBy)),
sortingArrowAlignment = TextAlignment.Right
},
new Column()
{
width = UnityConstants.ChangesetsColumns.COMMENT_WIDTH,
minWidth = UnityConstants.ChangesetsColumns.COMMENT_MIN_WIDTH,
headerContent = new GUIContent(
GetColumnName(ChangesetsListColumn.Comment)),
sortingArrowAlignment = TextAlignment.Right
},
new Column()
{
width = UnityConstants.ChangesetsColumns.BRANCH_WIDTH,
minWidth = UnityConstants.ChangesetsColumns.BRANCH_MIN_WIDTH,
headerContent = new GUIContent(
GetColumnName(ChangesetsListColumn.Branch)),
sortingArrowAlignment = TextAlignment.Right
},
new Column()
{
width = UnityConstants.ChangesetsColumns.REPOSITORY_WIDTH,
minWidth = UnityConstants.ChangesetsColumns.REPOSITORY_MIN_WIDTH,
headerContent = new GUIContent(
GetColumnName(ChangesetsListColumn.Repository)),
sortingArrowAlignment = TextAlignment.Right
},
new Column()
{
width = UnityConstants.ChangesetsColumns.GUID_WIDTH,
minWidth = UnityConstants.ChangesetsColumns.GUID_MIN_WIDTH,
headerContent = new GUIContent(
GetColumnName(ChangesetsListColumn.Guid)),
sortingArrowAlignment = TextAlignment.Right,
}
};
}
ChangesetsListHeaderState(Column[] columns)
: base(columns)
{
if (mHeaderTitles == null)
mHeaderTitles = TreeHeaderColumns.GetTitles(columns);
if (mColumnsAllowedToggleVisibility == null)
mColumnsAllowedToggleVisibility = TreeHeaderColumns.GetVisibilities(columns);
}
[SerializeField]
string[] mHeaderTitles;
[SerializeField]
bool[] mColumnsAllowedToggleVisibility;
}
}

View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 7ff9581aa143f4d41b4e351881b8f459
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,419 @@
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using UnityEditor.IMGUI.Controls;
using Codice.CM.Common;
using PlasticGui;
using PlasticGui.WorkspaceWindow.QueryViews;
using Unity.PlasticSCM.Editor.UI;
using Unity.PlasticSCM.Editor.UI.Avatar;
using Unity.PlasticSCM.Editor.UI.Tree;
namespace Unity.PlasticSCM.Editor.Views.Changesets
{
internal class ChangesetsListView : PlasticTreeView
{
internal GenericMenu Menu { get { return mMenu.Menu; } }
internal ChangesetsListView(
ChangesetsListHeaderState headerState,
List<string> columnNames,
ChangesetsViewMenu menu,
Action sizeChangedAction,
Action selectionChangedAction,
Action doubleClickAction)
{
mColumnNames = columnNames;
mMenu = menu;
mSizeChangedAction = sizeChangedAction;
mSelectionChangedAction = selectionChangedAction;
mDoubleClickAction = doubleClickAction;
multiColumnHeader = new MultiColumnHeader(headerState);
multiColumnHeader.canSort = true;
multiColumnHeader.sortingChanged += SortingChanged;
mCooldownFilterAction = new CooldownWindowDelayer(
DelayedSearchChanged, UnityConstants.SEARCH_DELAYED_INPUT_ACTION_INTERVAL);
mCooldownSelectionAction = new CooldownWindowDelayer(
DelayedSelectionChanged, UnityConstants.SELECTION_DELAYED_INPUT_ACTION_INTERVAL);
}
protected override void SelectionChanged(IList<int> selectedIds)
{
mCooldownSelectionAction.Ping();
}
internal void SetLoadedChangesetId(long loadedChangesetId)
{
mLoadedChangesetId = loadedChangesetId;
}
protected override IList<TreeViewItem> BuildRows(
TreeViewItem rootItem)
{
if (mQueryResult == null)
{
ClearRows(rootItem, mRows);
return mRows;
}
RegenerateRows(
mListViewItemIds,
mQueryResult.GetObjects(),
rootItem, mRows);
return mRows;
}
protected override void SearchChanged(string newSearch)
{
mCooldownFilterAction.Ping();
}
protected override void ContextClickedItem(int id)
{
mMenu.Popup();
Repaint();
}
public override void OnGUI(Rect rect)
{
if (Event.current.type == EventType.Layout)
{
if (IsSizeChanged(treeViewRect, mLastRect))
mSizeChangedAction();
}
mLastRect = treeViewRect;
base.OnGUI(rect);
Event e = Event.current;
if (e.type != EventType.KeyDown)
return;
bool isProcessed = mMenu.ProcessKeyActionIfNeeded(e);
if (isProcessed)
e.Use();
}
protected override void RowGUI(RowGUIArgs args)
{
if (args.item is ChangesetListViewItem)
{
ChangesetListViewItem changesetListViewItem = (ChangesetListViewItem)args.item;
ChangesetInfo changesetInfo = (ChangesetInfo)changesetListViewItem.ObjectInfo;
ChangesetsListViewItemGUI(
mQueryResult,
rowHeight,
changesetListViewItem,
args,
changesetInfo.ChangesetId == mLoadedChangesetId,
Repaint);
return;
}
base.RowGUI(args);
}
protected override void DoubleClickedItem(int id)
{
if (GetSelection().Count != 1)
return;
mDoubleClickAction();
}
internal void BuildModel(
ViewQueryResult queryResult,
long loadedChangesetId)
{
mListViewItemIds.Clear();
mQueryResult = queryResult;
mLoadedChangesetId = loadedChangesetId;
}
internal void Refilter()
{
if (mQueryResult == null)
return;
Filter filter = new Filter(searchString);
mQueryResult.ApplyFilter(filter, mColumnNames);
}
internal void Sort()
{
if (mQueryResult == null)
return;
int sortedColumnIdx = multiColumnHeader.state.sortedColumnIndex;
bool sortAscending = multiColumnHeader.IsSortedAscending(sortedColumnIdx);
mQueryResult.Sort(
mColumnNames[sortedColumnIdx],
sortAscending);
}
internal List<RepositorySpec> GetSelectedRepositories()
{
List<RepositorySpec> result = new List<RepositorySpec>();
IList<int> selectedIds = GetSelection();
if (selectedIds.Count == 0)
return result;
foreach (KeyValuePair<object, int> item
in mListViewItemIds.GetInfoItems())
{
if (!selectedIds.Contains(item.Value))
continue;
RepositorySpec repSpec =
mQueryResult.GetRepositorySpec(item.Key);
result.Add(repSpec);
}
return result;
}
internal List<RepObjectInfo> GetSelectedRepObjectInfos()
{
List<RepObjectInfo> result = new List<RepObjectInfo>();
IList<int> selectedIds = GetSelection();
if (selectedIds.Count == 0)
return result;
foreach (KeyValuePair<object, int> item
in mListViewItemIds.GetInfoItems())
{
if (!selectedIds.Contains(item.Value))
continue;
RepObjectInfo repObjectInfo =
mQueryResult.GetRepObjectInfo(item.Key);
result.Add(repObjectInfo);
}
return result;
}
internal void SelectRepObjectInfos(
List<RepObjectInfo> repObjectsToSelect)
{
List<int> idsToSelect = new List<int>();
foreach (RepObjectInfo repObjectInfo in repObjectsToSelect)
{
int repObjectInfoId = GetTreeIdForItem(repObjectInfo);
if (repObjectInfoId == -1)
continue;
idsToSelect.Add(repObjectInfoId);
}
TableViewOperations.SetSelectionAndScroll(this, idsToSelect);
}
int GetTreeIdForItem(RepObjectInfo repObjectInfo)
{
foreach (KeyValuePair<object, int> item in mListViewItemIds.GetInfoItems())
{
RepObjectInfo currentRepObjectInfo =
mQueryResult.GetRepObjectInfo(item.Key);
if (!currentRepObjectInfo.Equals(repObjectInfo))
continue;
if (!currentRepObjectInfo.GUID.Equals(repObjectInfo.GUID))
continue;
return item.Value;
}
return -1;
}
void DelayedSearchChanged()
{
Refilter();
Sort();
Reload();
TableViewOperations.ScrollToSelection(this);
}
void DelayedSelectionChanged()
{
if (!HasSelection())
return;
mSelectionChangedAction();
}
void SortingChanged(MultiColumnHeader multiColumnHeader)
{
Sort();
Reload();
}
static void RegenerateRows(
ListViewItemIds<object> listViewItemIds,
List<object> objectInfos,
TreeViewItem rootItem,
List<TreeViewItem> rows)
{
ClearRows(rootItem, rows);
if (objectInfos.Count == 0)
return;
foreach (object objectInfo in objectInfos)
{
int objectId;
if (!listViewItemIds.TryGetInfoItemId(objectInfo, out objectId))
objectId = listViewItemIds.AddInfoItem(objectInfo);
ChangesetListViewItem changesetListViewItem =
new ChangesetListViewItem(objectId, objectInfo);
rootItem.AddChild(changesetListViewItem);
rows.Add(changesetListViewItem);
}
}
static void ClearRows(
TreeViewItem rootItem,
List<TreeViewItem> rows)
{
if (rootItem.hasChildren)
rootItem.children.Clear();
rows.Clear();
}
static void ChangesetsListViewItemGUI(
ViewQueryResult queryResult,
float rowHeight,
ChangesetListViewItem item,
RowGUIArgs args,
bool isBoldText,
Action avatarLoadedAction)
{
for (int visibleColumnIdx = 0; visibleColumnIdx < args.GetNumVisibleColumns(); visibleColumnIdx++)
{
Rect cellRect = args.GetCellRect(visibleColumnIdx);
if (visibleColumnIdx == 0)
{
cellRect.x += UnityConstants.FIRST_COLUMN_WITHOUT_ICON_INDENT;
cellRect.width -= UnityConstants.FIRST_COLUMN_WITHOUT_ICON_INDENT;
}
ChangesetsListColumn column =
(ChangesetsListColumn)args.GetColumn(visibleColumnIdx);
ChangesetsListViewItemCellGUI(
cellRect,
rowHeight,
queryResult,
item,
column,
avatarLoadedAction,
args.selected,
args.focused,
isBoldText);
}
}
static void ChangesetsListViewItemCellGUI(
Rect rect,
float rowHeight,
ViewQueryResult queryResult,
ChangesetListViewItem item,
ChangesetsListColumn column,
Action avatarLoadedAction,
bool isSelected,
bool isFocused,
bool isBoldText)
{
string columnText = RepObjectInfoView.GetColumnText(
queryResult.GetRepositorySpec(item.ObjectInfo),
queryResult.GetRepObjectInfo(item.ObjectInfo),
ChangesetsListHeaderState.GetColumnName(column));
if (column == ChangesetsListColumn.CreatedBy)
{
DrawTreeViewItem.ForItemCell(
rect,
rowHeight,
-1,
GetAvatar.ForEmail(columnText, avatarLoadedAction),
null,
columnText,
isSelected,
isFocused,
isBoldText,
false);
return;
}
if (column == ChangesetsListColumn.Branch ||
column == ChangesetsListColumn.Repository ||
column == ChangesetsListColumn.Guid)
{
DrawTreeViewItem.ForSecondaryLabel(
rect, columnText, isSelected, isFocused, isBoldText);
return;
}
DrawTreeViewItem.ForLabel(
rect, columnText, isSelected, isFocused, isBoldText);
}
static bool IsSizeChanged(
Rect currentRect, Rect lastRect)
{
if (currentRect.width != lastRect.width)
return true;
if (currentRect.height != lastRect.height)
return true;
return false;
}
Rect mLastRect;
ListViewItemIds<object> mListViewItemIds = new ListViewItemIds<object>();
ViewQueryResult mQueryResult;
long mLoadedChangesetId;
readonly CooldownWindowDelayer mCooldownFilterAction;
readonly CooldownWindowDelayer mCooldownSelectionAction;
readonly Action mDoubleClickAction;
readonly Action mSelectionChangedAction;
readonly Action mSizeChangedAction;
readonly ChangesetsViewMenu mMenu;
readonly List<string> mColumnNames;
}
}

View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 59e682a8b37338a46910fa9a939425e3
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,68 @@
using System.Collections.Generic;
using Codice.CM.Common;
using Unity.PlasticSCM.Editor.UI.Tree;
namespace Unity.PlasticSCM.Editor.Views.Changesets
{
internal static class ChangesetsSelection
{
internal static void SelectChangesets(
ChangesetsListView listView,
List<RepObjectInfo> csetsToSelect,
int defaultRow)
{
if (csetsToSelect == null || csetsToSelect.Count == 0)
{
TableViewOperations.SelectFirstRow(listView);
return;
}
listView.SelectRepObjectInfos(csetsToSelect);
if (listView.HasSelection())
return;
TableViewOperations.SelectDefaultRow(listView, defaultRow);
if (listView.HasSelection())
return;
TableViewOperations.SelectFirstRow(listView);
}
internal static List<RepObjectInfo> GetSelectedRepObjectInfos(
ChangesetsListView listView)
{
return listView.GetSelectedRepObjectInfos();
}
internal static int GetSelectedChangesetsCount(
ChangesetsListView listView)
{
return listView.GetSelection().Count;
}
internal static ChangesetExtendedInfo GetSelectedChangeset(
ChangesetsListView listView)
{
List<RepObjectInfo> selectedRepObjectsInfos = listView.GetSelectedRepObjectInfos();
if (selectedRepObjectsInfos.Count == 0)
return null;
return (ChangesetExtendedInfo)selectedRepObjectsInfos[0];
}
internal static RepositorySpec GetSelectedRepository(
ChangesetsListView listView)
{
List<RepositorySpec> selectedRepositories = listView.GetSelectedRepositories();
if (selectedRepositories.Count == 0)
return null;
return selectedRepositories[0];
}
}
}

View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 20341761c2011b441b2a3af227beeb71
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,664 @@
using System.Collections.Generic;
using UnityEditor;
using UnityEditor.IMGUI.Controls;
using UnityEngine;
using Codice.Client.Common;
using Codice.Client.Common.Threading;
using Codice.CM.Common;
using Codice.CM.Common.Mount;
using PlasticGui;
using PlasticGui.WorkspaceWindow;
using PlasticGui.WorkspaceWindow.Update;
using PlasticGui.WorkspaceWindow.QueryViews;
using PlasticGui.WorkspaceWindow.QueryViews.Changesets;
using GluonGui;
using PlasticGui.WorkspaceWindow.CodeReview;
using Unity.PlasticSCM.Editor.AssetUtils;
using Unity.PlasticSCM.Editor.AssetUtils.Processor;
using Unity.PlasticSCM.Editor.UI;
using Unity.PlasticSCM.Editor.UI.Progress;
using Unity.PlasticSCM.Editor.UI.Tree;
using Unity.PlasticSCM.Editor.Tool;
using Unity.PlasticSCM.Editor.Views.Diff;
using GluonNewIncomingChangesUpdater = PlasticGui.Gluon.WorkspaceWindow.NewIncomingChangesUpdater;
using IGluonUpdateReport = PlasticGui.Gluon.IUpdateReport;
namespace Unity.PlasticSCM.Editor.Views.Changesets
{
internal partial class ChangesetsTab :
IRefreshableView,
IChangesetMenuOperations,
ChangesetsViewMenu.IMenuOperations,
ILaunchCodeReviewWindow
{
internal ChangesetsListView Table { get { return mChangesetsListView; } }
internal IChangesetMenuOperations Operations { get { return this; } }
internal interface IRevertToChangesetListener
{
void OnSuccessOperation();
}
internal ChangesetsTab(
WorkspaceInfo wkInfo,
WorkspaceWindow workspaceWindow,
ChangesetInfo changesetToSelect,
IViewSwitcher viewSwitcher,
IMergeViewLauncher mergeViewLauncher,
IHistoryViewLauncher historyViewLauncher,
ViewHost viewHost,
IUpdateReport updateReport,
IGluonUpdateReport gluonUpdateReport,
NewIncomingChangesUpdater developerNewIncomingChangesUpdater,
GluonNewIncomingChangesUpdater gluonNewIncomingChangesUpdater,
IShelvedChangesUpdater shelvedChangesUpdater,
IRevertToChangesetListener revertToChangesetListener,
LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
LaunchTool.IProcessExecutor processExecutor,
WorkspaceOperationsMonitor workspaceOperationsMonitor,
ISaveAssets saveAssets,
EditorWindow parentWindow,
bool isGluonMode)
{
mWkInfo = wkInfo;
mViewHost = viewHost;
mWorkspaceWindow = workspaceWindow;
mViewSwitcher = viewSwitcher;
mRevertToChangesetListener = revertToChangesetListener;
mShowDownloadPlasticExeWindow = showDownloadPlasticExeWindow;
mProcessExecutor = processExecutor;
mWorkspaceOperationsMonitor = workspaceOperationsMonitor;
mSaveAssets = saveAssets;
mParentWindow = parentWindow;
mIsGluonMode = isGluonMode;
mGluonUpdateReport = gluonUpdateReport;
mGluonNewIncomingChangesUpdater = gluonNewIncomingChangesUpdater;
mShelvePendingChangesQuestionerBuilder = new ShelvePendingChangesQuestionerBuilder(parentWindow);
mShelvedChangesUpdater = shelvedChangesUpdater;
mEnableSwitchAndShelveFeatureDialog = new EnableSwitchAndShelveFeature(
PlasticGui.Plastic.API.GetRepositorySpec(mWkInfo),
mParentWindow);
BuildComponents(
wkInfo,
workspaceWindow,
workspaceWindow,
viewSwitcher,
historyViewLauncher,
parentWindow);
mProgressControls = new ProgressControlsForViews();
mSplitterState = PlasticSplitterGUILayout.InitSplitterState(
new float[] { 0.50f, 0.50f },
new int[] { 100, (int)UnityConstants.DIFF_PANEL_MIN_WIDTH },
new int[] { 100000, 100000 }
);
mChangesetOperations = new ChangesetOperations(
wkInfo,
workspaceWindow,
viewSwitcher,
mergeViewLauncher,
ViewType.ChangesetsView,
mProgressControls,
updateReport,
new ContinueWithPendingChangesQuestionerBuilder(viewSwitcher, parentWindow),
mShelvePendingChangesQuestionerBuilder,
new ApplyShelveWithConflictsQuestionerBuilder(),
developerNewIncomingChangesUpdater,
shelvedChangesUpdater,
null,
null,
mEnableSwitchAndShelveFeatureDialog);
RefreshAndSelect(changesetToSelect);
}
internal void OnEnable()
{
mDiffPanel.OnEnable();
mSearchField.downOrUpArrowKeyPressed +=
SearchField_OnDownOrUpArrowKeyPressed;
}
internal void OnDisable()
{
mDiffPanel.OnDisable();
mSearchField.downOrUpArrowKeyPressed -=
SearchField_OnDownOrUpArrowKeyPressed;
TreeHeaderSettings.Save(
mChangesetsListView.multiColumnHeader.state,
UnityConstants.CHANGESETS_TABLE_SETTINGS_NAME);
}
internal void Update()
{
mDiffPanel.Update();
mProgressControls.UpdateProgress(mParentWindow);
}
internal void OnGUI()
{
DoActionsToolbar(mProgressControls);
PlasticSplitterGUILayout.BeginHorizontalSplit(mSplitterState);
DoChangesetsArea(
mChangesetsListView,
mProgressControls.IsOperationRunning());
EditorGUILayout.BeginHorizontal();
Rect border = GUILayoutUtility.GetRect(1, 0, 1, 100000);
EditorGUI.DrawRect(border, UnityStyles.Colors.BarBorder);
DoChangesArea(mDiffPanel);
EditorGUILayout.EndHorizontal();
PlasticSplitterGUILayout.EndHorizontalSplit();
}
internal void DrawSearchFieldForTab()
{
DrawSearchField.For(
mSearchField,
mChangesetsListView,
UnityConstants.SEARCH_FIELD_WIDTH);
}
internal void DrawDateFilter()
{
GUI.enabled = !mProgressControls.IsOperationRunning();
EditorGUI.BeginChangeCheck();
mDateFilter.FilterType = (DateFilter.Type)
EditorGUILayout.EnumPopup(
mDateFilter.FilterType,
EditorStyles.toolbarDropDown,
GUILayout.Width(100));
if (EditorGUI.EndChangeCheck())
{
EnumPopupSetting<DateFilter.Type>.Save(
mDateFilter.FilterType,
UnityConstants.CHANGESETS_DATE_FILTER_SETTING_NAME);
((IRefreshableView)this).Refresh();
}
GUI.enabled = true;
}
internal void SetWorkingObjectInfo(WorkingObjectInfo homeInfo)
{
if (mIsGluonMode)
return;
lock (mLock)
{
mLoadedChangesetId = homeInfo.GetChangesetId();
}
mChangesetsListView.SetLoadedChangesetId(mLoadedChangesetId);
mChangesetsViewMenu.SetLoadedBranchId(homeInfo.BranchInfo.BranchId);
}
internal void SetRevertToChangesetOperationInterfacesForTesting(
RevertToChangesetOperation.IGetStatusForWorkspace getStatusForWorkspace,
RevertToChangesetOperation.IUndoCheckoutOperation undoCheckoutOperation,
RevertToChangesetOperation.IRevertToChangesetMergeController revertToChangesetMergeController)
{
mGetStatusForWorkspace = getStatusForWorkspace;
mUndoCheckoutOperation = undoCheckoutOperation;
mRevertToChangesetMergeController = revertToChangesetMergeController;
}
internal void SetLaunchToolForTesting(
LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
LaunchTool.IProcessExecutor processExecutor)
{
mShowDownloadPlasticExeWindow = showDownloadPlasticExeWindow;
mProcessExecutor = processExecutor;
}
internal void RefreshAndSelect(RepObjectInfo repObj)
{
List<RepObjectInfo> changesetsToSelect = repObj == null ?
ChangesetsSelection.GetSelectedRepObjectInfos(mChangesetsListView) :
new List<RepObjectInfo> { repObj };
string query = GetChangesetsQuery(mDateFilter);
FillChangesets(
mWkInfo,
query,
changesetsToSelect);
}
void IRefreshableView.Refresh()
{
RefreshAndSelect(null);
}
int IChangesetMenuOperations.GetSelectedChangesetsCount()
{
return ChangesetsSelection.GetSelectedChangesetsCount(mChangesetsListView);
}
void IChangesetMenuOperations.DiffChangeset()
{
LaunchDiffOperations.DiffChangeset(
mShowDownloadPlasticExeWindow,
mProcessExecutor,
ChangesetsSelection.GetSelectedRepository(mChangesetsListView),
ChangesetsSelection.GetSelectedChangeset(mChangesetsListView),
mIsGluonMode);
}
void IChangesetMenuOperations.DiffSelectedChangesets()
{
List<RepObjectInfo> selectedChangesets = ChangesetsSelection.
GetSelectedRepObjectInfos(mChangesetsListView);
if (selectedChangesets.Count < 2)
return;
LaunchDiffOperations.DiffSelectedChangesets(
mShowDownloadPlasticExeWindow,
mProcessExecutor,
ChangesetsSelection.GetSelectedRepository(mChangesetsListView),
(ChangesetExtendedInfo)selectedChangesets[0],
(ChangesetExtendedInfo)selectedChangesets[1],
mIsGluonMode);
}
void IChangesetMenuOperations.SwitchToChangeset()
{
SwitchToChangesetForMode();
}
void IChangesetMenuOperations.DiffWithAnotherChangeset() { }
void IChangesetMenuOperations.CreateBranch()
{
CreateBranchForMode();
}
void IChangesetMenuOperations.LabelChangeset() { }
void IChangesetMenuOperations.MergeChangeset()
{
mChangesetOperations.MergeChangeset(
ChangesetsSelection.GetSelectedRepository(mChangesetsListView),
ChangesetsSelection.GetSelectedChangeset(mChangesetsListView));
}
void IChangesetMenuOperations.CherryPickChangeset() { }
void IChangesetMenuOperations.SubtractiveChangeset() { }
void IChangesetMenuOperations.SubtractiveChangesetInterval() { }
void IChangesetMenuOperations.CherryPickChangesetInterval() { }
void IChangesetMenuOperations.MergeToChangeset() { }
void IChangesetMenuOperations.MoveChangeset() { }
void IChangesetMenuOperations.DeleteChangeset() { }
void IChangesetMenuOperations.BrowseRepositoryOnChangeset() { }
void IChangesetMenuOperations.CreateCodeReview()
{
RepositorySpec repSpec = ChangesetsSelection.GetSelectedRepository(mChangesetsListView);
ChangesetInfo changesetInfo = ChangesetsSelection.GetSelectedChangeset(mChangesetsListView);
NewCodeReviewBehavior choice = SelectNewCodeReviewBehavior.For(repSpec.Server);
switch (choice)
{
case NewCodeReviewBehavior.CreateAndOpenInDesktop:
mChangesetOperations.CreateCodeReview(repSpec, changesetInfo, this);
break;
case NewCodeReviewBehavior.RequestFromUnityCloud:
OpenRequestReviewPage.ForChangeset(repSpec, changesetInfo.ChangesetId);
break;
case NewCodeReviewBehavior.Ask:
default:
break;
}
}
void ILaunchCodeReviewWindow.Show(
WorkspaceInfo wkInfo,
RepositorySpec repSpec,
ReviewInfo reviewInfo,
RepObjectInfo repObjectInfo,
bool bShowReviewChangesTab)
{
LaunchTool.OpenCodeReview(
mShowDownloadPlasticExeWindow,
mProcessExecutor,
repSpec,
reviewInfo.Id,
mIsGluonMode);
}
void IChangesetMenuOperations.RevertToChangeset()
{
if (((IChangesetMenuOperations)this).GetSelectedChangesetsCount() != 1)
return;
ChangesetExtendedInfo targetChangesetInfo = ((ChangesetsViewMenu.IMenuOperations)this).GetSelectedChangeset();
RevertToChangesetOperation.RevertTo(
mWkInfo,
mViewSwitcher,
mWorkspaceWindow,
mProgressControls,
mGetStatusForWorkspace,
mUndoCheckoutOperation,
mRevertToChangesetMergeController,
GuiMessage.Get(),
targetChangesetInfo,
RefreshAsset.BeforeLongAssetOperation,
RefreshAsset.AfterLongAssetOperation,
mRevertToChangesetListener.OnSuccessOperation);
}
void ChangesetsViewMenu.IMenuOperations.DiffBranch()
{
LaunchDiffOperations.DiffBranch(
mShowDownloadPlasticExeWindow,
mProcessExecutor,
ChangesetsSelection.GetSelectedRepository(mChangesetsListView),
ChangesetsSelection.GetSelectedChangeset(mChangesetsListView),
mIsGluonMode);
}
ChangesetExtendedInfo ChangesetsViewMenu.IMenuOperations.GetSelectedChangeset()
{
return ChangesetsSelection.GetSelectedChangeset(
mChangesetsListView);
}
void SearchField_OnDownOrUpArrowKeyPressed()
{
mChangesetsListView.SetFocusAndEnsureSelectedItem();
}
void OnChangesetsListViewSizeChanged()
{
if (!mShouldScrollToSelection)
return;
mShouldScrollToSelection = false;
TableViewOperations.ScrollToSelection(mChangesetsListView);
}
void OnSelectionChanged()
{
List<RepObjectInfo> selectedChangesets = ChangesetsSelection.
GetSelectedRepObjectInfos(mChangesetsListView);
if (selectedChangesets.Count != 1)
return;
mDiffPanel.UpdateInfo(
MountPointWithPath.BuildWorkspaceRootMountPoint(
ChangesetsSelection.GetSelectedRepository(mChangesetsListView)),
(ChangesetExtendedInfo)selectedChangesets[0]);
}
void FillChangesets(
WorkspaceInfo wkInfo,
string query,
List<RepObjectInfo> changesetsToSelect)
{
if (mIsRefreshing)
return;
mIsRefreshing = true;
int defaultRow = TableViewOperations.GetFirstSelectedRow(mChangesetsListView);
((IProgressControls)mProgressControls).ShowProgress(
PlasticLocalization.GetString(
PlasticLocalization.Name.LoadingChangesets));
ViewQueryResult queryResult = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter();
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
queryResult = new ViewQueryResult(
PlasticGui.Plastic.API.FindQuery(wkInfo, query));
long changesetId = PlasticGui.Plastic.API.GetLoadedChangeset(wkInfo);
lock (mLock)
{
mLoadedChangesetId = changesetId;
}
BranchInfo currentBranch = PlasticGui.Plastic.API.GetWorkingBranch(wkInfo);
if (currentBranch != null)
mChangesetsViewMenu.SetLoadedBranchId(currentBranch.BranchId);
},
/*afterOperationDelegate*/ delegate
{
try
{
if (waiter.Exception != null)
{
mDiffPanel.ClearInfo();
ExceptionsHandler.DisplayException(waiter.Exception);
return;
}
UpdateChangesetsList(
mChangesetsListView,
queryResult,
mLoadedChangesetId);
int changesetsCount = GetChangesetsCount(queryResult);
if (changesetsCount == 0)
{
mDiffPanel.ClearInfo();
return;
}
ChangesetsSelection.SelectChangesets(
mChangesetsListView, changesetsToSelect, defaultRow);
}
finally
{
((IProgressControls)mProgressControls).HideProgress();
mIsRefreshing = false;
}
});
}
static void UpdateChangesetsList(
ChangesetsListView changesetsListView,
ViewQueryResult queryResult,
long loadedChangesetId)
{
changesetsListView.BuildModel(
queryResult,
loadedChangesetId);
changesetsListView.Refilter();
changesetsListView.Sort();
changesetsListView.Reload();
}
static int GetChangesetsCount(
ViewQueryResult queryResult)
{
if (queryResult == null)
return 0;
return queryResult.Count();
}
static string GetChangesetsQuery(DateFilter dateFilter)
{
if (dateFilter.FilterType == DateFilter.Type.AllTime)
return QueryConstants.ChangesetsBeginningQuery;
string whereClause = QueryConstants.GetDateWhereClause(
dateFilter.GetTimeAgo());
return string.Format("{0} {1}",
QueryConstants.ChangesetsBeginningQuery,
whereClause);
}
void DoActionsToolbar(ProgressControlsForViews progressControls)
{
EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);
if (progressControls.IsOperationRunning())
{
DrawProgressForViews.ForIndeterminateProgress(
progressControls.ProgressData);
}
GUILayout.FlexibleSpace();
GUILayout.Space(2);
EditorGUILayout.EndHorizontal();
}
static void DoChangesetsArea(
ChangesetsListView changesetsListView,
bool isOperationRunning)
{
EditorGUILayout.BeginVertical();
GUI.enabled = !isOperationRunning;
Rect rect = GUILayoutUtility.GetRect(0, 100000, 0, 100000);
changesetsListView.OnGUI(rect);
GUI.enabled = true;
EditorGUILayout.EndVertical();
}
static void DoChangesArea(DiffPanel diffPanel)
{
EditorGUILayout.BeginVertical();
diffPanel.OnGUI();
EditorGUILayout.EndVertical();
}
void BuildComponents(
WorkspaceInfo wkInfo,
IWorkspaceWindow workspaceWindow,
IRefreshView refreshView,
IViewSwitcher viewSwitcher,
IHistoryViewLauncher historyViewLauncher,
EditorWindow parentWindow)
{
mSearchField = new SearchField();
mSearchField.downOrUpArrowKeyPressed += SearchField_OnDownOrUpArrowKeyPressed;
DateFilter.Type dateFilterType =
EnumPopupSetting<DateFilter.Type>.Load(
UnityConstants.CHANGESETS_DATE_FILTER_SETTING_NAME,
DateFilter.Type.LastMonth);
mDateFilter = new DateFilter(dateFilterType);
ChangesetsListHeaderState headerState =
ChangesetsListHeaderState.GetDefault();
TreeHeaderSettings.Load(headerState,
UnityConstants.CHANGESETS_TABLE_SETTINGS_NAME,
(int)ChangesetsListColumn.CreationDate, false);
mChangesetsViewMenu = new ChangesetsViewMenu(
this,
this,
mIsGluonMode);
mChangesetsListView = new ChangesetsListView(
headerState,
ChangesetsListHeaderState.GetColumnNames(),
mChangesetsViewMenu,
sizeChangedAction: OnChangesetsListViewSizeChanged,
selectionChangedAction: OnSelectionChanged,
doubleClickAction: ((IChangesetMenuOperations)this).DiffChangeset);
mChangesetsListView.Reload();
mDiffPanel = new DiffPanel(
wkInfo, workspaceWindow, refreshView, viewSwitcher,
historyViewLauncher, mShowDownloadPlasticExeWindow,
parentWindow, mIsGluonMode);
}
bool mIsRefreshing;
bool mShouldScrollToSelection;
long mLoadedChangesetId = -1;
object mSplitterState;
object mLock = new object();
DateFilter mDateFilter;
SearchField mSearchField;
ChangesetsListView mChangesetsListView;
ChangesetsViewMenu mChangesetsViewMenu;
DiffPanel mDiffPanel;
RevertToChangesetOperation.IGetStatusForWorkspace mGetStatusForWorkspace =
new RevertToChangesetOperation.GetStatusFromWorkspace();
RevertToChangesetOperation.IUndoCheckoutOperation mUndoCheckoutOperation =
new RevertToChangesetOperation.UndoCheckout();
RevertToChangesetOperation.IRevertToChangesetMergeController mRevertToChangesetMergeController =
new RevertToChangesetOperation.RevertToChangesetMergeController();
ChangesetOperations mChangesetOperations;
LaunchTool.IProcessExecutor mProcessExecutor;
LaunchTool.IShowDownloadPlasticExeWindow mShowDownloadPlasticExeWindow;
readonly WorkspaceOperationsMonitor mWorkspaceOperationsMonitor;
readonly ISaveAssets mSaveAssets;
readonly bool mIsGluonMode;
readonly ViewHost mViewHost;
readonly IGluonUpdateReport mGluonUpdateReport;
readonly WorkspaceWindow mWorkspaceWindow;
readonly IViewSwitcher mViewSwitcher;
readonly ProgressControlsForViews mProgressControls;
readonly IRevertToChangesetListener mRevertToChangesetListener;
readonly EditorWindow mParentWindow;
readonly WorkspaceInfo mWkInfo;
readonly GluonNewIncomingChangesUpdater mGluonNewIncomingChangesUpdater;
readonly IShelvePendingChangesQuestionerBuilder mShelvePendingChangesQuestionerBuilder;
readonly IShelvedChangesUpdater mShelvedChangesUpdater;
readonly SwitchAndShelve.IEnableSwitchAndShelveFeatureDialog mEnableSwitchAndShelveFeatureDialog;
}
}

View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 471badd5c87fb154885f11cdf1b49a00
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,122 @@
using Codice.CM.Common;
using Codice.CM.Common.Selectors;
using GluonGui.WorkspaceWindow.Views.WorkspaceExplorer.Explorer;
using PlasticGui.WorkspaceWindow.QueryViews.Branches;
using Unity.PlasticSCM.Editor.AssetUtils;
using Unity.PlasticSCM.Editor.UI;
using Unity.PlasticSCM.Editor.Views.Branches.Dialogs;
namespace Unity.PlasticSCM.Editor.Views.Changesets
{
internal partial class ChangesetsTab
{
void SwitchToChangesetForMode()
{
bool isCancelled;
mSaveAssets.UnderWorkspaceWithConfirmation(
mWkInfo.ClientPath, mWorkspaceOperationsMonitor,
out isCancelled);
if (isCancelled)
return;
if (mIsGluonMode)
{
SwitchToChangesetForGluon();
return;
}
SwitchToChangesetForDeveloper();
}
void SwitchToChangesetForDeveloper()
{
mChangesetOperations.SwitchToChangeset(
ChangesetsSelection.GetSelectedRepository(mChangesetsListView),
ChangesetsSelection.GetSelectedChangeset(mChangesetsListView),
RefreshAsset.BeforeLongAssetOperation,
items => RefreshAsset.AfterLongAssetOperation(
ProjectPackages.ShouldBeResolvedFromUpdateReport(mWkInfo, items)));
}
void SwitchToChangesetForGluon()
{
ChangesetExtendedInfo csetInfo = ChangesetsSelection.GetSelectedChangeset(mChangesetsListView);
new SwitchToUIOperation().SwitchToChangeset(
mWkInfo,
PlasticGui.Plastic.API.GetRepositorySpec(mWkInfo),
csetInfo.BranchName,
csetInfo.ChangesetId,
mViewHost,
mGluonNewIncomingChangesUpdater,
new UnityPlasticGuiMessage(),
mProgressControls,
mWorkspaceWindow.GluonProgressOperationHandler,
mGluonUpdateReport,
mWorkspaceWindow,
mShelvePendingChangesQuestionerBuilder,
mShelvedChangesUpdater,
mEnableSwitchAndShelveFeatureDialog,
RefreshAsset.BeforeLongAssetOperation,
items => RefreshAsset.AfterLongAssetOperation(
ProjectPackages.ShouldBeResolvedFromPaths(mWkInfo, items)));
}
void CreateBranchForMode()
{
if (mIsGluonMode)
{
CreateBranchForGluon();
return;
}
CreateBranchForDeveloper();
}
void CreateBranchForDeveloper()
{
RepositorySpec repSpec = ChangesetsSelection.GetSelectedRepository(mChangesetsListView);
ChangesetExtendedInfo csetInfo = ChangesetsSelection.GetSelectedChangeset(mChangesetsListView);
BranchCreationData branchCreationData = CreateBranchDialog.CreateBranchFromChangeset(
mParentWindow,
repSpec,
csetInfo);
mChangesetOperations.CreateBranch(
branchCreationData,
RefreshAsset.BeforeLongAssetOperation,
items => RefreshAsset.AfterLongAssetOperation(
ProjectPackages.ShouldBeResolvedFromUpdateReport(mWkInfo, items)));
}
void CreateBranchForGluon()
{
RepositorySpec repSpec = ChangesetsSelection.GetSelectedRepository(mChangesetsListView);
ChangesetExtendedInfo csetInfo = ChangesetsSelection.GetSelectedChangeset(mChangesetsListView);
BranchCreationData branchCreationData = CreateBranchDialog.CreateBranchFromChangeset(
mParentWindow,
repSpec,
csetInfo);
CreateBranchOperation.CreateBranch(
mWkInfo,
branchCreationData,
mViewHost,
mGluonNewIncomingChangesUpdater,
new UnityPlasticGuiMessage(),
mProgressControls,
mWorkspaceWindow.GluonProgressOperationHandler,
mGluonUpdateReport,
mWorkspaceWindow,
mShelvePendingChangesQuestionerBuilder,
mShelvedChangesUpdater,
mEnableSwitchAndShelveFeatureDialog,
RefreshAsset.BeforeLongAssetOperation,
items => RefreshAsset.AfterLongAssetOperation(
ProjectPackages.ShouldBeResolvedFromPaths(mWkInfo, items)));
}
}
}

View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 06e8f2c592322e640ae99a833427b552
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,354 @@
using UnityEditor;
using UnityEngine;
using Codice.CM.Common;
using PlasticGui.WorkspaceWindow.QueryViews.Changesets;
using PlasticGui;
using Unity.PlasticSCM.Editor.Tool;
using Unity.PlasticSCM.Editor.UI;
namespace Unity.PlasticSCM.Editor.Views.Changesets
{
internal class ChangesetsViewMenu
{
internal GenericMenu Menu { get { return mMenu; } }
public interface IMenuOperations
{
void DiffBranch();
ChangesetExtendedInfo GetSelectedChangeset();
}
internal ChangesetsViewMenu(
IChangesetMenuOperations changesetMenuOperations,
IMenuOperations menuOperations,
bool isGluonMode)
{
mChangesetMenuOperations = changesetMenuOperations;
mMenuOperations = menuOperations;
mIsGluonMode = isGluonMode;
BuildComponents();
}
internal void Popup()
{
mMenu = new GenericMenu();
UpdateMenuItems(mMenu);
mMenu.ShowAsContext();
}
internal bool ProcessKeyActionIfNeeded(Event e)
{
int selectedChangesetsCount = mChangesetMenuOperations.GetSelectedChangesetsCount();
ChangesetMenuOperations operationToExecute = GetMenuOperations(
e, selectedChangesetsCount > 1);
if (operationToExecute == ChangesetMenuOperations.None)
return false;
ChangesetMenuOperations operations = ChangesetMenuUpdater.GetAvailableMenuOperations(
selectedChangesetsCount,
mIsGluonMode,
mMenuOperations.GetSelectedChangeset().BranchId,
mLoadedBranchId,
false);
if (!operations.HasFlag(operationToExecute))
return false;
ProcessMenuOperation(operationToExecute);
return true;
}
internal void SetLoadedBranchId(long loadedBranchId)
{
mLoadedBranchId = loadedBranchId;
}
void DiffChangesetMenuItem_Click()
{
mChangesetMenuOperations.DiffChangeset();
}
void DiffSelectedChangesetsMenuItem_Click()
{
mChangesetMenuOperations.DiffSelectedChangesets();
}
void RevertToChangesetMenuItem_Click()
{
mChangesetMenuOperations.RevertToChangeset();
}
void DiffBranchMenuItem_Click()
{
mMenuOperations.DiffBranch();
}
void CreateBranchFromChangesetMenuItem_Click()
{
mChangesetMenuOperations.CreateBranch();
}
void SwitchToChangesetMenuItem_Click()
{
mChangesetMenuOperations.SwitchToChangeset();
}
void MergeChangesetMenuItem_Click()
{
mChangesetMenuOperations.MergeChangeset();
}
void CreateCodeReviewMenuItem_Click()
{
mChangesetMenuOperations.CreateCodeReview();
}
void UpdateMenuItems(GenericMenu menu)
{
ChangesetExtendedInfo singleSelectedChangeset = mMenuOperations.GetSelectedChangeset();
ChangesetMenuOperations operations = ChangesetMenuUpdater.GetAvailableMenuOperations(
mChangesetMenuOperations.GetSelectedChangesetsCount(),
mIsGluonMode,
singleSelectedChangeset.BranchId,
mLoadedBranchId,
false);
AddDiffChangesetMenuItem(
mDiffChangesetMenuItemContent,
menu,
singleSelectedChangeset,
operations,
DiffChangesetMenuItem_Click);
AddChangesetsMenuItem(
mDiffSelectedChangesetsMenuItemContent,
menu,
operations,
ChangesetMenuOperations.DiffSelectedChangesets,
DiffSelectedChangesetsMenuItem_Click);
if (!IsOnMainBranch(singleSelectedChangeset))
{
menu.AddSeparator(string.Empty);
AddDiffBranchMenuItem(
mDiffBranchMenuItemContent,
menu,
singleSelectedChangeset,
operations,
DiffBranchMenuItem_Click);
}
menu.AddSeparator(string.Empty);
AddChangesetsMenuItem(
mCreateBranchMenuItemContent,
menu,
operations,
ChangesetMenuOperations.CreateBranch,
CreateBranchFromChangesetMenuItem_Click);
AddChangesetsMenuItem(
mSwitchToChangesetMenuItemContent,
menu,
operations,
ChangesetMenuOperations.SwitchToChangeset,
SwitchToChangesetMenuItem_Click);
if (!mIsGluonMode)
{
AddChangesetsMenuItem(
mRevertToChangesetMenuItemContent,
menu,
operations,
ChangesetMenuOperations.RevertToChangeset,
RevertToChangesetMenuItem_Click);
menu.AddSeparator(string.Empty);
AddChangesetsMenuItem(
mMergeChangesetMenuItemContent,
menu,
operations,
ChangesetMenuOperations.MergeChangeset,
MergeChangesetMenuItem_Click);
}
menu.AddSeparator(string.Empty);
AddChangesetsMenuItem(
mCreateCodeReviewMenuItemContent,
menu,
operations,
ChangesetMenuOperations.CreateCodeReview,
CreateCodeReviewMenuItem_Click);
}
void ProcessMenuOperation(
ChangesetMenuOperations operationToExecute)
{
if (operationToExecute == ChangesetMenuOperations.DiffChangeset)
{
DiffChangesetMenuItem_Click();
return;
}
if (operationToExecute == ChangesetMenuOperations.DiffSelectedChangesets)
{
DiffSelectedChangesetsMenuItem_Click();
return;
}
if (operationToExecute == ChangesetMenuOperations.MergeChangeset)
{
MergeChangesetMenuItem_Click();
return;
}
}
static void AddChangesetsMenuItem(
GUIContent menuItemContent,
GenericMenu menu,
ChangesetMenuOperations operations,
ChangesetMenuOperations operationsToCheck,
GenericMenu.MenuFunction menuFunction)
{
if (operations.HasFlag(operationsToCheck))
{
menu.AddItem(
menuItemContent,
false,
menuFunction);
return;
}
menu.AddDisabledItem(menuItemContent);
}
static void AddDiffChangesetMenuItem(
GUIContent menuItemContent,
GenericMenu menu,
ChangesetExtendedInfo changeset,
ChangesetMenuOperations operations,
GenericMenu.MenuFunction menuFunction)
{
string changesetName =
changeset != null ?
changeset.ChangesetId.ToString() :
string.Empty;
menuItemContent.text = string.Format("{0} {1}",
PlasticLocalization.GetString(
PlasticLocalization.Name.DiffChangesetMenuItem,
changesetName),
GetPlasticShortcut.ForDiff());
if (operations.HasFlag(ChangesetMenuOperations.DiffChangeset))
{
menu.AddItem(
menuItemContent,
false,
menuFunction);
return;
}
menu.AddDisabledItem(
menuItemContent);
}
static void AddDiffBranchMenuItem(
GUIContent menuItemContent,
GenericMenu menu,
ChangesetExtendedInfo changeset,
ChangesetMenuOperations operations,
GenericMenu.MenuFunction menuFunction)
{
menuItemContent.text =
PlasticLocalization.Name.DiffBranchMenuItem.GetString(
GetShorten.BranchNameFromChangeset(changeset));
if (operations.HasFlag(ChangesetMenuOperations.DiffChangeset))
{
menu.AddItem(
menuItemContent,
false,
menuFunction);
return;
}
menu.AddDisabledItem(
menuItemContent);
}
static bool IsOnMainBranch(ChangesetExtendedInfo singleSeletedChangeset)
{
if (singleSeletedChangeset == null)
return false;
return singleSeletedChangeset.BranchName == MAIN_BRANCH_NAME;
}
static ChangesetMenuOperations GetMenuOperations(
Event e, bool isMultipleSelection)
{
if (Keyboard.IsControlOrCommandKeyPressed(e) &&
Keyboard.IsKeyPressed(e, KeyCode.D))
return isMultipleSelection ?
ChangesetMenuOperations.DiffSelectedChangesets :
ChangesetMenuOperations.DiffChangeset;
if (Keyboard.IsControlOrCommandKeyPressed(e) &&
Keyboard.IsKeyPressed(e, KeyCode.M))
return ChangesetMenuOperations.MergeChangeset;
return ChangesetMenuOperations.None;
}
void BuildComponents()
{
mDiffChangesetMenuItemContent = new GUIContent(string.Empty);
mDiffSelectedChangesetsMenuItemContent = new GUIContent(string.Format("{0} {1}",
PlasticLocalization.GetString(PlasticLocalization.Name.ChangesetMenuItemDiffSelected),
GetPlasticShortcut.ForDiff()));
mDiffBranchMenuItemContent = new GUIContent();
mCreateBranchMenuItemContent = new GUIContent(
PlasticLocalization.GetString(PlasticLocalization.Name.ChangesetMenuItemCreateBranch));
mSwitchToChangesetMenuItemContent = new GUIContent(
PlasticLocalization.GetString(PlasticLocalization.Name.ChangesetMenuItemSwitchToChangeset));
mRevertToChangesetMenuItemContent = new GUIContent(
PlasticLocalization.GetString(PlasticLocalization.Name.ChangesetMenuItemRevertToChangeset));
mMergeChangesetMenuItemContent = new GUIContent(string.Format("{0} {1}",
PlasticLocalization.GetString(PlasticLocalization.Name.ChangesetMenuItemMergeFromChangeset),
GetPlasticShortcut.ForMerge()));
mCreateCodeReviewMenuItemContent = new GUIContent(
PlasticLocalization.Name.ChangesetMenuCreateANewCodeReview.GetString());
}
GenericMenu mMenu;
GUIContent mDiffChangesetMenuItemContent;
GUIContent mDiffSelectedChangesetsMenuItemContent;
GUIContent mDiffBranchMenuItemContent;
GUIContent mCreateBranchMenuItemContent;
GUIContent mSwitchToChangesetMenuItemContent;
GUIContent mRevertToChangesetMenuItemContent;
GUIContent mMergeChangesetMenuItemContent;
GUIContent mCreateCodeReviewMenuItemContent;
readonly IChangesetMenuOperations mChangesetMenuOperations;
readonly IMenuOperations mMenuOperations;
readonly bool mIsGluonMode;
long mLoadedBranchId = -1;
const string MAIN_BRANCH_NAME = "/main";
}
}

View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 397f62458d0ad3441aaaa1a738bd4f94
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,69 @@
using PlasticGui.WorkspaceWindow.QueryViews;
using LayoutFilters = Codice.Client.BaseCommands.LayoutFilters;
namespace Unity.PlasticSCM.Editor.Views.Changesets
{
internal class DateFilter
{
internal enum Type
{
LastWeek,
Last15Days,
LastMonth,
Last3Months,
LastYear,
AllTime
}
internal Type FilterType;
internal DateFilter(Type filterType)
{
FilterType = filterType;
}
internal LayoutFilters.DateFilter GetLayoutFilter()
{
switch (FilterType)
{
case Type.LastWeek:
return LayoutFilters.DateFilter.BuildFromTimeAgo(
LayoutFilters.SinceTimeType.OneWeekAgo);
case Type.Last15Days:
return LayoutFilters.DateFilter.BuildFromTimeAgo(
LayoutFilters.SinceTimeType.FifteenDaysAgo);
case Type.LastMonth:
return LayoutFilters.DateFilter.BuildFromTimeAgo(
LayoutFilters.SinceTimeType.OneMonthAgo);
case Type.Last3Months:
return LayoutFilters.DateFilter.BuildFromTimeAgo(
LayoutFilters.SinceTimeType.ThreeMonthsAgo);
case Type.LastYear:
return LayoutFilters.DateFilter.BuildFromTimeAgo(
LayoutFilters.SinceTimeType.OneYearAgo);
}
return null;
}
internal string GetTimeAgo()
{
switch (FilterType)
{
case Type.LastWeek:
return QueryConstants.OneWeekAgo;
case Type.Last15Days:
return QueryConstants.HalfMonthAgo;
case Type.LastMonth:
return QueryConstants.OneMonthAgo;
case Type.Last3Months:
return QueryConstants.ThreeMonthsAgo;
case Type.LastYear:
return QueryConstants.OneYearAgo;
}
return string.Empty;
}
}
}

View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 3a4d62c64067bca4cbbd6f7fcad2e190
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,167 @@
using Codice.CM.Common;
using Unity.PlasticSCM.Editor.Tool;
namespace Unity.PlasticSCM.Editor.Views.Changesets
{
static class LaunchDiffOperations
{
internal static void DiffChangeset(
LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
LaunchTool.IProcessExecutor processExecutor,
RepositorySpec repSpec,
long changesetId,
bool isGluonMode)
{
if (changesetId == -1)
return;
string changesetFullSpec = GetChangesetFullSpec(
repSpec, changesetId);
LaunchTool.OpenChangesetDiffs(
showDownloadPlasticExeWindow,
processExecutor,
repSpec,
changesetFullSpec,
isGluonMode);
}
internal static void DiffChangeset(
LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
LaunchTool.IProcessExecutor processExecutor,
RepositorySpec repSpec,
ChangesetInfo changesetInfo,
bool isGluonMode)
{
if (changesetInfo == null)
return;
string changesetFullSpec = GetChangesetFullSpec(
repSpec, changesetInfo.ChangesetId);
LaunchTool.OpenChangesetDiffs(
showDownloadPlasticExeWindow,
processExecutor,
repSpec,
changesetFullSpec,
isGluonMode);
}
internal static void DiffSelectedChangesets(
LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
LaunchTool.IProcessExecutor processExecutor,
RepositorySpec repSpec,
ChangesetInfo cset1,
ChangesetInfo cset2,
bool isGluonMode)
{
ChangesetInfo srcChangesetInfo;
ChangesetInfo dstChangesetInfo;
GetSrcAndDstCangesets(
cset1,
cset2,
out srcChangesetInfo,
out dstChangesetInfo);
string srcChangesetFullSpec = GetChangesetFullSpec(
repSpec, srcChangesetInfo.ChangesetId);
string dstChangesetFullSpec = GetChangesetFullSpec(
repSpec, dstChangesetInfo.ChangesetId);
LaunchTool.OpenSelectedChangesetsDiffs(
showDownloadPlasticExeWindow,
processExecutor,
repSpec,
srcChangesetFullSpec,
dstChangesetFullSpec,
isGluonMode);
}
internal static void DiffBranch(
LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
LaunchTool.IProcessExecutor processExecutor,
RepositorySpec repSpec,
BranchInfo branchInfo,
bool isGluonMode)
{
if (branchInfo == null)
return;
string branchFullSpec = GetBranchFullSpec(
repSpec, branchInfo);
LaunchTool.OpenBranchDiffs(
showDownloadPlasticExeWindow,
processExecutor,
repSpec,
branchFullSpec,
isGluonMode);
}
internal static void DiffBranch(
LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
LaunchTool.IProcessExecutor processExecutor,
RepositorySpec repSpec,
ChangesetExtendedInfo changesetExtendedInfo,
bool isGluonMode)
{
if (changesetExtendedInfo == null)
return;
string branchFullSpec = GetBranchFullSpec(
repSpec, changesetExtendedInfo);
LaunchTool.OpenBranchDiffs(
showDownloadPlasticExeWindow,
processExecutor,
repSpec,
branchFullSpec,
isGluonMode);
}
static void GetSrcAndDstCangesets(
ChangesetInfo cset1,
ChangesetInfo cset2,
out ChangesetInfo srcChangesetInfo,
out ChangesetInfo dstChangesetInfo)
{
if (cset1.LocalTimeStamp < cset2.LocalTimeStamp)
{
srcChangesetInfo = cset1;
dstChangesetInfo = cset2;
return;
}
srcChangesetInfo = cset2;
dstChangesetInfo = cset1;
}
static string GetChangesetFullSpec(
RepositorySpec repSpec,
long changesetId)
{
return string.Format("cs:{0}@{1}",
changesetId, repSpec.ToString());
}
static string GetBranchFullSpec(
RepositorySpec repSpec,
BranchInfo branchInfo)
{
return string.Format("br:{0}@{1}",
branchInfo.BranchName,
repSpec.ToString());
}
static string GetBranchFullSpec(
RepositorySpec repSpec,
ChangesetExtendedInfo changesetExtendedInfo)
{
return string.Format("br:{0}@{1}",
changesetExtendedInfo.BranchName,
repSpec.ToString());
}
}
}

View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 6483fd05e8bf42a47aee5e11dbf6db8a
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: