com.intellij.openapi.roots.ModuleRootEvent Java Examples

@Inject
public RunManagerImpl(@Nonnull Project project, @Nonnull ProjectPropertiesComponent propertiesComponent) {
  myConfig = new RunManagerConfig(propertiesComponent);
  myProject = project;

  initializeConfigurationTypes(ConfigurationType.CONFIGURATION_TYPE_EP.getExtensions());
  myProject.getMessageBus().connect(myProject).subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter() {
    @Override
    public void rootsChanged(ModuleRootEvent event) {
      RunnerAndConfigurationSettings configuration = getSelectedConfiguration();
      if (configuration != null) {
        myIconCheckTimes.remove(configuration.getUniqueID());//cache will be expired
      }
    }
  });
}
 

@Override
public void rootsChanged(@Nonnull final ModuleRootEvent event) {
  myFileManager.dispatchPendingEvents();

  if (event.isCausedByFileTypesChange()) return;
  runExternalAction(() -> {
    depthCounter--;
    assert depthCounter >= 0 : depthCounter;
    if (depthCounter > 0) return;

    DebugUtil.performPsiModification(null, () -> myFileManager.possiblyInvalidatePhysicalPsi());

    PsiTreeChangeEventImpl treeEvent = new PsiTreeChangeEventImpl(myManager);
    treeEvent.setPropertyName(PsiTreeChangeEvent.PROP_ROOTS);
    myManager.propertyChanged(treeEvent);
  });
}
 

private void doViewSwitch(@NotNull ExternalSystemTaskId id, @NotNull String projectPath) {
  Project ideProject = id.findProject();
  if (ideProject == null) {
    return;
  }
  // Disable zooming on subsequent project resolves/refreshes,
  // i.e. a project that already has existing modules, because it may zoom at a module
  // that is going to be replaced by the current resolve.
  if (ModuleManager.getInstance(ideProject).getModules().length > 0) {
    return;
  }

  MessageBusConnection messageBusConnection = ideProject.getMessageBus().connect();
  messageBusConnection.subscribe(
    ProjectTopics.PROJECT_ROOTS,
    new ModuleRootListener() {
      @Override
      public void rootsChanged(ModuleRootEvent event) {
        // Initiate view switch only when project modules have been created.
        new ViewSwitchProcessor(ideProject, projectPath).asyncViewSwitch();
      }
    }
  );
}
 

/**
 * The constructor
 *
 * @param module the module to analyze
 */
public AnalyzeDependenciesComponent(Module module) {
  myModule = module;
  mySettings = AnalyzeDependenciesSettings.getInstance(myModule.getProject());
  initTree();
  init();
  getSplitter().setProportion(0.3f);
  myMessageBusConnection = myModule.getProject().getMessageBus().connect();
  myMessageBusConnection.subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter() {
    @Override
    public void rootsChanged(ModuleRootEvent event) {
      myClasspaths.clear();
      updateTree();
    }
  });
}
 

@Override
public void projectOpened() {
  MessageBusConnection connection = myProject.getMessageBus().connect(myProject);
  connection.subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter() {
    @Override
    public void rootsChanged(ModuleRootEvent event) {
      ApplicationManager.getApplication().invokeLater(new Runnable() {
        @Override
        public void run() {
          if (myProject.isDisposed()) return;
          VcsDirtyScopeManager.getInstance(myProject).markEverythingDirty();
        }
      }, ModalityState.NON_MODAL);
    }
  });
  connection.subscribe(ProblemListener.TOPIC, new MyProblemListener());
}
 

@Inject
public CSharpPartialElementManager(@Nonnull Project project)
{
	myProject = project;
	project.getMessageBus().connect().subscribe(PsiManagerImpl.ANY_PSI_CHANGE_TOPIC, new AnyPsiChangeListener.Adapter()
	{
		@Override
		public void beforePsiChanged(boolean isPhysical)
		{
			myCache.clear();
		}
	});

	project.getMessageBus().connect().subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter()
	{
		@Override
		public void rootsChanged(ModuleRootEvent event)
		{
			myCache.clear();
		}
	});
}
 

