import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
/**
 * Constructor
 *
 * @param appContext the IDE application context
 * @param resources the JSON Example resources that contain the action icon
 * @param asyncRequestFactory asynchronous request factory for creating the server request
 * @param notificationManager the notification manager used to display the lines of code per file
 */
@Inject
public CountLinesAction(
    AppContext appContext,
    JsonExampleResources resources,
    AsyncRequestFactory asyncRequestFactory,
    NotificationManager notificationManager) {

  super(
      appContext,
      "Count JSON Lines of Code",
      "Counts lines of code for all JSON Files in the project",
      resources.icon());

  this.appContext = appContext;
  this.asyncRequestFactory = asyncRequestFactory;
  this.notificationManager = notificationManager;
  this.unmarshaller = new StringMapUnmarshaller();
}
 

import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
/**
 * Constructor.
 *
 * @param appContext the {@link AppContext}
 * @param asyncRequestFactory the {@link AsyncRequestFactory} that is used to create requests
 * @param loaderFactory the {@link LoaderFactory} for displaying a message while waiting for a
 *     response
 */
@Inject
public MyServiceClient(
    final AppContext appContext,
    final AsyncRequestFactory asyncRequestFactory,
    final LoaderFactory loaderFactory) {

  this.appContext = appContext;
  this.asyncRequestFactory = asyncRequestFactory;
  this.loaderFactory = loaderFactory;
}
 

import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
@Inject
public TextEditorsViewPresenter(
        AppContext appContext,
        TextEditorsView textViewEditors,
        ResourceManager.ResourceManagerFactory resourceManagerFactory,
		EditorAgent editorAgent,
		EventBus eventBus) {
	this.textEditorsView = textViewEditors;

	this.resourceManagerFactory = resourceManagerFactory;
    resourceManager = resourceManagerFactory.newResourceManager(appContext.getDevMachine());
    this.editorAgent = editorAgent;

	eventBus.addHandler(FileEvent.TYPE, this);
	exportOpenEditor();
}
 

import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
@Inject
public BitbucketSshKeyProvider(
    @NotNull final BitbucketClientService bitbucketService,
    @NotNull @RestContext final String baseUrl,
    @NotNull final BitbucketLocalizationConstant constant,
    @NotNull final NotificationManager notificationManager,
    @NotNull final DialogFactory dialogFactory,
    AppContext appContext,
    @NotNull final SecurityTokenProvider securityTokenProvider) {

  this.bitbucketService = bitbucketService;
  this.baseUrl = baseUrl;
  this.constant = constant;
  this.notificationManager = notificationManager;
  this.dialogFactory = dialogFactory;
  this.appContext = appContext;
  this.securityTokenProvider = securityTokenProvider;
}
 

import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
@Inject
public MicrosoftHostingService(
    @RestContext final String baseUrl,
    AppContext appContext,
    DtoFactory dtoFactory,
    MicrosoftServiceClient microsoftClient,
    MicrosoftTemplates microsoftTemplates,
    SecurityTokenProvider securityTokenProvider) {
  this.baseUrl = baseUrl;
  this.appContext = appContext;
  this.dtoFactory = dtoFactory;
  this.microsoftClient = microsoftClient;
  this.microsoftTemplates = microsoftTemplates;
  this.securityTokenProvider = securityTokenProvider;
}
 

import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
/** Create presenter. */
@Inject
public ResetFilesPresenter(
    ResetFilesView view,
    GitServiceClient service,
    AppContext appContext,
    GitLocalizationConstant constant,
    NotificationManager notificationManager,
    DtoFactory dtoFactory,
    DialogFactory dialogFactory,
    GitOutputConsoleFactory gitOutputConsoleFactory,
    ProcessesPanelPresenter processesPanelPresenter) {
  this.view = view;
  this.dtoFactory = dtoFactory;
  this.dialogFactory = dialogFactory;
  this.gitOutputConsoleFactory = gitOutputConsoleFactory;
  this.consolesPanelPresenter = processesPanelPresenter;
  this.view.setDelegate(this);
  this.service = service;
  this.appContext = appContext;
  this.constant = constant;
  this.notificationManager = notificationManager;
}
 

import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
@Inject
public SshKeyManagerPresenter(
    SshKeyManagerView view,
    SshServiceClient service,
    AppContext appContext,
    SshKeyLocalizationConstant constant,
    UploadSshKeyPresenter uploadSshKeyPresenter,
    NotificationManager notificationManager,
    DialogFactory dialogFactory,
    SshKeyUploaderRegistry registry,
    ShowSshKeyView showSshKeyView) {
  super(constant.sshManagerTitle(), constant.sshManagerCategory());

  this.view = view;
  this.appContext = appContext;
  this.dialogFactory = dialogFactory;
  this.registry = registry;
  this.showSshKeyView = showSshKeyView;
  this.view.setDelegate(this);
  this.service = service;
  this.constant = constant;
  this.uploadSshKeyPresenter = uploadSshKeyPresenter;
  this.notificationManager = notificationManager;
  this.hostNameValidator = new HostNameValidator();
}
 

