private void onProjectOpened(ProjectEventArgs obj)
{
//subscribe to edit completed event
//this is across all maps and layers in the project
EditCompletedEvent.Subscribe(onEditCompleted);
//subscribe to row events for a certain layer in a certain map
//look for a map named 'Layers' in the project
var mapProjItem = Project.Current.GetItems<MapProjectItem>().FirstOrDefault(item => item.Name == "Layers");
if (mapProjItem == null)
return;
//run on MCT
QueuedTask.Run(() =>
{
var theMap = mapProjItem.GetMap();
//look for a layer named 'Parcels' in the map
var featLayer = theMap.FindLayers("Parcels").FirstOrDefault() as FeatureLayer;
if (featLayer == null)
return;
var layerTable = featLayer.GetTable();
//setup row events
_rowCreateToken = RowCreatedEvent.Subscribe(onRowCreateEvent, layerTable);
_rowDeleteToken = RowDeletedEvent.Subscribe(onRowDeleteEvent, layerTable);
_rowChangedToken = RowChangedEvent.Subscribe(onRowChangedEvent, layerTable);
});
}
/// <summary>
/// Clear out the configuration
/// </summary>
/// <param name="args"></param>
private void OnProjectOpened(ProjectEventArgs args)
{
Maps.Clear();
FeatureLayers.Clear();
Fields.Clear();
Prefix = string.Empty;
Suffix = string.Empty;
FileExtension = string.Empty;
FileWorkspace = string.Empty;
}
public void CloseProject()
{
ProjectAvailableEventArgs preCloseEventArgs = new ProjectAvailableEventArgs(_current);
_eventAggregator.GetEvent <ProjectPreCloseEvent>().Publish(preCloseEventArgs);
_current = null;
ProjectEventArgs closedEventArgs = new ProjectEventArgs(_packageService.Current.PackageFile);
_eventAggregator.GetEvent <ProjectClosedEvent>().Publish(closedEventArgs);
}
private void PythonProjectReferenceNode_ProjectLoaded(object sender, ProjectEventArgs e)
{
if (ProjectMgr.IsClosing)
{
return;
}
InitializeFileChangeListener();
AddAnalyzedAssembly(((PythonProjectNode)ProjectMgr).GetAnalyzer()).DoNotWait();
ProjectMgr.OnInvalidateItems(Parent);
}
private void Sinks_ProjectRemoved(object sender, ProjectEventArgs e)
{
if (!e.Project.VBE.IsInDesignMode)
{
return;
}
Debug.Assert(e.ProjectId != null);
OnParseRequested(sender);
}
void ProjectEventChanged(ProjectEventArgs args)
{
if (args.Action == ProjectAction.Close)
{
if (udpSocket.RunningFlag)
{
udpSocket.UDPClose();
}
}
}
private void Sinks_ProjectAdded(object sender, ProjectEventArgs e)
{
if (!e.Project.VBE.IsInDesignMode)
{
return;
}
Logger.Debug("Project '{0}' was added.", e.ProjectId);
OnParseRequested(sender);
}
private void ProjectManager_ProjectOpened(object sender, ProjectEventArgs e)
{
IProjectContext projectContext = (IProjectContext)ProjectXamlContext.GetProjectContext(e.Project);
if (projectContext == null)
{
return;
}
this.AddProjectContextHandlers(projectContext);
}
private void Project2_ProjectLoaded(ProjectEventArgs e)
{
ServerName = e.ServerName;
ProjectName = e.ProjectName;
gbApproval.Enabled = true;
GetRequestStatus();
GetApprovalStatus();
}
private void OnProjectClosed(object sender, ProjectEventArgs e)
{
IXamlProject xamlProject = e.Project as IXamlProject;
if (xamlProject == null || xamlProject.ProjectContext == null || this.activeProject != xamlProject.ProjectContext)
{
return;
}
this.OnProjectDeactivating();
this.cachedProjectProviders.Remove(xamlProject.ProjectContext);
}
private void OnProjectOpen(ProjectEventArgs obj)
{
if (!hasSettings)
{
_moduleSettings.Clear();
}
//get dsn settings from the local odbc settings and use those for the connectionitems
//List<string> enumdsn = EnumDsn();
//ListODBCsources();
}
private void OnProjectClosed(object sender, ProjectEventArgs e)
{
ICodeProject codeProject;
if (!this.projectDictionary.TryGetValue(e.Project, out codeProject))
{
return;
}
codeProject.Dispose();
this.projectDictionary.Remove(e.Project);
}
private void Sinks_ProjectAdded(object sender, ProjectEventArgs e)
{
if (!e.Project.VBE.IsInDesignMode)
{
return;
}
Logger.Debug("Project '{0}' was added.", e.ProjectId);
RefreshProjects(_vbe); // note side-effect: assigns ProjectId/HelpFile
OnParseRequested(sender);
}
void ProjectCreated(object sender, ProjectEventArgs e)
{
if (!AddInOptions.AutomaticallyAddFiles)
{
return;
}
if (!CanBeVersionControlledFile(e.Project.Directory))
{
return;
}
string projectDir = Path.GetFullPath(e.Project.Directory);
try {
using (SvnClientWrapper client = new SvnClientWrapper()) {
SvnMessageView.HandleNotifications(client);
Status status = client.SingleStatus(projectDir);
if (status.TextStatus != StatusKind.Unversioned)
{
return;
}
client.Add(projectDir, Recurse.None);
if (FileUtility.IsBaseDirectory(Path.Combine(projectDir, "bin"), e.Project.OutputAssemblyFullPath))
{
client.AddToIgnoreList(projectDir, "bin");
}
CompilableProject compilableProject = e.Project as CompilableProject;
if (compilableProject != null)
{
if (FileUtility.IsBaseDirectory(Path.Combine(projectDir, "obj"), compilableProject.IntermediateOutputFullPath))
{
client.AddToIgnoreList(projectDir, "obj");
}
}
foreach (ProjectItem item in e.Project.Items)
{
FileProjectItem fileItem = item as FileProjectItem;
if (fileItem != null)
{
if (FileUtility.IsBaseDirectory(projectDir, fileItem.FileName))
{
AddFileWithParentDirectoriesToSvn(client, fileItem.FileName);
}
}
}
AddFileWithParentDirectoriesToSvn(client, e.Project.FileName);
}
} catch (SvnClientException ex) {
MessageService.ShowError(ex.Message);
} catch (Exception ex) {
MessageService.ShowException(ex, "Project add exception");
}
}
void SetProjectTitle(object sender, ProjectEventArgs e)
{
if (e.Project != null)
{
Title = e.Project.Name + " - " + ResourceService.GetString("MainWindow.DialogName");
}
else
{
Title = ResourceService.GetString("MainWindow.DialogName");
}
}
/// <summary>
/// Clear out the configuration
/// </summary>
/// <param name="args"></param>
private void OnProjectOpened(ProjectEventArgs args)
{
Maps.Clear();
FeatureLayers.Clear();
Fields.Clear();
_FileList.Clear();
Prefix = string.Empty;
Suffix = string.Empty;
FileExtension = string.Empty;
FileWorkspace = string.Empty;
FileLoadingMethod = EnumFileLoadingMethod.None;
}
/// <summary>
/// Clear out the configuration
/// </summary>
/// <param name="args"></param>
private void OnProjectOpened(ProjectEventArgs args)
{
Maps.Clear();
FeatureLayers.Clear();
Fields.Clear();
_fileList.Clear();
Prefix = string.Empty;
Suffix = string.Empty;
FileWorkspace = string.Empty;
DestinationWorkspace = string.Empty;
FileCloningMethod = EnumFileCloningMethod.None;
}
private void model_ProjectUpdated(object sender,
ProjectEventArgs e)
{
GetProject(e.Project.ID).Update(e.Project);
if (SelectedProject != null &&
e.Project.ID == SelectedProject.ID)
{
SelectedProject.Update(e.Project);
DetailsEstimateStatus =
SelectedProject.EstimateStatus;
}
}
private void onProjectClosed(ProjectEventArgs obj)
{
//Unsubscribe from events
EditCompletedEvent.Unsubscribe(onEditCompleted);
QueuedTask.Run(() =>
{
RowCreatedEvent.Unsubscribe(_rowCreateToken);
RowDeletedEvent.Unsubscribe(_rowDeleteToken);
RowChangedEvent.Unsubscribe(_rowChangedToken);
});
}
private void model_ProjectUpdated(object sender,
ProjectEventArgs e)
{
GetProject(e.Project.ID).Update(e.Project);
if (SelectedProject == null || e.Project.ID != SelectedProject.ID)
{
return;
}
SelectedProject.Update(e.Project);
DetailsEstimateStatus = SelectedProject.EstimateStatus;
}
void model_ProjectUpdated(object sender, ProjectEventArgs e)
{
int selectedProjectId = GetSelectedProjectId();
if (selectedProjectId > NONE_SELECTED)
{
if (selectedProjectId == e.Project.ID)
{
UpdateDetails(e.Project);
}
}
}
private void Sinks_ProjectRemoved(object sender, ProjectEventArgs e)
{
if (!_vbe.IsInDesignMode)
{
return;
}
Debug.Assert(e.ProjectId != null);
DisposeProjectDeclarations(e.ProjectId);
OnParseRequested(sender);
}
private void OnProjectClose(ProjectEventArgs obj)
{
//hasSettings = false;
//if (API_KEY != null)
//{
// if (!String.IsNullOrEmpty(API_KEY.EMAIL_Value))
// {
// Analytics.Client.Identify(API_KEY.EMAIL_Value, new Traits() { });
// MessageBox.Show("Please be aware that sharing ArcGIS Pro projects may expose your Planet api key if the projects contains Planet map layers.");
// }
//}
}
private async Task OnProjectSavingAsync(ProjectEventArgs arg)
{
await Task.Run(() =>
{
FileSystemUtils.EnsureFolderExists(GetLocalWorklistsFolder());
foreach (IWorkList workList in GetWorklists())
{
workList.Commit();
}
});
}
private void OnProjectLoaded(object sender, ProjectEventArgs e)
{
var pyProj = PythonProject.FromObject(e.Project);
if (pyProj != null)
{
var analyzer = pyProj.Analyzer;
_projectInfo[pyProj] = new ProjectInfo(this, pyProj);
}
TestContainersUpdated?.Invoke(this, EventArgs.Empty);
}
private async Task OnProjectSavingAsync(ProjectEventArgs arg)
{
// todo daro: revise usage of Task
await Task.Run(() =>
{
EnsureFolderExists(GetLocalWorklistsFolder());
foreach (IWorkList workList in _layerByWorkList.Keys)
{
workList.Commit();
}
});
}
private void EventListener_ProjectLoaded(object sender, ProjectEventArgs e)
{
Guid proj;
if (ErrorHandler.Succeeded(((IVsHierarchy)e.Project).GetGuidProperty(
(uint)VSConstants.VSITEMID.Root,
(int)__VSHPROPID.VSHPROPID_ProjectIDGuid,
out proj
)) && ReferencedProjectGuid == proj)
{
Invalidate();
}
}
private void OnProjectLoaded(object sender, ProjectEventArgs e)
{
if (e.Project != null)
{
string root = null;
try
{
root = e.Project.GetProjectHome();
}
catch (Exception ex)
{
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Warning("TestContainerDiscoverer: Failed to get project home {0}", ex);
}
// If we fail to get ProjectHome, we still want to track the
// project. We just won't get the benefits of merging
// watchers into a single recursive watcher.
}
string path;
if (e.Project.TryGetProjectPath(out path) &&
!_knownProjects.ContainsKey(path))
{
var dteProject = ((IVsHierarchy)e.Project).GetProject();
var projectInfo = new ProjectInfo(
e.Project,
this
);
_knownProjects.Add(path, projectInfo);
foreach (var p in e.Project.GetProjectItemPaths())
{
if (!string.IsNullOrEmpty(root) && CommonUtils.IsSubpathOf(root, p))
{
_testFilesUpdateWatcher.AddDirectoryWatch(root);
_fileRootMap[p] = root;
}
else
{
_testFilesUpdateWatcher.AddWatch(p);
}
}
}
}
OnTestContainersChanged(e.Project);
}
private void OnProjectLoaded(object sender, ProjectEventArgs e)
{
// We delay project test discovery until test explorer requests tests.
// But if a project is loaded after SetupSolution() runs, we still need to update.
if (!_setupComplete)
{
return;
}
if (LoadProject(e.Project))
{
NotifyContainerChanged();
}
}
private void OnProjectOpened(ProjectEventArgs obj) //Project Opened event handler
{
//do on open...
var EMEInstall = new EMEInstall();
EMEInstall.DirectionsDir();
EMEInstall.CheckUSEPADir();
// check last sync, sync with online if needed
var AsyncContacts = new AsyncContacts();
AsyncContacts.LoadContactsAsync(checksyncage: true);
EMEInstall.CopyEMEToolbox();
}
/// <summary>
/// Called when a project is loaded.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="ProjectEventArgs"/> instance containing the event data.</param>
private void OnProjectLoaded(
object sender,
ProjectEventArgs e)
{
// Set up the line buffer for the loaded project.
var projectLineBuffer = new ProjectLineBuffer(e.Project, editorView);
editorView.SetLineBuffer(projectLineBuffer);
commandController.Project = e.Project;
commandController.ProjectLineBuffer = projectLineBuffer;
// Update the GUI element.
UpdateGuiState();
}
public void SetUp()
{
NUnitProject.ProjectSeed = 0;
project = NUnitProject.EmptyProject();
project.Changed += new ProjectEventHandler( OnProjectChanged );
lastEvent = null;
}
private void workspace_ProjectAdded(object sender, ProjectEventArgs e)
{
AddProject(e.Project);
}
/// <summary>
/// Project opened event.
/// </summary>
/// <remarks>
/// This is necessary because OnReadStateAsync is NOT called if a project does not contain the module settings. This provides a way to restore the settings to
/// default when a project not containing our settings is opened.
/// </remarks>
/// <param name="args">project opened event arguments</param>
private void OnProjectOpen(ProjectEventArgs args)
{
// if flag has not been set then we didn't enter OnReadStateAsync - and we want to restore the module settings to default
if (!hasSettings)
_moduleSettings.Clear();
}
private void workspace_ProjectRemoved(object sender, ProjectEventArgs e)
{
RemoveProject(e.Project);
}
void ProjectService_ProjectRemoved(object sender, ProjectEventArgs e)
{
if (e.Project == project && this.WorkbenchWindow != null)
WorkbenchWindow.CloseWindow(true);
}
/// <summary>
/// Project closed event. Make sure we reset the settings flag.
/// </summary>
/// <param name="args">project closed event arguments</param>
private void OnProjectClosed(ProjectEventArgs args)
{
// reset the flag
hasSettings = false;
}
private void onProjectClosed(ProjectEventArgs obj)
{
//Unsubscribe from events
EditCompletedEvent.Unsubscribe(onEditCompleted);
QueuedTask.Run(() =>
{
RowCreatedEvent.Unsubscribe(_rowCreateToken);
RowDeletedEvent.Unsubscribe(_rowDeleteToken);
RowChangedEvent.Unsubscribe(_rowChangedToken);
});
}
private void EhProjectChanged(object sender, ProjectEventArgs e)
{
if (!string.IsNullOrEmpty(e.NewName) && e.ProjectEventKind != ProjectEventKind.ProjectDirtyChanged)
_reporter.WriteLine("Project changed: Type: {0}; fileName: {1}", e.ProjectEventKind, e.NewName);
}
private void OnProjectChanged( object sender, ProjectEventArgs e )
{
lastEvent = e;
}