private ORProjectRootListener(@NotNull Project project) {
    project.getMessageBus().
            connect(project).
            subscribe(PROJECT_ROOTS, new ModuleRootListener() {
                @Override
                public void rootsChanged(@NotNull ModuleRootEvent event) {
                    DumbService.getInstance(project).queueTask(new DumbModeTask() {
                        @Override
                        public void performInDumbMode(@NotNull ProgressIndicator indicator) {
                            if (!project.isDisposed()) {
                                indicator.setText("Updating resource repository roots");
                                // should be done per module
                                //ModuleManager moduleManager = ModuleManager.getInstance(project);
                                //for (Module module : moduleManager.getModules()) {
                                //    moduleRootsOrDependenciesChanged(module);
                                //}
                                Sdk projectSdk = ProjectRootManager.getInstance(project).getProjectSdk();
                                if (projectSdk != null && projectSdk.getSdkType() instanceof OCamlSdkType) {
                                    OCamlSdkType.reindexSourceRoots(projectSdk);
                                }
                            }
                        }
                    });
                }
            });
}
 

@Override
protected void setUp() throws Exception {
  super.setUp();
  if (useExternalCompiler()) {
    myProject.getMessageBus().connect(myTestRootDisposable).subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter() {
      @Override
      public void rootsChanged(ModuleRootEvent event) {
        //todo[nik] projectOpened isn't called in tests so we need to add this listener manually
        forceFSRescan();
      }
    });
    // CompilerTestUtil.enableExternalCompiler(myProject);
  }
  else {
    // CompilerTestUtil.disableExternalCompiler(myProject);
  }
}
 

@Override
public void rootsChanged(ModuleRootEvent event) {
  if (myScheduled) return;
  myScheduled = true;

  UIAccess uiAccess = UIAccess.get();
  DumbService.getInstance(myProject).runWhenSmart(() -> {
    myScheduled = false;
    handleRootChange(uiAccess);
  });
}
 

@Override
public void beforeRootsChange(@Nonnull final ModuleRootEvent event) {
  if (event.isCausedByFileTypesChange()) return;
  runExternalAction(() -> {
    depthCounter++;
    if (depthCounter > 1) return;

    PsiTreeChangeEventImpl treeEvent = new PsiTreeChangeEventImpl(myManager);
    treeEvent.setPropertyName(PsiTreeChangeEvent.PROP_ROOTS);
    myManager.beforePropertyChange(treeEvent);
  });
}
 

public UnindexedFilesUpdater(final Project project) {
  myProject = project;
  myPusher = PushedFilePropertiesUpdater.getInstance(myProject);
  project.getMessageBus().connect(this).subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootListener() {
    @Override
    public void rootsChanged(@Nonnull ModuleRootEvent event) {
      DumbService.getInstance(project).cancelTask(UnindexedFilesUpdater.this);
    }
  });
}
 

@Inject
public LogicalRootsManagerImpl(final ModuleManager moduleManager, final Project project) {
  myModuleManager = moduleManager;
  myProject = project;

  final MessageBusConnection connection = project.getMessageBus().connect();
  connection.subscribe(LOGICAL_ROOTS, new LogicalRootListener() {
    @Override
    public void logicalRootsChanged() {
      clear();
      //updateCache(moduleManager);
    }
  });
  connection.subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter() {
    @Override
    public void rootsChanged(ModuleRootEvent event) {
      project.getMessageBus().syncPublisher(LOGICAL_ROOTS).logicalRootsChanged();
    }
  });
  registerLogicalRootProvider(LogicalRootType.SOURCE_ROOT, new NotNullFunction<Module, List<VirtualFileLogicalRoot>>() {
    @Override
    @Nonnull
    public List<VirtualFileLogicalRoot> fun(final Module module) {
      return ContainerUtil.map2List(ModuleRootManager.getInstance(module).getContentFolderFiles(ContentFolderScopes.productionAndTest()), new Function<VirtualFile, VirtualFileLogicalRoot>() {
        @Override
        public VirtualFileLogicalRoot fun(final VirtualFile s) {
          return new VirtualFileLogicalRoot(s);
        }
      });
    }
  });
}
 