import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
@Inject
public CreateCSharpSourceFileAction(
    CSharpLocalizationConstant localizationConstant,
    CSharpResources resources,
    DialogFactory dialogFactory,
    CoreLocalizationConstant coreLocalizationConstant,
    EventBus eventBus,
    AppContext appContext,
    NotificationManager notificationManager,
    Provider<EditorAgent> editorAgentProvider) {
  super(
      localizationConstant.createCSharpFileActionTitle(),
      localizationConstant.createCSharpFileActionDescription(),
      resources.csharpFile(),
      dialogFactory,
      coreLocalizationConstant,
      eventBus,
      appContext,
      notificationManager,
      editorAgentProvider);
}
 

import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
@Inject
public DebugTestNgTestAction(
    TestNgResources resources,
    TestDetector testDetector,
    TestServiceClient client,
    TestingHandler testingHandler,
    DtoFactory dtoFactory,
    NotificationManager notificationManager,
    DebugConfigurationsManager debugConfigurationsManager,
    AppContext appContext,
    TestResultPresenter testResultPresenter,
    TestNgLocalizationConstant localization) {
  super(
      testDetector,
      testResultPresenter,
      testingHandler,
      debugConfigurationsManager,
      client,
      dtoFactory,
      appContext,
      notificationManager,
      singletonList(PROJECT_PERSPECTIVE_ID),
      localization.actionDebugDescription(),
      localization.actionDebugTestTitle(),
      resources.testIcon());
}
 

import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
@Inject
public NewJavaScriptFileAction(
    WebLocalizationConstant localizationConstant,
    DialogFactory dialogFactory,
    CoreLocalizationConstant coreLocalizationConstant,
    EventBus eventBus,
    AppContext appContext,
    NotificationManager notificationManager,
    Provider<EditorAgent> editorAgentProvider) {
  super(
      localizationConstant.newJavaScriptFileActionTitle(),
      localizationConstant.newJavaScriptFileActionDescription(),
      null,
      dialogFactory,
      coreLocalizationConstant,
      eventBus,
      appContext,
      notificationManager,
      editorAgentProvider);
}
 

import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
@Inject
public AddToIndexPresenter(
    AddToIndexView view,
    AppContext appContext,
    GitLocalizationConstant constant,
    GitOutputConsoleFactory gitOutputConsoleFactory,
    ProcessesPanelPresenter processesPanelPresenter,
    GitServiceClient service,
    NotificationManager notificationManager) {
  this.view = view;
  this.view.setDelegate(this);
  this.service = service;
  this.constant = constant;
  this.appContext = appContext;
  this.notificationManager = notificationManager;
  this.gitOutputConsoleFactory = gitOutputConsoleFactory;
  this.consolesPanelPresenter = processesPanelPresenter;
}
 

import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
@Inject
public GitHubHostingService(
    @NotNull final AppContext appContext,
    @NotNull final DtoFactory dtoFactory,
    @NotNull final GitHubServiceClient gitHubClientService,
    @NotNull final GitHubTemplates templates,
    SecurityTokenProvider securityTokenProvider,
    OAuthServiceClient oAuthServiceClient) {
  this.appContext = appContext;
  this.dtoFactory = dtoFactory;
  this.gitHubClientService = gitHubClientService;
  this.templates = templates;
  this.baseUrl = appContext.getMasterApiEndpoint();
  this.securityTokenProvider = securityTokenProvider;
  this.oAuthServiceClient = oAuthServiceClient;
}
 

import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
@Inject
public CategoriesPagePresenter(
    CategoriesPageView view,
    ProjectTypeRegistry projectTypeRegistry,
    ProjectTemplateRegistry projectTemplateRegistry,
    ProjectWizardRegistry wizardRegistry,
    PreSelectedProjectTypeManager preSelectedProjectTypeManager,
    SelectPathPresenter selectPathPresenter,
    AppContext appContext) {
  super();
  this.view = view;
  this.projectTypeRegistry = projectTypeRegistry;
  this.projectTemplateRegistry = projectTemplateRegistry;
  this.wizardRegistry = wizardRegistry;
  this.preSelectedProjectTypeManager = preSelectedProjectTypeManager;
  this.selectPathPresenter = selectPathPresenter;
  this.appContext = appContext;

  view.setDelegate(this);
  loadProjectTypesAndTemplates();
}
 

