private void ProjectManager_ProjectChanged(object sender, ProjectChangedEventArgs e)
{
switch (e.Type)
{
case ProjectChangedType.Closed:
ClearDefaultCodecHeaders();
break;
case ProjectChangedType.FileDeleted:
IInputFile inputFile = e.Item as InputFile;
if (inputFile != null)
{
List <CodecID> toRemoveKeys = new List <CodecID>();
foreach (KeyValuePair <CodecID, IResultNode> keyPair in _codecHeaderSource)
{
if (keyPair.Value != null && keyPair.Value.InputFile == inputFile)
{
toRemoveKeys.Add(keyPair.Key);
}
}
foreach (CodecID codecId in toRemoveKeys)
{
RemoveDefaultCodecHeader(codecId);
}
}
break;
}
}
private void Workspace_CurrentChanged(object sender, ProjectChangedEventArgs e)
{
Title = e.NewProject.Name;
HighlightChangedCells(TaskDataGrid, e.Changes.ChangedTasks);
HighlightChangedCells(ResourceDataGrid, e.Changes.ChangedResources);
HighlightChangedCells(AssignmentDataGrid, e.Changes.ChangedAssignments);
}
private void projectManager_ProjectChanged(object sender, ProjectChangedEventArgs e)
{
if (IsDisposed || Disposing)
{
return;
}
bool scanState = _fullFileScanner.IsBusy;
switch (e.Type)
{
case ProjectChangedType.FileDeleted:
if (scanState)
{
StopKeyframeScanByUser();
}
RemoveRowByInputFile((IInputFile)e.Item);
if (scanState)
{
StartKeyframeScan();
}
break;
case ProjectChangedType.Closed:
if (scanState)
{
StopKeyframeScanByUser();
}
RemoveAllFiles();
break;
}
}
/// <summary>
/// Called when a file system watcher notices a new book (or some similar change) in our downloaded books folder.
/// This will happen on a thread-pool thread.
/// Since we are updating the UI in response we want to deal with it on the main thread.
/// This also has the effect that it can't happen in the middle of another LoadSourceCollectionButtons().
/// </summary>
/// <param name="sender"></param>
/// <param name="eventArgs"></param>
private void DownLoadedBooksChanged(object sender, ProjectChangedEventArgs eventArgs)
{
Invoke((Action)(() =>
{
// We may notice a change to the downloaded books directory before the other Bloom instance has finished
// copying the new book there. Finishing should not take long, because the download is done...at worst
// we have to copy the book on our own filesystem. Typically we only have to move the directory.
// As a safeguard, wait half a second before we update things.
if (_newDownloadTimer != null)
{
// Things changed again before we started the update! Forget the old update and wait until things
// are stable for the required interval.
_newDownloadTimer.Stop();
_newDownloadTimer.Dispose();
}
_newDownloadTimer = new Timer();
_newDownloadTimer.Tick += (o, args) =>
{
_newDownloadTimer.Stop();
_newDownloadTimer.Dispose();
_newDownloadTimer = null;
UpdateDownloadedBooks(eventArgs.Path);
};
_newDownloadTimer.Interval = 500;
_newDownloadTimer.Start();
}));
}
/// <summary>
/// Raises the <c>ProjectChanged</c> event
/// </summary>
/// <param name="e">the event args for the <c>ProjectChanged</c> event</param>
private void OnProjectChanged(object sender, ProjectChangedEventArgs e)
{
if (ProjectChanged != null)
{
ProjectChanged(sender, e);
}
}
public override void RefreshOnProjectChanged(ProjectChangedEventArgs args)
{
TimeUntilNextRun = Project.Frequency;
Timer.Change(0, 1000);
HashSet <DateTime> currentDates = new HashSet <DateTime>();
foreach (TreeItemFolderViewModel folder in TestFolders)
{
currentDates.Add(folder.Date.Date);
}
foreach (TestResult result in args.AddedTests)
{
if (!currentDates.Contains(result.DateOfTesting.Date))
{
currentDates.Add(result.DateOfTesting.Date);
TestFolders.Add(new TreeItemFolderViewModel(result.DateOfTesting, new List <TestResult>()));
}
}
foreach (TreeItemFolderViewModel folder in TestFolders)
{
folder.RefreshOnProjectChanged(args);
}
}
// Change or merge this with your existing function
private void backgroundWorker1_ProgressChanged(object sender, ProjectChangedEventArgs e)
{
var temp = ProgressChanged;
if (temp != null)
{
temp(this, e);
}
}
public void ProjectChanged(object sender, ProjectChangedEventArgs e)
{
if (_eventArgs != null)
{
throw new InvalidOperationException("Unexpected ProjectChanged event.");
}
_eventArgs = e;
}
private void ProjectChanged(object sender, ProjectChangedEventArgs e)
{
switch (e.Type)
{
case ProjectChangedType.FileDeleted:
case ProjectChangedType.Closed:
ClearWindow();
break;
}
}
/// <summary>
/// Raises the <c>ProjectChanged</c> event
/// </summary>
/// <param name="e">the event args for the <c>ProjectChanged</c> event</param>
private void OnProjectChanged(ProjectChangedEventArgs e)
{
if (_isSuspended)
{
_lastProjectChangedEventArgs = e;
}
else if (ProjectChanged != null)
{
ProjectChanged(this, e);
}
}
public void ProjectChangedSetMetadata()
{
With.Mocks(_mockRepository).Expecting(delegate
{
var e = new ProjectChangedEventArgs(ProjectChangedType.MetadataChanged);
_projectChangedEventHandler.Expect(x => x(_project, e));
}).Verify(delegate
{
_project.ProjectChanged += _projectChangedEventHandler;
_project.SetMetadata(_fullMetadata);
});
}
public void ProjectChangedSetFileName()
{
With.Mocks(_mockRepository).Expecting(delegate
{
var e = new ProjectChangedEventArgs(ProjectChangedType.FileNameChanged, EmptyProjectFileName);
_projectChangedEventHandler.Expect(x => x(_project, e));
}).Verify(delegate
{
_project.ProjectChanged += _projectChangedEventHandler;
_project.FileName = EmptyProjectFileName;
});
}
public void ProjectChangedAddFile()
{
With.Mocks(_mockRepository).Expecting(delegate
{
var e = new ProjectChangedEventArgs(ProjectChangedType.FileAdded, _inputFile1);
_projectChangedEventHandler.Expect(x => x(_project, e));
}).Verify(delegate
{
_project.ProjectChanged += _projectChangedEventHandler;
_project.AddFile(FileName1, OneDetector);
});
}
private void ProjectChanged(object sender, ProjectChangedEventArgs e)
{
switch (e.Type)
{
case ProjectChangedType.FileDeleted:
case ProjectChangedType.Closed:
if (_previewWindow != null)
{
ClearWindow();
}
break;
}
}
public void ProjectChangedSetVisibleColumns()
{
With.Mocks(_mockRepository).Expecting(delegate
{
var e = new ProjectChangedEventArgs(ProjectChangedType.VisibleColumnsChanged, _detector1);
_projectChangedEventHandler.Expect(x => x(_project, e));
}).Verify(delegate
{
_project.AddFile(FileName1, OneDetector);
_project.ProjectChanged += _projectChangedEventHandler;
_project.SetVisibleColumns(_detector1, TwoColumns);
});
}
public void ProjectChangedDeleteDataBlock()
{
With.Mocks(_mockRepository).Expecting(delegate
{
var e = new ProjectChangedEventArgs(ProjectChangedType.DataBlockDeleted, _dataBlock1);
_projectChangedEventHandler.Expect(x => x(_project, e));
}).Verify(delegate
{
_project.AddFile(FileName1, OneDetector);
_project.AddDataBlock(_dataBlock1);
_project.ProjectChanged += _projectChangedEventHandler;
_project.DeleteDataBlock(_dataBlock1);
});
}
private void ProviderValue_ProjectChanged(object sender, ProjectChangedEventArgs e)
{
string filename = e.Project as string;
if (filename == null)
{
var proj = e.Project as MSBuild.Project;
if (proj != null)
{
filename = proj.FullPath;
}
}
RediscoverInterpreters(filename);
}
public override void RefreshOnProjectChanged(ProjectChangedEventArgs args)
{
foreach (TestResult added in args.AddedTests)
{
if (added.DateOfTesting.Date == Date.Date)
{
TestResults.Add(new TreeItemTestResultViewModel(added));
}
}
foreach (TestResult removed in args.RemovedTests)
{
// Might need to expose the TestResult instance in the view model so we can compare it?
Debug.Fail("TODO");
}
}
void solutionMonitor_ProjectChanged(object sender, ProjectChangedEventArgs e)
{
switch (e.ChangeType)
{
case ProjectChangeType.Loaded:
RemoveProjectFromCache(e.Project);
var containers = DiscoverTestContainers(e.Project);
foreach (var container in containers)
{
AddContainerToCache(container, e.Project);
}
break;
case ProjectChangeType.Unloaded:
RemoveProjectFromCache(e.Project);
break;
}
OnTestContainersUpdated();
}
private void Project_ProjectChanged(object sender, ProjectChangedEventArgs e)
{
switch (e.Type)
{
case ProjectChangedType.FileDeleted:
case ProjectChangedType.DataBlockDeleted:
{
Row row = FindRow(e.Item);
if (row.HasFocus)
{
SetFocusRow(row.ParentRow, false);
}
row.ParentRow.UpdateChildren(true, false);
}
break;
case ProjectChangedType.FileAdded:
{
RootRow.UpdateChildren(true, false);
}
break;
case ProjectChangedType.DataBlockAdded:
{
Row row = FindRow(((IDataBlock)e.Item).InputFile);
if (row != null)
{
row.UpdateChildren(true, false);
}
else
{
RootRow.UpdateChildren(true, false);
}
}
break;
}
}
/// <summary>
/// Handles the ProjectChanged event of the <see cref="ProjectManager"/> object.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="ProjectChangedEventArgs"/> instance containing the event data.</param>
private void ProjectChanged(object sender, ProjectChangedEventArgs e)
{
}
private void Workspace_CurrentChanged(object sender, ProjectChangedEventArgs e)
{
Update(e.NewProject, e.Changes);
}
/// <summary>
/// 控制保存按钮
/// </summary>
/// <param name="sender"></param>
/// <param name="arg"></param>
private void _pnlLeft_OnChanged(object sender, ProjectChangedEventArgs arg)
{
btnSave.Enabled = arg.Chnaged;
}
public void SuspendProjectChangeNotification()
{
_isSuspended = true;
_lastProjectChangedEventArgs = null;
}
public abstract void RefreshOnProjectChanged(ProjectChangedEventArgs args);
/// <summary>
/// 提供地址选项
/// </summary>
/// <param name="sender"></param>
/// <param name="arg"></param>
private void _model_OnChanged(object sender, ProjectChangedEventArgs arg)
{
IniliazeCombox(_model.ProjectModel);
}
public void Clear()
{
_eventArgs = null;
}
private void OnProgressChanged(object sender, ProjectChangedEventArgs e)
{
//ToDo: Update whatever you like in your MainWindow
}
public override void RefreshOnProjectChanged(ProjectChangedEventArgs args)
{
// No-op
}
/// <summary>
/// Handles the ProjectChanged event of the <see cref="ProjectManager"/> object.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="ProjectChangedEventArgs"/> instance containing the event data.</param>
private void ProjectChanged(object sender, ProjectChangedEventArgs e)
{
_projectName = e.Project.Name;
projectNode.Text = _projectName;
}