@Override
public void rootsChanged(ModuleRootEvent event) {
  for (Pair<String, VcsDirectoryMapping> mapping : myMappingsForRemovedModules) {
    promptRemoveMapping(mapping.first, mapping.second);
  }
  // the check calculates to true only before user has done any change to mappings, i.e. in case modules are detected/added automatically
  // on start etc (look inside)
  if (myVcsManager.needAutodetectMappings()) {
    autoDetectVcsMappings(false);
  }
}
 

@Override
public void projectOpened(final Project project, UIAccess uiAccess) {
  String path = getProjectPath(project);
  if (path != null) {
    markPathRecent(path, project);
  }
  SystemDock.getInstance().updateMenu();

  project.getMessageBus().connect().subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootListener() {
    @Override
    public void rootsChanged(ModuleRootEvent event) {
      updateProjectModuleExtensions(project);
    }
  });
}
 

@Inject
public EditorNotificationsImpl(Project project) {
  myProject = project;
  myUpdateMerger = new MergingUpdateQueue("EditorNotifications update merger", 100, true, null, project);
  MessageBusConnection connection = project.getMessageBus().connect(project);
  connection.subscribe(FileEditorManagerListener.FILE_EDITOR_MANAGER, new FileEditorManagerListener() {
    @Override
    public void fileOpened(@Nonnull FileEditorManager source, @Nonnull VirtualFile file) {
      updateNotifications(file);
    }
  });
  connection.subscribe(DumbService.DUMB_MODE, new DumbService.DumbModeListener() {
    @Override
    public void enteredDumbMode() {
      updateAllNotifications();
    }

    @Override
    public void exitDumbMode() {
      updateAllNotifications();
    }
  });
  connection.subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootListener() {
    @Override
    public void rootsChanged(ModuleRootEvent event) {
      updateAllNotifications();
    }
  });
}
 

private void addProjectListeners() {
  project.getMessageBus().connect().subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootListener() {
    @Override
    public void rootsChanged(ModuleRootEvent event) {
      rootsCache = null;
    }
  });
}
 

public ProjectTreeBuilder(@Nonnull Project project,
                          @Nonnull JTree tree,
                          @Nonnull DefaultTreeModel treeModel,
                          @Nullable Comparator<NodeDescriptor> comparator,
                          @Nonnull ProjectAbstractTreeStructureBase treeStructure) {
  super(project, tree, treeModel, treeStructure, comparator);

  final MessageBusConnection connection = project.getMessageBus().connect(this);

  connection.subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootListener() {
    @Override
    public void rootsChanged(ModuleRootEvent event) {
      queueUpdate();
    }
  });

  connection.subscribe(BookmarksListener.TOPIC, new MyBookmarksListener());

  PsiManager.getInstance(project).addPsiTreeChangeListener(createPsiTreeChangeListener(project), this);
  FileStatusManager.getInstance(project).addFileStatusListener(new MyFileStatusListener(), this);
  CopyPasteManager.getInstance().addContentChangedListener(new CopyPasteUtil.DefaultCopyPasteListener(getUpdater()), this);

  connection.subscribe(ProblemListener.TOPIC, new MyProblemListener());

  setCanYieldUpdate(true);

  initRootNode();
}
 

@Override
public void rootsChanged(ModuleRootEvent event) {
  myUpdateQueue.cancelAllUpdates();
  myUpdateQueue.queue(new Update("RootsChanged") {
    @Override
    public void run() {
      refreshScope(getCurrentScope());
    }

    @Override
    public boolean isExpired() {
      return !isTreeShowing();
    }
  });
}
 

