Java ModuleRootEvent类代码示例

import com.intellij.openapi.roots.ModuleRootEvent; //导入依赖的package包/类
@Override
public void rootsChanged( ModuleRootEvent event )
{
  Project project = (Project)event.getSource();
  if( !shouldProcessRootChanges( project ) )
  {
    return;
  }
  boolean processDependencies = true;

  if( processDependencies )
  {
    processModuleDependenciesChange( project );
  }

  final Module[] modules = ModuleManager.getInstance( project ).getModules();
  for( Module ijModule : modules )
  {
    ManModule manModule = ManProject.getModule( ijModule );
    processClasspathChange( manModule, ijModule );
    changeSourceRoots( manModule );
  }
}
 

import com.intellij.openapi.roots.ModuleRootEvent; //导入依赖的package包/类
/**
 * 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();
    }
  });
}
 

import com.intellij.openapi.roots.ModuleRootEvent; //导入依赖的package包/类
@Override
public void projectOpened() {
  final ModuleRootListener rootListener = new ModuleRootAdapter() {
    public void rootsChanged(ModuleRootEvent event) {
      if (!myProject.isDisposed()) {
        checkToolWindowStatuses(myProject);
      }
    }
  };

  StartupManager.getInstance(myProject).runWhenProjectIsInitialized(new Runnable() {
    public void run() {
      if (!myProject.isDisposed()) {
        checkToolWindowStatuses(myProject);
        final MessageBusConnection connection = myProject.getMessageBus().connect(myProject);
        connection.subscribe(ProjectTopics.PROJECT_ROOTS, rootListener);
      }
    }
  });
}
 

import com.intellij.openapi.roots.ModuleRootEvent; //导入依赖的package包/类
@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);
    }
  });
  final WolfTheProblemSolver.ProblemListener myProblemListener = new MyProblemListener();
  WolfTheProblemSolver.getInstance(myProject).addProblemListener(myProblemListener,myProject);
}
 

import com.intellij.openapi.roots.ModuleRootEvent; //导入依赖的package包/类
@Override
public void rootsChanged(ModuleRootEvent event) {
  if (myToolWindowForm == null || !myToolWindowReady || myToolWindowDisposed) {
    return;
  }

  final PsiFile file = myToolWindowForm.getFile();
  if (file != null) {
    final Module module = ModuleUtilCore.findModuleForPsiElement(file);
    if (module != null) {
      final Sdk prevSdk = myModule2Sdk.get(module);
      final Sdk newSdk = ModuleRootManager.getInstance(module).getSdk();
      if (newSdk != null &&
          (newSdk.getSdkType() instanceof AndroidSdkType || (prevSdk != null && prevSdk.getSdkType() instanceof AndroidSdkType)) &&
          !newSdk.equals(prevSdk)) {
        render();
      }
    }
  }

  updateMap();
}
 

import com.intellij.openapi.roots.ModuleRootEvent; //导入依赖的package包/类
private void addProjectPropertiesUpdatingListener() {
  myProject.getMessageBus().connect(myDisposable).subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter() {
    @Override
    public void rootsChanged(final ModuleRootEvent event) {
      ApplicationManager.getApplication().invokeLater(new Runnable() {
        @Override
        public void run() {
          StartupManager.getInstance(myProject).runWhenProjectIsInitialized(new Runnable() {
            @Override
            public void run() {
              updatePropertyFilesIfNecessary();
            }
          });
        }
      }, myProject.getDisposed());
    }
  });
}
 

import com.intellij.openapi.roots.ModuleRootEvent; //导入依赖的package包/类
@Override
public void initFacet() {
  MessageBusConnection connection = getModule().getMessageBus().connect(this);
  connection.subscribe(PROJECT_ROOTS, new ModuleRootAdapter() {
    @Override
    public void rootsChanged(ModuleRootEvent event) {
      ApplicationManager.getApplication().invokeLater(new Runnable() {
        @Override
        public void run() {
          if (!isDisposed()) {
            PsiDocumentManager.getInstance(getModule().getProject()).commitAllDocuments();
            updateConfiguration();
          }
        }
      });
    }
  });
  updateConfiguration();
}
 

import com.intellij.openapi.roots.ModuleRootEvent; //导入依赖的package包/类
@Override
public void initFacet() {
  MessageBusConnection connection = getModule().getMessageBus().connect(this);
  connection.subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter() {
    @Override
    public void rootsChanged(ModuleRootEvent event) {
      ApplicationManager.getApplication().invokeLater(new Runnable() {
        @Override
        public void run() {
          if (!isDisposed()) {
            PsiDocumentManager.getInstance(getModule().getProject()).commitAllDocuments();
            updateConfiguration();
          }
        }
      });
    }
  });
  updateConfiguration();
}
 

import com.intellij.openapi.roots.ModuleRootEvent; //导入依赖的package包/类
@Override
public void rootsChanged(ModuleRootEvent event) {
  final ToolWindow window = ToolWindowManager.getInstance(myProject).getToolWindow(TOOL_WINDOW_ID);
  if (window == null) {
    return;
  }

  if (window.isDisposed() || !window.isVisible()) {
    return;
  }

  AndroidPlatform newPlatform = getPlatform();

  if (!Comparing.equal(myPrevPlatform, newPlatform)) {
    myPrevPlatform = newPlatform;
    ApplicationManager.getApplication().invokeLater(new Runnable() {
      @Override
      public void run() {
        if (!window.isDisposed() && window.isVisible()) {
          myView.activate();
        }
      }
    });
  }
}
 

import com.intellij.openapi.roots.ModuleRootEvent; //导入依赖的package包/类
public LoaderFactory(final Project project) {
  myProject = project;
  myModule2ClassLoader = ContainerUtil.createConcurrentWeakMap();
  myConnection = myProject.getMessageBus().connect();
  myConnection.subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter() {
    public void rootsChanged(final ModuleRootEvent event) {
      clearClassLoaderCache();
    }
  });

  Disposer.register(project, new Disposable() {
    public void dispose() {
      myConnection.disconnect();
      myModule2ClassLoader.clear();
    }
  });
}
 

import com.intellij.openapi.roots.ModuleRootEvent; //导入依赖的package包/类
public ConfigureGroovyLibraryNotificationProvider(Project project, final EditorNotifications notifications) {
  myProject = project;
  project.getMessageBus().connect(project).subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter() {
    @Override
    public void rootsChanged(ModuleRootEvent event) {
      notifications.updateAllNotifications();
    }
  });

  supportedFileTypes = new HashSet<FileType>();
  supportedFileTypes.add(GroovyFileType.GROOVY_FILE_TYPE);

  for (GroovyFrameworkConfigNotification configNotification : GroovyFrameworkConfigNotification.EP_NAME.getExtensions()) {
    Collections.addAll(supportedFileTypes, configNotification.getFrameworkFileTypes());
  }
}
 

import com.intellij.openapi.roots.ModuleRootEvent; //导入依赖的package包/类
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();
      }
    }
  );
}
 

import com.intellij.openapi.roots.ModuleRootEvent; //导入依赖的package包/类
@Override
public void projectOpened() {
  super.projectOpened();
  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(ModuleRootEvent event) {
        myProjectRoots = null;
      }
    }
  );
}
 

import com.intellij.openapi.roots.ModuleRootEvent; //导入依赖的package包/类
public Unity3dProjectChangeListener(@NotNull Project project, @NotNull StartupManager startupManager)
{
	myProject = project;

	for(Unity3dProjectSourceFileTypeFactory factory : Unity3dProjectSourceFileTypeFactory.EP_NAME.getExtensions())
	{
		factory.registerFileTypes(mySourceFileTypes::add);
	}

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

	VirtualFileManager.getInstance().addVirtualFileListener(this, this);

	myAssetsDirPointer = VirtualFilePointerManager.getInstance().create(StandardFileSystems.FILE_PROTOCOL_PREFIX + myProject.getPresentableUrl() + "/" + Unity3dProjectImportUtil
			.ASSETS_DIRECTORY, this, null);

	startupManager.registerPostStartupActivity(this::checkAndRunIfNeed);
}
 

import com.intellij.openapi.roots.ModuleRootEvent; //导入依赖的package包/类
@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() || !DirectoryIndex.getInstance(myProject).isInitialized()) return;
          VcsDirtyScopeManager.getInstance(myProject).markEverythingDirty();
        }
      }, ModalityState.NON_MODAL);
    }
  });
  final WolfTheProblemSolver.ProblemListener myProblemListener = new MyProblemListener();
  WolfTheProblemSolver.getInstance(myProject).addProblemListener(myProblemListener,myProject);
}