public static void SafeRun()
{
if (WorldConfiguration.Instance.SafeRun)
{
ExceptionsHandler.SafeRun();
}
}
void ExchangeTokensAndJoinOrganization(string unityAccessToken)
{
int ini = Environment.TickCount;
TokenExchangeResponse response = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ResponseInit;
response = PlasticScmRestApiClient.TokenExchange(unityAccessToken);
},
/*afterOperationDelegate*/ delegate
{
mLog.DebugFormat(
"TokenExchange time {0} ms",
Environment.TickCount - ini);
if (waiter.Exception != null)
{
mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ErrorTokenException;
ExceptionsHandler.LogException(
"TokenExchangeSetting",
waiter.Exception);
return;
}
if (response == null)
{
mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ErrorResponseNull;
Debug.Log("response null");
return;
}
if (response.Error != null)
{
mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ErrorResponseError;
mLog.ErrorFormat(
"Unable to exchange token: {0} [code {1}]",
response.Error.Message, response.Error.ErrorCode);
return;
}
if (string.IsNullOrEmpty(response.AccessToken))
{
mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ErrorTokenEmpty;
mLog.InfoFormat(
"Access token is empty for user: {0}",
response.User);
return;
}
mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ResponseEnd;
sAccessToken = response.AccessToken;
sUserName = response.User;
GetOrganizationList();
});
}
internal static void ForWorkspace(
WorkspaceInfo wkInfo,
IPlasticAPI plasticApi)
{
RepositoryInfo repInfo = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
RepositorySpec repSpec = plasticApi.GetRepositorySpec(wkInfo);
repInfo = plasticApi.GetRepositoryInfo(repSpec);
},
/*afterOperationDelegate*/ delegate
{
if (waiter.Exception != null)
{
ExceptionsHandler.LogException(
"SetupCloudProjectId",
waiter.Exception);
return;
}
SetupCloudProjectId.ForRepository(repInfo);
});
}
public PartsDataResponse Save(IModel i)
{
try
{
var o = i as Part;
var id = _partController.Save(o, true, transID: _token, endPoint: "part/save");
_stockController.Save(new Stock
{
PartId = id,
Units = 1,
LastUpdate = BlueConstants.BlueCurrentDate
});
return(new PartsDataResponse
{
Parts = _partController.Select("where id=@0", id).ToList(),
Message = BlueConstants.SUCCESS,
Success = true,
});
}
catch (Exception ex)
{
ExceptionsHandler.Process(ex);
}
return(null);
}
static void HandleLog(string logString, string stackTrace, LogType type)
{
if (type != LogType.Exception)
{
return;
}
if (!IsPlasticStackTrace(stackTrace))
{
return;
}
GUIActionRunner.RunGUIAction(delegate {
mLog.ErrorFormat("[HandleLog] Unexpected error: {0}", logString);
mLog.DebugFormat("Stack trace: {0}", stackTrace);
string message = logString;
if (ExceptionsHandler.DumpStackTrace())
{
message += Environment.NewLine + stackTrace;
}
GuiMessage.ShowError(message);
});
}
static void InviteMemberButton_clicked(object obj)
{
WorkspaceInfo wkInfo = (WorkspaceInfo)obj;
CurrentUserAdminCheckResponse response = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(50);
waiter.Execute(
/*threadOperationDelegate*/
delegate
{
RepositorySpec repSpec = PlasticGui.Plastic.API.GetRepositorySpec(wkInfo);
ServerProfile serverProfile =
CmConnection.Get().GetProfileManager().GetProfileForServer(repSpec.Server) ??
ClientConfig.Get().GetDefaultProfile();
string authToken = CmConnection.Get()
.BuildWebApiTokenForCloudEditionForProfileAndOrg(
serverProfile);
response = WebRestApiClient.PlasticScm.IsUserAdmin(
ServerOrganizationParser.GetOrganizationFromServer(repSpec.Server),
authToken);
},
/*afterOperationDelegate*/
delegate
{
if (waiter.Exception != null)
{
ExceptionsHandler.LogException(
"IsUserAdmin",
waiter.Exception);
return;
}
if (response.Error != null)
{
Debug.LogErrorFormat(
"Error checking if the user is the organization admin: {0}",
string.Format("Unable to get IsUserAdminResponse: {0} [code {1}]",
response.Error.Message,
response.Error.ErrorCode));
return;
}
if (response.IsCurrentUserAdmin)
{
Application.OpenURL("https://www.plasticscm.com/dashboard/cloud/" +
response.OrganizationName +
"/users-and-groups");
return;
}
GuiMessage.ShowInformation(
PlasticLocalization.GetString(PlasticLocalization.Name.InviteMembersTitle),
PlasticLocalization.GetString(PlasticLocalization.Name.InviteMembersMessage));
});
}
void IRefreshableView.Refresh()
{
BranchInfo workingBranch = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
workingBranch = OverlappedCalculator.GetWorkingBranch(
mWkInfo.ClientPath);
},
/*afterOperationDelegate*/ delegate
{
if (waiter.Exception != null)
{
ExceptionsHandler.DisplayException(waiter.Exception);
return;
}
// No need for merge info if it's a label
if (workingBranch == null)
{
return;
}
mMergeController.UpdateMergeObjectInfoIfNeeded(workingBranch);
mMergeViewLogic.Refresh();
});
}
void Update()
{
if (mException != null)
{
return;
}
if (mWkInfo == null)
{
return;
}
try
{
double currentUpdateTime = EditorApplication.timeSinceStartup;
double elapsedSeconds = currentUpdateTime - mLastUpdateTime;
mViewSwitcher.Update();
mWorkspaceWindow.OnParentUpdated(elapsedSeconds);
if (mWelcomeView != null)
{
mWelcomeView.Update();
}
mLastUpdateTime = currentUpdateTime;
}
catch (Exception ex)
{
mException = ex;
ExceptionsHandler.HandleException("Update", ex);
}
}
internal static void ForWorkspace(
WorkspaceInfo wkInfo,
IPlasticAPI plasticApi)
{
if (HasCloudProjectId())
{
return;
}
string repGuid = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
RepositorySpec repSpec = plasticApi.GetRepositorySpec(wkInfo);
RepositoryInfo repInfo = plasticApi.GetRepositoryInfo(repSpec);
repGuid = repInfo.GUID.ToString();
},
/*afterOperationDelegate*/ delegate
{
if (waiter.Exception != null)
{
ExceptionsHandler.LogException(
"SetupCloudProjectId",
waiter.Exception);
}
ConfigureCloudProjectId(repGuid);
});
}
void IAssetMenuOperations.ShowDiff()
{
string selectedPath = AssetsSelection.GetSelectedPath(
mAssetSelection.GetSelectedAssets());
DiffInfo diffInfo = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
string symbolicName = GetSymbolicName(selectedPath);
string extension = Path.GetExtension(selectedPath);
diffInfo = Plastic.API.BuildDiffInfoForDiffWithPrevious(
selectedPath, symbolicName, selectedPath, extension, mWkInfo);
},
/*afterOperationDelegate*/ delegate
{
if (waiter.Exception != null)
{
ExceptionsHandler.DisplayException(waiter.Exception);
return;
}
DiffOperation.DiffWithPrevious(
diffInfo,
null,
null);
});
}
internal void PartialUpdateWorkspace()
{
mProgressControls.ShowProgress(PlasticLocalization.GetString(
PlasticLocalization.Name.UpdatingWorkspace));
((IUpdateProgress)mGluonProgressOperationHandler).ShowCancelableProgress();
OutOfDateUpdater outOfDateUpdater = new OutOfDateUpdater(mWkInfo);
IThreadWaiter waiter = ThreadWaiter.GetWaiter();
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
outOfDateUpdater.Execute();
},
/*afterOperationDelegate*/ delegate
{
mProgressControls.HideProgress();
((IUpdateProgress)mGluonProgressOperationHandler).EndProgress();
mViewHost.RefreshView(ViewType.CheckinView);
mViewHost.RefreshView(ViewType.IncomingChangesView);
Refresh.UnityAssetDatabase();
if (waiter.Exception != null)
{
ExceptionsHandler.DisplayException(waiter.Exception);
return;
}
ShowUpdateReportDialog(
mWkInfo, mViewHost, outOfDateUpdater.Progress, mProgressControls,
mGuiMessage, mGluonProgressOperationHandler, this);
},
/*timerTickDelegate*/ delegate
{
UpdateProgress progress = outOfDateUpdater.Progress;
if (progress == null)
{
return;
}
if (progress.IsCanceled)
{
mProgressControls.ShowNotification(
PlasticLocalization.GetString(PlasticLocalization.Name.Canceling));
}
((IUpdateProgress)mGluonProgressOperationHandler).RefreshProgress(
progress,
UpdateProgressDataCalculator.CalculateProgressForWorkspaceUpdate(
mWkInfo.ClientPath, progress));
});
}
void FillBranches(WorkspaceInfo wkInfo, string query, List <RepObjectInfo> branchesToSelect)
{
if (mIsRefreshing)
{
return;
}
mIsRefreshing = true;
int defaultRow = TableViewOperations.
GetFirstSelectedRow(mBranchesListView);
((IProgressControls)mProgressControls).ShowProgress(
PlasticLocalization.GetString(
PlasticLocalization.Name.LoadingBranches));
ViewQueryResult queryResult = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter();
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
queryResult = new ViewQueryResult(
PlasticGui.Plastic.API.FindQuery(wkInfo, query));
},
/*afterOperationDelegate*/ delegate
{
try
{
if (waiter.Exception != null)
{
ExceptionsHandler.DisplayException(waiter.Exception);
return;
}
UpdateBranchesList(
mBranchesListView,
queryResult);
int branchesCount = GetBranchesCount(queryResult);
if (branchesCount == 0)
{
return;
}
BranchesSelection.SelectBranches(
mBranchesListView, branchesToSelect, defaultRow);
}
finally
{
((IProgressControls)mProgressControls).HideProgress();
mIsRefreshing = false;
}
});
}
static void DisplayException(
IProgressControls progressControls,
Exception ex)
{
ExceptionsHandler.LogException(
"CreateWorkspaceView", ex);
progressControls.ShowError(
ExceptionsHandler.GetCorrectExceptionMessage(ex));
}
static void DisplayException(
ProgressControlsForMigration progressControls,
Exception ex)
{
ExceptionsHandler.LogException(
"MigrationDialog", ex);
progressControls.ShowError(
ExceptionsHandler.GetCorrectExceptionMessage(ex));
}
void tm_OnTestEnded(AsyncBufferPageDataCollector sender, PageDataCollectorStartInfo settings, bool success, PageDataCollectorErrors errCode, int resultsId)
{
if (success == false && errCode != PageDataCollectorErrors.TestAborted)
{
ExceptionsHandler.HandleException(new Exception(String.Format("Test Failed. Error #{0} Command Args \"{1}\"", errCode, ((settings != null && settings.CreateCommandLineArgs() != null) ? settings.CreateCommandLineArgs() : ""))));
}
if (this.pageDataCollector != null)
{
this.pageDataCollector.Dispose();
}
this.pageDataCollector = null;
if (success == false)
{
SetTestRunning(false);
SetTestStatus(TestEventType.TestEnded, success, errCode, resultsId);
int[] pp = GetProxyPorts();
if (pp == null)
{
return;
}
if (errCode == PageDataCollectorErrors.CantStartProxy && proxyRangeOffset < pp.Length - 1)
{
proxyRangeOffset++;
StartTest();
}
else if (errCode != PageDataCollectorErrors.TestAborted)
{
if (errCode == PageDataCollectorErrors.InvalidConfiguration)
{
MessageBox.Show("Invalid configuration detected.\r\nPlease make sure the settings are correct", "Test Aborted", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else if (errCode == PageDataCollectorErrors.TestAlreadyRunning)
{
MessageBox.Show("Test is already running on a different page.", "Test Aborted", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else if (errCode == PageDataCollectorErrors.TestTimeout)
{
MessageBox.Show("Test has timed-out.", "Test Aborted", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
MessageBox.Show("Unexpected error occured while trying to test the page\r\n(err#" + ((int)errCode) + ")", "Test Aborted", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
else
{
ProcessResults(resultsId);
}
}
internal void ExchangeTokens(string unityAccessToken)
{
int ini = Environment.TickCount;
TokenExchangeResponse response = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
response = PlasticScmRestApiClient.TokenExchange(unityAccessToken);
},
/*afterOperationDelegate*/ delegate
{
mLog.DebugFormat(
"TokenExchange time {0} ms",
Environment.TickCount - ini);
if (waiter.Exception != null)
{
ExceptionsHandler.LogException(
"TokenExchangeSetting",
waiter.Exception);
return;
}
if (response == null)
{
Debug.Log("response null");
return;
}
if (response.Error != null)
{
mLog.ErrorFormat(
"Unable to exchange token: {0} [code {1}]",
response.Error.Message,
response.Error.ErrorCode);
return;
}
if (string.IsNullOrEmpty(response.AccessToken))
{
mLog.InfoFormat(
"Access token is empty for user: {0}",
response.User);
return;
}
sAccessToken = response.AccessToken;
sUserName = response.User;
});
}
internal static void CheckinPathsPartial(
WorkspaceInfo wkInfo,
List <string> paths,
string comment,
ViewHost viewHost,
CheckinDialog dialog,
GuiMessage.IGuiMessage guiMessage,
IProgressControls progressControls,
IGluonViewSwitcher gluonViewSwitcher)
{
BaseCommandsImpl baseCommands = new BaseCommandsImpl();
progressControls.ShowProgress(PlasticLocalization.GetString(
PlasticLocalization.Name.CheckinInFilesProgress));
IThreadWaiter waiter = ThreadWaiter.GetWaiter(50);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
baseCommands.PartialCheckin(wkInfo, paths, comment);
},
/*afterOperationDelegate*/ delegate
{
progressControls.HideProgress();
((IPlasticDialogCloser)dialog).CloseDialog();
if (waiter.Exception is CheckinConflictsException)
{
// we need to explicitly call EditorWindow.Close() to ensure
// that the dialog is closed before asking the user
dialog.Close();
if (!UserWantsToShowIncomingView(guiMessage))
{
return;
}
gluonViewSwitcher.ShowIncomingChangesView();
return;
}
if (waiter.Exception != null)
{
ExceptionsHandler.DisplayException(waiter.Exception);
return;
}
viewHost.RefreshView(ViewType.CheckinView);
viewHost.RefreshView(ViewType.HistoryView);
});
}
void FillData(
MountPointWithPath mountWithPath,
ChangesetInfo csetInfo)
{
mSelectedMountWithPath = mountWithPath;
mSelectedChangesetInfo = csetInfo;
((IProgressControls)mProgressControls).ShowProgress(
PlasticLocalization.GetString(PlasticLocalization.Name.Loading));
mIsSkipMergeTrackingButtonVisible = false;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(100);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
mDiffs = Plastic.API.GetChangesetDifferences(
mountWithPath, csetInfo);
},
/*afterOperationDelegate*/ delegate
{
((IProgressControls)mProgressControls).HideProgress();
if (waiter.Exception != null)
{
ExceptionsHandler.DisplayException(waiter.Exception);
return;
}
if (mSelectedMountWithPath != mountWithPath ||
mSelectedChangesetInfo != csetInfo)
{
return;
}
if (mDiffs == null || mDiffs.Count == 0)
{
ClearDiffs();
return;
}
mIsSkipMergeTrackingButtonVisible =
ClientDiffList.HasMerges(mDiffs);
bool skipMergeTracking =
mIsSkipMergeTrackingButtonVisible &&
mIsSkipMergeTrackingButtonChecked;
UpdateDiffTreeView(
mDiffs, skipMergeTracking, mDiffTreeView);
});
}
void AsyncCalculateStatus(CancelToken cancelToken)
{
Dictionary <string, LockStatusData> statusByPathCache = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(50);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
Dictionary <RepositorySpec, List <WorkspaceTreeNode> > lockCandidates =
new Dictionary <RepositorySpec, List <WorkspaceTreeNode> >();
FillLockCandidates.ForTree(mWkInfo, lockCandidates);
if (cancelToken.IsCancelled())
{
return;
}
Dictionary <WorkspaceTreeNode, LockInfo> lockInfoByNode =
SearchLocks.GetLocksInfo(mWkInfo, lockCandidates);
if (cancelToken.IsCancelled())
{
return;
}
statusByPathCache = BuildStatusByNodeCache.
ForLocks(mWkInfo.ClientPath, lockInfoByNode);
},
/*afterOperationDelegate*/ delegate
{
if (waiter.Exception != null)
{
ExceptionsHandler.LogException(
"LockStatusCache",
waiter.Exception);
return;
}
if (cancelToken.IsCancelled())
{
return;
}
lock (mLock)
{
mStatusByPathCache = statusByPathCache;
}
mRepaintProjectWindow();
});
}
internal static void Open(List<string> files)
{
try
{
foreach (string file in files)
OpenFile(file);
}
catch (Exception ex)
{
ExceptionsHandler.DisplayException(ex);
}
}
private void ThreadProc()
{
try
{
while (_isRunning)
{
//---- Wait until we wake up this thread
if (_commandsCount < 1)
{
//-- Wait...
bool hasTimeOut = false;
lock (this)
hasTimeOut = !Monitor.Wait(this, _uselessThreadTimeout);
//-- The thread pool is NOT heavily used, remove this thread from the pool
if (hasTimeOut)
{
lock (_threads)
if (_threads.Count > _minThreadsCount)
{
_threads.Remove(Thread.CurrentThread);
return;
}
continue;
}
}
//---- Process at least one command, if fast enough can process several commands
Interlocked.Increment(ref _busyThreads);
//---- Thread pool is heavily used, add a thread to the pool
if (_busyThreads == _threads.Count)
{
AddThreadToPool();
}
ProcessAllCommands();
Interlocked.Decrement(ref _busyThreads);
}
}
catch (ThreadAbortException)
{
}
catch (Exception exception)
{
ExceptionsHandler.Handle(exception);
}
}
static void EnableUserBetaProgramIfNeeded(string unityAccessToken)
{
int ini = Environment.TickCount;
UnityPackageBetaEnrollResponse response = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
response = PlasticScmRestApiClient.IsBetaEnabled(unityAccessToken);
},
/*afterOperationDelegate*/ delegate
{
mLog.DebugFormat(
"IsBetaEnabled time {0} ms",
Environment.TickCount - ini);
if (waiter.Exception != null)
{
ExceptionsHandler.LogException(
"CalculateUserBetaProgramSetting",
waiter.Exception);
return;
}
if (response == null)
{
return;
}
if (response.Error != null)
{
mLog.ErrorFormat(
"Unable to retrieve is beta enabled: {0} [code {1}]",
response.Error.Message, response.Error.ErrorCode);
return;
}
if (!response.IsBetaEnabled)
{
mLog.InfoFormat(
"Beta is disabled for accessToken: {0}",
unityAccessToken);
return;
}
PlasticMenuItem.Add();
});
}
static void HandleUnhandledException(object sender, UnhandledExceptionEventArgs args)
{
Exception ex = (Exception)args.ExceptionObject;
if (IsExitGUIException(ex) ||
!IsPlasticStackTrace(ex.StackTrace))
{
return;
}
GUIActionRunner.RunGUIAction(delegate {
ExceptionsHandler.HandleException("HandleUnhandledException", ex);
});
}
public void Sort_SholdWorkAppropriateForNonTextTypes(string columnName, SortDirectionsEnum direction, Type propertyType)
{
ExceptionsHandler.Hande(() =>
{
this.navigator.AllTypesDataPage().GoTo();
var tableElement = new TableElement("table", this.driver);
string columnHeader = columnName.StartsWith("NestedModel") ? this.GetHeaderForNestedModel(columnName) : columnName;
tableElement.ClickSortButton(columnHeader, direction);
AssertNonTextPropertyOrder(columnName, columnHeader, direction, propertyType, tableElement);
tableElement.GoToLastPage();
AssertNonTextPropertyOrder(columnName, columnHeader, direction, propertyType, tableElement);
},
this.driver);
}
public void Sort_SholdWorkAppropriateForTextTypes(string columnName, SortDirectionsEnum direction)
{
ExceptionsHandler.Hande(() =>
{
this.navigator.AllTypesDataPage().GoTo();
var tableElement = new TableElement("table", this.driver);
tableElement.ClickSortButton(columnName, direction);
// Assert that rows are in correct order for the first page
AssertTextPropertyOrder(columnName, direction, tableElement);
tableElement.GoToLastPage();
// Assert that rows are in correct order for the last page
AssertTextPropertyOrder(columnName, direction, tableElement);
},
this.driver);
}
private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
{
try
{
ExceptionsHandler.HandleException((Exception)e.ExceptionObject);
}
catch
{
}
DialogResult dr = MessageBox.Show("An unexpected error has occurred.\r\nWould you like to report this error?\r\n\r\n(private data will NOT be sent!)", "Error Detected!", MessageBoxButtons.YesNo);
if (dr == DialogResult.Yes)
{
ExceptionsHandler.FlushExceptions();
}
}
void AsyncCalculateStatus(CancelToken cancelToken)
{
Dictionary <string, AssetStatus> statusByPathCache = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(50);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
OutOfDateItems outOfDateItems =
OutOfDateUpdater.CalculateOutOfDateItems(
mWkInfo, new List <ErrorMessage>(),
OutOfDateCalculator.Options.IsIncomingChanges);
if (cancelToken.IsCancelled())
{
return;
}
statusByPathCache = BuildStatusByPathCache.
ForOutOfDateItems(outOfDateItems, mWkInfo.ClientPath);
},
/*afterOperationDelegate*/ delegate
{
if (waiter.Exception != null)
{
ExceptionsHandler.LogException(
"RemoteStatusCache",
waiter.Exception);
return;
}
if (cancelToken.IsCancelled())
{
return;
}
lock (mLock)
{
mStatusByPathCache = statusByPathCache;
}
mRepaintProjectWindow();
});
}
public void Sort_SholdWorkWithSubsecuentPropertiesSortOperations()
{
ExceptionsHandler.Hande(() =>
{
string firstColumnName = "Integer";
string secondColumnName = "DoubleProperty";
this.navigator.AllTypesDataPage().GoTo();
var tableElement = new TableElement("table", this.driver);
tableElement.ClickSortButton(firstColumnName, SortDirectionsEnum.Asc);
tableElement.ClickSortButton(secondColumnName, SortDirectionsEnum.Asc);
AssertNonTextPropertyOrder(secondColumnName, secondColumnName, SortDirectionsEnum.Asc, typeof(double), tableElement);
tableElement.GoToLastPage();
AssertNonTextPropertyOrder(secondColumnName, secondColumnName, SortDirectionsEnum.Asc, typeof(double), tableElement);
},
this.driver);
}
static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
{
try{
StringBuilder sb = new StringBuilder();
sb.Append("Engine Failed. args: ");
foreach (String s in commandArgs)
{
sb.Append(s);
sb.Append(" ");
}
ExceptionsHandler.HandleException(new Exception(sb.ToString(), (Exception)e.ExceptionObject));
}catch
{
}
System.Environment.ExitCode = (int)PageDataCollectorErrors.Unknown;
System.Environment.Exit((int)PageDataCollectorErrors.Unknown);
}
void IAssetMenuOperations.ShowDiff()
{
if (LaunchTool.ShowDownloadPlasticExeWindow(
mWkInfo,
mIsGluonMode,
TrackFeatureUseEvent.Features.InstallPlasticCloudFromShowDiff,
TrackFeatureUseEvent.Features.InstallPlasticEnterpriseFromFromShowDiff,
TrackFeatureUseEvent.Features.CancelPlasticInstallationFromFromShowDiff))
{
return;
}
string selectedPath = AssetsSelection.GetSelectedPath(
mAssetSelection.GetSelectedAssets());
DiffInfo diffInfo = null;
IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
waiter.Execute(
/*threadOperationDelegate*/ delegate
{
string symbolicName = GetSymbolicName(selectedPath);
string extension = Path.GetExtension(selectedPath);
diffInfo = PlasticGui.Plastic.API.BuildDiffInfoForDiffWithPrevious(
selectedPath, symbolicName, selectedPath, extension, mWkInfo);
},
/*afterOperationDelegate*/ delegate
{
if (waiter.Exception != null)
{
ExceptionsHandler.DisplayException(waiter.Exception);
return;
}
DiffOperation.DiffWithPrevious(
diffInfo,
null,
null);
});
}
