private string SetSourceControlIndicator(Uri uri, SourceControlStatus status)
{
string indicator = null;
switch (status)
{
case SourceControlStatus.Added:
indicator = Resources.DocumentAddImage;
break;
case SourceControlStatus.CheckedIn:
{
if (m_sourceControlService.IsSynched(uri))
{
indicator = Resources.DocumentLockImage;
}
else
{
indicator = Resources.DocumentWarningImage;
}
}
break;
case SourceControlStatus.CheckedOut:
indicator = Resources.DocumentCheckOutImage;
break;
case SourceControlStatus.NotControlled:
indicator = null;
break;
}
return(indicator);
}
private void GetFolderStatusRecursive(string directoryName)
{
DirectoryInfo dir = new DirectoryInfo(directoryName);
FileSystemInfo[] items = dir.GetFileSystemInfos();
foreach (FileSystemInfo item in items)
{
// if (item is DirectoryInfo)
// {
// //Console.WriteLine("DIRECTORY: " + ((DirectoryInfo)item).FullName);
// //GetAllDirFilesRecurse(((DirectoryInfo)item).FullName);
// }
// if (item is System.IO.FileInfo)
{
SourceControlStatus initialStatus = SourceControlStatus.Unknown;
FileInfo info;
string filename = item.FullName;
if (!m_infoCache.TryGetValue(filename, out info))
{
Uri fileUri = new Uri(filename);
info = new FileInfo(fileUri, initialStatus);
m_infoCache[filename] = info;
ParseStatus(filename);
}
if (item is DirectoryInfo)
{
GetFolderStatusRecursive(filename);
}
//Console.WriteLine("FILE: " + ((FileInfo)item).FullName);
}
}
}
/// <summary>
/// Performs adding documents to source control</summary>
/// <param name="doing">True iff doing the command</param>
/// <returns>True iff any documents added or can be added</returns>
protected virtual bool DoAdd(bool doing)
{
if (SourceControlService == null || !SourceControlService.Enabled ||
SourceControlContext == null)
{
return(false);
}
int addedCount = 0;
foreach (IResource resource in SourceControlContext.Resources)
{
SourceControlStatus status = GetStatus(resource);
if (status != SourceControlStatus.NotControlled &&
status != SourceControlStatus.FileDoesNotExist)
{
return(false);
}
addedCount++;
if (doing)
{
SourceControlService.Add(resource.Uri);
}
}
return(addedCount != 0);
}
/// <summary>
/// Performs checking in documents to source control</summary>
/// <param name="doing">True iff doing the command</param>
/// <returns>True iff any documents checked in or can be checked in</returns>
protected virtual bool DoCheckIn(bool doing)
{
if (SourceControlService == null || m_contextRegistry == null ||
SourceControlContext == null || !SourceControlService.AllowCheckIn)
{
return(false);
}
bool result = false;
List <IResource> toCheckIns = new List <IResource>();
// return true if resources are added or checked out
foreach (IResource resource in SourceControlContext.Resources)
{
SourceControlStatus status = GetStatus(resource);
if (status == SourceControlStatus.CheckedOut ||
status == SourceControlStatus.Added ||
status == SourceControlStatus.Deleted)
{
result = true;
if (doing)
{
toCheckIns.Add(resource);
}
else
{
break;
}
}
}
if (doing)
{
if (m_documentService != null)
{
foreach (IResource resource in SourceControlContext.Resources)
{
// if collection has been modified save it before we check in
IDocument document = resource.As <IDocument>();
if (document != null)
{
if (document.Dirty)
{
m_documentService.Save(document);
}
}
}
}
CheckInForm form = new CheckInForm(SourceControlService, toCheckIns);
if (m_mainForm != null)
{
form.Icon = m_mainForm.Icon;
}
form.ShowDialog(GetDialogOwner());
}
return(result);
}
private void RightPaneAddItem(IResource resource)
{
if (m_thumbnailControl.Visible)
{
m_requestedThumbs.Add(resource);
m_thumbnailService.ResolveThumbnail(resource);
string assetPath = resource.GetPathName();
string assetFileName = Path.GetFileName(assetPath);
Icon shellIcon = FileIconUtil.GetFileIcon(assetFileName, FileIconUtil.IconSize.Large, false);
Bitmap tempThumbnail = shellIcon.ToBitmap();
ThumbnailControlItem item = GetItem(resource);
if (item == null)
{
item = NewItem(resource, tempThumbnail);
m_thumbnailControl.Items.Add(item);
}
else
{
item.Image = tempThumbnail;
}
}
else if (m_listView.Visible)
{
string assetPath = resource.Uri.OriginalString;
string indicator = null;
if (m_sourceControlService != null)
{
SourceControlStatus status = m_sourceControlService.GetStatus(resource.Uri);
indicator = SetSourceControlIndicator(resource.Uri, status);
}
string path = resource.GetPathName();
}
}
public static void SetCachedStatus(IEnumerable <DocumentReference> items, SourceControlStatus status)
{
foreach (DocumentReference item in items)
{
SourceControlStatusCache.SetCachedStatusInternal(item, status);
}
SourceControlStatusCache.OnStatusUpdated();
}
/*
* private void client_Notification(object sender, NotificationEventArgs args)
* {
* // this is for debug purposes
* Outputs.WriteLine(OutputMessageType.Warning, args.Path);
* }*/
private static SourceControlStatus[] GetStatusArray(List <FileInfo> info)
{
SourceControlStatus[] result = new SourceControlStatus[info.Count];
for (int i = 0; i < info.Count; i++)
{
result[i] = info[i].Status;
}
return(result);
}
private static void SetCachedStatusInternal(DocumentReference item, SourceControlStatus status)
{
if (SourceControlStatusCache.statusCache.ContainsKey(item))
{
SourceControlStatusCache.statusCache[item] = status;
return;
}
SourceControlStatusCache.statusCache.Add(item, status);
}
// /// <summary>
// /// Raises the StatusChanged event</summary>
// /// <param name="e">Event args</param>
// protected override void OnStatusChanged(SourceControlEventArgs e)
// {
// base.OnStatusChanged(e);
// }
/// <summary>
/// Sets the status for the given URI</summary>
/// <param name="uri">URI of item</param>
/// <param name="status">New status of item</param>
protected void SetStatus(Uri uri, SourceControlStatus status)
{
FileInfo info = GetInfo(uri, false);
if (status != info.Status)
{
info.Status = status;
OnStatusChanged(new SourceControlEventArgs(uri, status));
}
}
/// <summary>
/// Constructor</summary>
/// <param name="uri">File URI</param>
/// <param name="status">Source control status</param>
/// <param name="headRevision">Head revision number</param>
/// <param name="revision">Revision number</param>
/// <param name="isLocked">True iff locked</param>
/// <param name="otherUsers">Other file users</param>
public SourceControlFileInfo(Uri uri, SourceControlStatus status,
int headRevision, int revision, bool isLocked, IEnumerable <string> otherUsers)
{
Uri = uri;
Status = status;
HeadRevision = headRevision;
Revision = revision;
IsLocked = isLocked;
OtherUsers = otherUsers;
}
private bool IsValidStatusForHistory(IDocumentItem documentItem)
{
SourceControlStatus cachedStatus = SourceControlStatusCache.GetCachedStatus(documentItem);
if (cachedStatus == SourceControlStatus.None)
{
return(false);
}
return(cachedStatus != SourceControlStatus.Add);
}
protected bool FileHasPendingChange(IDocumentItem item)
{
SourceControlStatus cachedStatus = SourceControlStatusCache.GetCachedStatus(item);
if (cachedStatus == SourceControlStatus.CheckedIn)
{
return(false);
}
return(cachedStatus != SourceControlStatus.None);
}
/// <summary>
/// Constructor</summary>
/// <param name="uri">File URI</param>
/// <param name="status">Source control status</param>
/// <param name="headRevision">Head revision number</param>
/// <param name="revision">Revision number</param>
/// <param name="isLocked">True iff locked</param>
/// <param name="otherUsers">Other file users</param>
public SourceControlFileInfo(Uri uri, SourceControlStatus status,
int headRevision, int revision, bool isLocked, IEnumerable<string> otherUsers)
{
Uri = uri;
Status = status;
HeadRevision = headRevision;
Revision = revision;
IsLocked = isLocked;
OtherUsers = otherUsers;
}
/// <summary>
/// Gets source control status icon</summary>
/// <param name="uri">File URI</param>
/// <param name="status">Source control status</param>
/// <returns>Source control status icon image</returns>
public override Image GetSourceControlStatusIcon(Uri uri, SourceControlStatus status)
{
Image result = null;
switch (status)
{
case SourceControlStatus.Added:
result = m_statusImages[P4VFileAdd];
break;
case SourceControlStatus.CheckedIn:
{
if (IsSynched(uri))
{
FileInfo info = GetInfo(uri);
if (string.IsNullOrEmpty(info.OtherLock))
{
result = m_statusImages[P4VFileSync];
}
else
{
result = m_statusImages[P4VFileLockOther];
}
}
else
{
result = m_statusImages[P4VFileNotsync];
}
break;
}
case SourceControlStatus.CheckedOut:
{
FileInfo info = GetInfo(uri);
if (info.IsLocked)
{
result = m_statusImages[P4VFileLock];
}
else
{
result = m_statusImages[P4VFileEditHead];
}
break;
}
case SourceControlStatus.NotControlled:
result = m_statusImages[P4VFileWs];
break;
}
return(result);
}
private List <FileInfo> GetInfo(IEnumerable <Uri> uris, bool refreshCache)
{
// create result list using cache where possible, and build a list of unknown paths
List <FileInfo> result = new List <FileInfo>();
List <string> refreshPaths = new List <string>();
foreach (Uri uri in uris)
{
string path = GetCanonicalPath(uri);
SourceControlStatus initialStatus =
File.Exists(path) ?
SourceControlStatus.Unknown :
SourceControlStatus.FileDoesNotExist;
FileInfo info;
if (!m_infoCache.TryGetValue(path, out info))
{
info = new FileInfo(uri, initialStatus);
m_infoCache[path] = info;
refreshPaths.Add(path);
}
else if (refreshCache)
{
info.Status = initialStatus;
refreshPaths.Add(path);
}
result.Add(info);
}
if (refreshPaths.Count > 0)
{
// remember old status to avoid spurious StatusChanged events
SourceControlStatus[] oldStatus = GetStatusArray(result);
// get info for unknown paths from Subversion
RefreshInfo(refreshPaths.ToArray());
for (int i = 0; i < result.Count; i++)
{
FileInfo info = result[i];
if (oldStatus[i] != info.Status)
{
OnStatusChanged(new SourceControlEventArgs(info.Uri, info.Status));
}
}
}
return(result);
}
/// <summary>
/// Reverts an item</summary>
/// <param name="uri">Uri, representing the path to item</param>
public override void Revert(Uri uri)
{
CheckUri(uri);
SourceControlStatus oldStatus = GetInfo(uri, false).Status;
if (ClientInitialized())
{
string path = GetCanonicalPath(uri);
RunCommand("revert", path);
SourceControlStatus newStatus = GetInfo(uri, true).Status;
if (oldStatus != newStatus)
{
OnStatusChanged(new SourceControlEventArgs(uri, newStatus));
}
}
}
private ThumbnailControlItem NewItem(IResource resource, Image image)
{
ThumbnailControlItem item = new ThumbnailControlItem(image);
item.Tag = resource;
item.Name = Path.GetFileName(resource.GetPathName());
item.Description = resource.GetPathName();
// Set source control status
if (m_sourceControlService != null)
{
SourceControlStatus status = m_sourceControlService.GetStatus(resource.Uri);
item.Indicator = SetSourceControlIndicator(resource.Uri, status);
}
return(item);
}
internal static void UpdateStatus(IEnumerable <DocumentReference> items, ISourceControlProvider sourceControlProvider)
{
if (items.CountIs <DocumentReference>(0) || sourceControlProvider == null)
{
return;
}
DocumentReference[] array = (
from item in items
where PathHelper.FileExists(item.Path)
select item).ToArray <DocumentReference>();
SourceControlStatus[] sourceControlStatusArray = new SourceControlStatus[(int)array.Length];
sourceControlProvider.QueryInfo((
from path in (IEnumerable <DocumentReference>) array
select path.Path).ToArray <string>(), sourceControlStatusArray);
for (int i = 0; i < (int)array.Length; i++)
{
SourceControlStatusCache.SetCachedStatusInternal(array[i], sourceControlStatusArray[i]);
}
SourceControlStatusCache.OnStatusUpdated();
}
internal void CheckLazyLoadStatus()
{
if (Preferences.LocalSettings.GetBool("LazyLoadStatus", false))
{
// if lazy laoding, update status of the selected files that haven't had
// their status loaded
IList <string> files = SccService.SelectedFiles;
IList <string> llfiles = new List <string>(files.Count);
foreach (string file in files)
{
SourceControlStatus status = SccService.GetFileStatus(file);
if (status.Test(SourceControlStatus.scsUnknown))
{
llfiles.Add(file);
}
}
CurrentScm.UpdateFiles(llfiles, true);
Glyphs.RefreshFilesAndGlyphs(llfiles);
}
}
private void UpdateFileInfoCache(List <string> refreshList, TaggedObjectList records)
{
if (records != null)
{
// update FileInfo instances with passed in records, fire StatusChanged event when applicable
foreach (var record in records)
{
FileInfo info;
string filePath = PathUtil.GetCanonicalPath(record["clientFile"]);
bool foundInfo;
lock (m_infoCache) //keep the lock for as short a time as possible; can't lock around OnStatusChanged().
foundInfo = m_infoCache.TryGetValue(filePath, out info);
if (foundInfo)
{
SourceControlStatus oldStatus = info.Status;
info.UpdateRecord(record);
if (info.Status != oldStatus)
{
OnStatusChanged(new SourceControlEventArgs(info.Uri, info.Status));
}
refreshList.Remove(filePath);
}
}
}
foreach (var filePath in refreshList)
{
//P4API.NET does not output records for files not under version control
FileInfo info;
lock (m_infoCache) //keep the lock for as short a time as possible; can't lock around OnStatusChanged().
info = m_infoCache[filePath];
SourceControlStatus oldStatus = info.Status;
if (oldStatus != SourceControlStatus.NotControlled)
{
info.NotControlled = true;
OnStatusChanged(new SourceControlEventArgs(info.Uri,
SourceControlStatus.NotControlled));
}
}
}
/// <summary>
/// Performs reverting local files to files under source control</summary>
/// <param name="doing">True iff doing the command</param>
/// <returns>True iff any documents reverted or can be reverted</returns>
protected virtual bool DoRevert(bool doing)
{
if (SourceControlService == null || SourceControlContext == null)
{
return(false);
}
foreach (IResource resource in SourceControlContext.Resources)
{
SourceControlStatus status = GetStatus(resource);
if (status != SourceControlStatus.CheckedOut && status != SourceControlStatus.Added)
{
return(false);
}
}
if (doing)
{
// user must confirm revert
DialogResult dialogResult = MessageBox.Show(m_mainForm,
"All changes will be lost. Do you want to proceed?".Localize(),
"Proceed with Revert?".Localize(),
MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.Yes)
{
foreach (IResource resource in SourceControlContext.Resources)
{
SourceControlStatus status = GetStatus(resource);
if (status == SourceControlStatus.CheckedOut || status == SourceControlStatus.Added)
{
SourceControlService.Revert(resource.Uri);
Reload(resource);
}
}
}
}
return(true);
}
private bool FileHasPendingChangeThatIsNotAdd(IDocumentItem item)
{
SourceControlStatus cachedStatus = SourceControlStatusCache.GetCachedStatus(item);
switch (cachedStatus)
{
case SourceControlStatus.None:
case SourceControlStatus.Add:
{
return(false);
}
default:
{
if (cachedStatus == SourceControlStatus.CheckedIn)
{
return(false);
}
return(true);
}
}
}
/// <summary>
/// Perform the Revert command</summary>
/// <param name="doing">True to perform the Revert; false to test whether Revert can be done</param>
/// <returns>True iff Revert can be done or was done</returns>
protected virtual bool DoRevert(bool doing)
{
if (SourceControlService == null || SourceControlContext == null)
{
return(false);
}
foreach (IResource resource in SourceControlContext.Resources)
{
SourceControlStatus status = GetStatus(resource);
if (status != SourceControlStatus.CheckedOut && status != SourceControlStatus.Added && status != SourceControlStatus.Deleted)
{
return(false);
}
}
if (doing)
{
// user must confirm revert
var dialogResult = MessageBoxes.Show("All Changes will be lost. Do you want to proceed?".Localize(),
"Proceed with Revert?".Localize(),
MessageBoxButton.YesNo, MessageBoxImage.Question);
if (dialogResult == MessageBoxResult.Yes)
{
foreach (IResource resource in SourceControlContext.Resources.ToArray())
{
SourceControlStatus status = GetStatus(resource);
if (status == SourceControlStatus.CheckedOut || status == SourceControlStatus.Added || status == SourceControlStatus.Deleted)
{
SourceControlService.Revert(resource.Uri);
Reload(resource);
}
}
}
}
return(true);
}
public static void ShelveFiles(IList<string> files, P4ScmProvider Scm, bool ShowUi)
{
Dictionary<int, IDictionary<string, P4.FileMetaData>> changeLists =
new Dictionary<int, IDictionary<string, P4.FileMetaData>>();
bool shelvedFiles = false;
for (int idx = 0; idx < files.Count; idx++)
{
int changeListId = -1;
if (files[idx] != null && (files[idx].EndsWith("...") || files[idx].EndsWith("*")))
{
List<P4.FileSpec> fileSpecs = new List<P4.FileSpec>();
fileSpecs.Add(P4.FileSpec.DepotSpec(files[idx]));
IList<P4.File> opened = Scm.Connection.Repository.GetOpenedFiles(fileSpecs, null);
IList<P4.FileSpec> openedSpecs = new List<P4.FileSpec>();
foreach (P4.File f in opened)
{
if ((f != null) && (f.DepotPath != null))
{
openedSpecs.Add(P4.FileSpec.ClientSpec(f.ClientPath.Path));
}
}
IList<P4.FileMetaData> metadata = Scm.ListFileMetaData(null, openedSpecs);
foreach (P4.FileMetaData f in metadata)
{
if (f != null)
{
changeListId = f.Change;
if (changeLists.ContainsKey(changeListId) == false)
{
changeLists.Add(changeListId, new Dictionary<string, P4.FileMetaData>());
}
if (changeLists[changeListId].ContainsKey(f.LocalPath.Path) == false)
{
changeLists[changeListId].Add(f.LocalPath.Path, f);
}
if (f.MovedFile != null)
{
P4.FileMetaData movedFmd = Scm.GetFileMetaData(f.MovedFile.Path);
if ((movedFmd != null) && (movedFmd.LocalPath != null) &&
(changeLists[changeListId].ContainsKey(movedFmd.LocalPath.Path) == false))
{
changeLists[changeListId].Add(movedFmd.LocalPath.Path, movedFmd);
}
}
}
}
continue;
}
P4.FileMetaData fmd = null;
fmd = Scm.Fetch(files[idx]);
if (fmd == null)
{
continue;
}
SourceControlStatus status = Scm.GetFileStatus(files[idx]);
if (status == SourceControlStatus.scsCheckedIn)
{
continue;
}
changeListId = fmd.Change;
// describe cl here and see if it is shelved
if (changeListId > 0)
{
Options opts = new Options();
opts["-S"] = null;
Changelist isChangeShelved = Scm.GetChangelist(changeListId, opts);
if (isChangeShelved.Shelved)
{
shelvedFiles = true;
}
}
if (changeLists.ContainsKey(changeListId) == false)
{
changeLists.Add(changeListId, new Dictionary<string, P4.FileMetaData>());
}
if (changeLists[changeListId].ContainsKey(fmd.LocalPath.Path) == false)
{
changeLists[changeListId].Add(fmd.LocalPath.Path, fmd);
}
if (fmd.MovedFile != null)
{
P4.FileMetaData movedFmd = Scm.GetFileMetaData(fmd.MovedFile.Path);
if ((movedFmd != null) && (movedFmd.LocalPath != null) &&
(changeLists[changeListId].ContainsKey(movedFmd.LocalPath.Path) == false))
{
changeLists[changeListId].Add(movedFmd.LocalPath.Path, movedFmd);
}
}
}
bool dlgShown = false;
foreach (int changeListId in changeLists.Keys)
{
ShelveFileDlg dlg = new ShelveFileDlg(Scm);
if (!(shelvedFiles))
{
dlg.ClearChangelistTB.Checked = false;
dlg.ClearChangelistTB.Enabled = false;
}
dlg.ChangelistId = changeListId;
dlg.SelectedFileList = changeLists[changeListId].Values.ToList();
if (dlg.SelectedFileList.Count <= 0)
{
continue;
}
dlgShown = true;
DialogResult res = DialogResult.OK;
dlg.Description = Resources.ShelveFileDlg_FilesShelvedFromDefaultChangelist;
if (changeListId > 0)
{
dlg.Description = string.Format(
Resources.ShelveFileDlg_FilesShelvedFromNumberedChangelist, changeListId);
}
if (ShowUi)
{
res = dlg.ShowDialog();
}
if (res == DialogResult.Cancel)
{
return;
}
// If requested delete the existing shelved flags
if ((changeListId > 0) && (dlg.ReplaceExistingShelvedFiles))
{
if (Scm.ShelveFiles(changeListId, null, P4.ShelveFilesCmdFlags.Delete, true, null) == false)
{
return;
}
}
P4.ShelveFilesCmdFlags flags = P4.ShelveFilesCmdFlags.Force;
if (dlg.DontShelveUnchangedFiles)
{
flags |= ShelveFilesCmdFlags.LeaveUnchanged;
}
// Shelve the files
if (Scm.ShelveFiles(changeListId, dlg.Description, flags, dlg.SelectedFileList) == false)
{
return;
}
// If requested, revert the files after shelving
if (dlg.RevertAfterShelving)
{
IList<string> selection = dlg.GetSelectedFiles();
string[] selected = selection.ToArray();
Scm.RevertFiles(false, true, null, selected);
}
Scm.BroadcastChangelistUpdate(null, new P4ScmProvider.ChangelistUpdateArgs(changeListId, P4ScmProvider.ChangelistUpdateArgs.UpdateType.ContentUpdate));
}
if (dlgShown == false)
{
MessageBox.Show(Resources.ShelveFileDlg_NoShelveableFilesWarning, Resources.PerforceSCM, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
/// <summary>
/// Constructor</summary>
/// <param name="uri">URI for source controlled resource</param>
/// <param name="status">Source control status of resource</param>
public SourceControlEventArgs(Uri uri, SourceControlStatus status)
{
Uri = uri;
Status = status;
}
public static void SetCachedStatus(DocumentReference item, SourceControlStatus status)
{
SourceControlStatusCache.SetCachedStatusInternal(item, status);
SourceControlStatusCache.OnStatusUpdated();
}
public FileInfo(Uri uri, SourceControlStatus status)
{
Uri = uri;
Status = status;
}
/// <summary>
/// Gets source control status icon</summary>
/// <param name="uri">File URI</param>
/// <param name="status">Source control status</param>
/// <returns>Source control status icon image</returns>
public override Image GetSourceControlStatusIcon(Uri uri, SourceControlStatus status)
{
Image result = null;
switch (status)
{
case SourceControlStatus.Added:
result = m_statusImages[P4VFileAdd];
break;
case SourceControlStatus.CheckedIn:
{
if (IsSynched(uri))
{
FileInfo info = GetInfo(uri);
if (string.IsNullOrEmpty(info.OtherLock))
result = m_statusImages[P4VFileSync];
else
result = m_statusImages[P4VFileLockOther];
}
else
result = m_statusImages[P4VFileNotsync];
break;
}
case SourceControlStatus.CheckedOut:
{
FileInfo info = GetInfo(uri);
if (info.IsLocked)
result = m_statusImages[P4VFileLock];
else
result = m_statusImages[P4VFileEditHead];
break;
}
case SourceControlStatus.NotControlled:
result = m_statusImages[P4VFileWs];
break;
}
return result;
}
/// <summary>
/// Constructor</summary>
/// <param name="uri">File URI</param>
/// <param name="status">Source control status</param>
public SourceControlFileInfo(Uri uri, SourceControlStatus status)
{
Uri = uri;
Status = status;
OtherUsers = EmptyEnumerable<string>.Instance;
}
/// <summary>
/// Gets source control status icon</summary>
/// <param name="uri">File URI</param>
/// <param name="status">Source control status</param>
/// <returns>Source control status icon image</returns>
public virtual Image GetSourceControlStatusIcon(Uri uri, SourceControlStatus status)
{
return(null);
}
/// <summary>
/// Gets source control staus icon
/// </summary>
/// <param name="uri">file uri</param>
/// <param name="status">source control status</param>
/// <returns></returns>
public virtual Image GetSourceControlStatusIcon(Uri uri, SourceControlStatus status)
{
return null;
}
/// <summary>
/// Constructor</summary>
/// <param name="uri">URI for source controlled resource</param>
/// <param name="status">Source control status of resource</param>
public SourceControlEventArgs(Uri uri, SourceControlStatus status)
{
Uri = uri;
Status = status;
}
/// <summary>
/// Constructor</summary>
/// <param name="uri">File URI</param>
/// <param name="status">Source control status</param>
public SourceControlFileInfo(Uri uri, SourceControlStatus status)
{
Uri = uri;
Status = status;
OtherUsers = EmptyEnumerable <string> .Instance;
}