import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
@Inject
public ProjectTypeRegistryImpl(
    AsyncRequestFactory asyncRequestFactory,
    DtoUnmarshallerFactory dtoUnmarshallerFactory,
    AppContext appContext,
    EventBus eventBus) {
  this.asyncRequestFactory = asyncRequestFactory;
  this.dtoUnmarshallerFactory = dtoUnmarshallerFactory;
  this.appContext = appContext;
  this.eventBus = eventBus;

  projectTypes = new HashMap<>();

  eventBus.addHandler(
      BasicIDEInitializedEvent.TYPE,
      e -> {
        if (RUNNING == appContext.getWorkspace().getStatus()) {
          registerProjectTypes();
        }
      });

  eventBus.addHandler(WsAgentServerRunningEvent.TYPE, e -> registerProjectTypes());
  eventBus.addHandler(WsAgentServerStoppedEvent.TYPE, e -> projectTypes.clear());
}
 

import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
@Inject
public SourceEntryPresenter(
    SourceEntryView view,
    DtoFactory dtoFactory,
    ClasspathContainer classpathContainer,
    ClasspathResolver classpathResolver,
    JavaLocalizationConstant localization,
    AppContext appContext,
    SelectNodePresenter selectNodePresenter) {
  super(localization.sourcePropertyName(), localization.javaBuildPathCategory(), null);
  this.view = view;
  this.dtoFactory = dtoFactory;
  this.classpathContainer = classpathContainer;
  this.classpathResolver = classpathResolver;
  this.appContext = appContext;
  this.selectNodePresenter = selectNodePresenter;

  categories = new TreeMap<>();
  dirty = false;

  view.setDelegate(this);
}
 

import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
@Inject
public MatchNode(
    TreeStyles styles,
    JavaResources resources,
    EditorAgent editorAgent,
    AppContext appContext,
    @Assisted Match match,
    @Nullable @Assisted CompilationUnit compilationUnit,
    @Nullable @Assisted ClassFile classFile,
    JavaNavigationService service) {
  this.styles = styles;
  this.resources = resources;
  this.editorAgent = editorAgent;
  this.appContext = appContext;
  this.match = match;
  this.compilationUnit = compilationUnit;
  this.classFile = classFile;
  this.service = service;
}
 

import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
@Inject
public InitialProjectImporter(
    ImportProjectNotificationSubscriberFactory subscriberFactory,
    AppContext appContext,
    OAuth2AuthenticatorRegistry oAuth2AuthenticatorRegistry,
    ProjectImportOutputJsonRpcNotifier subscriber,
    NotificationManager notificationManager,
    CoreLocalizationConstant locale,
    AskCredentialsDialog askCredentialsDialog,
    DialogFactory dialogFactory,
    PromiseProvider promises,
    EventBus eventBus) {

  super(appContext, subscriberFactory);

  this.oAuth2AuthenticatorRegistry = oAuth2AuthenticatorRegistry;
  this.subscriber = subscriber;
  this.notificationManager = notificationManager;
  this.locale = locale;
  this.askCredentialsDialog = askCredentialsDialog;
  this.dialogFactory = dialogFactory;
  this.promises = promises;

  eventBus.addHandler(WorkspaceReadyEvent.getType(), e -> importProjects());
}
 

import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
@Inject
public NewHtmlFileAction(
    WebLocalizationConstant localizationConstant,
    DialogFactory dialogFactory,
    CoreLocalizationConstant coreLocalizationConstant,
    EventBus eventBus,
    AppContext appContext,
    NotificationManager notificationManager,
    Provider<EditorAgent> editorAgentProvider) {
  super(
      localizationConstant.newHtmlFileActionTitle(),
      localizationConstant.newHtmlFileActionDescription(),
      null,
      dialogFactory,
      coreLocalizationConstant,
      eventBus,
      appContext,
      notificationManager,
      editorAgentProvider);
}
 

import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
@Inject
public AddToIndexAction(
    AddToIndexPresenter presenter,
    AppContext appContext,
    GitLocalizationConstant constant,
    GitOutputConsoleFactory gitOutputConsoleFactory,
    ProcessesPanelPresenter consolesPanelPresenter,
    GitServiceClient service,
    NotificationManager notificationManager) {
  super(
      constant.addToIndexTitle(),
      constant.addToIndexTitle(),
      FontAwesome.PLUS_CIRCLE,
      appContext);
  this.presenter = presenter;
  this.constant = constant;
  this.gitOutputConsoleFactory = gitOutputConsoleFactory;
  this.consolesPanelPresenter = consolesPanelPresenter;
  this.service = service;
  this.notificationManager = notificationManager;
}
 

import org.eclipse.che.ide.api.app.AppContext; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public boolean isCutEnable(AppContext appContext) {
  final Resource[] resources = appContext.getResources();

  // check general state
  if (resources == null || resources.length == 0) {
    return false;
  }

  for (Resource resource : resources) {
    // if there is at least one root project
    if (resource.getResourceType() == PROJECT && resource.getLocation().segmentCount() == 1) {
      return false;
    }
  }

  return true;
}