@Inject
public FileIsNotAttachedProvider(Project project, final EditorNotifications notifications)
{
	myProject = project;
	myProject.getMessageBus().connect().subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootListener()
	{
		@Override
		public void rootsChanged(ModuleRootEvent event)
		{
			notifications.updateAllNotifications();
		}
	});
	myProject.getMessageBus().connect().subscribe(ModuleExtension.CHANGE_TOPIC, (oldExtension, newExtension) -> notifications.updateAllNotifications());
}
 

@Inject
public SetupUnitySDKProvider(Project project, final EditorNotifications notifications)
{
	myProject = project;
	myProject.getMessageBus().connect().subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootListener()
	{
		@Override
		public void rootsChanged(ModuleRootEvent event)
		{
			notifications.updateAllNotifications();
		}
	});
	myProject.getMessageBus().connect().subscribe(ModuleExtension.CHANGE_TOPIC, (oldExtension, newExtension) -> notifications.updateAllNotifications());
}
 

@Inject
Unity3dProjectService(Project project)
{
	myProject = project;
	project.getMessageBus().connect().subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootListener()
	{
		@Override
		public void rootsChanged(ModuleRootEvent event)
		{
			myValue.drop();
		}
	});
}
 

private void listenForRootsChange() {
  if (myProject.isDefault() || !PantsUtil.isPantsProject(myProject)) {
    return;
  }
  final MessageBusConnection connection = myProject.getMessageBus().connect(this);
  connection.subscribe(
    ProjectTopics.PROJECT_ROOTS, new ModuleRootListener() {
      @Override
      public void rootsChanged(@NotNull ModuleRootEvent event) {
        myProjectRoots = null;
      }
    }
  );
}
 

public KnowledgeViewTreeBuilder(@Nonnull Project project,
                                @Nonnull JTree tree,
                                @Nonnull DefaultTreeModel treeModel,
                                @Nullable Comparator<NodeDescriptor> comparator,
                                @Nonnull KnowledgeViewPanelTreeStructure treeStructure) {
  super(project, tree, treeModel, treeStructure, comparator);

  final MessageBusConnection connection = project.getMessageBus().connect(this);

  connection.subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter() {
    @Override
    public void rootsChanged(ModuleRootEvent event) {
      queueUpdate();
    }
  });

  connection.subscribe(BookmarksListener.TOPIC, new MyBookmarksListener());

  PsiManager.getInstance(project).addPsiTreeChangeListener(createPsiTreeChangeListener(project), this);
  FileStatusManager.getInstance(project).addFileStatusListener(new MyFileStatusListener(), this);
  CopyPasteManager.getInstance().addContentChangedListener(new CopyPasteUtil.DefaultCopyPasteListener(getUpdater()), this);

  WolfTheProblemSolver.getInstance(project).addProblemListener(new MyProblemListener(), this);

  setCanYieldUpdate(true);

  initRootNode();
}
 

@Override
	public void rootsChanged(ModuleRootEvent moduleRootEvent) {
//		projectSourceRoots = ProjectRootManager.getInstance(project).getContentSourceRoots();
//		projectResourceRoots = new VirtualFile[0];
//		for (VirtualFile resourceRoot : WebResourcesPathsConfiguration.getInstance(project).getResourceDirectories()) {
//			projectResourceRoots = Arrays.copyOf(projectResourceRoots, projectResourceRoots.length + 1);
//			projectResourceRoots[projectResourceRoots.length - 1] = resourceRoot;
//		}
	}
 

@Override
public void rootsChanged(ModuleRootEvent event) {
  scheduleScan();
}
 

@Override
public void beforeRootsChange(ModuleRootEvent event) {}
 

@Override
public void rootsChanged(ModuleRootEvent event) {
  updateModel();
}
 

public boolean isRealRootChangedEvent(ModuleRootEvent moduleRootEvent) {
  if (fileTypeRegistrationAtStartup) return false;
  return true;
}
 

@Override
public void rootsChanged(ModuleRootEvent event) {
  if (myPanel != null) {
    myPanel.rootsChanged();
  }
}
 

@Override
public void beforeRootsChange(ModuleRootEvent event) {
}